SLIDE 1
Succinct Trie Indexes Made Practical
Huanchen Zhang
David G. Andersen, Michael Kaminsky, Andrew Pavlo, Kimberly Keeton
Succinct Trie Indexes Made Practical Huanchen Zhang David G. - - PowerPoint PPT Presentation
Succinct Trie Indexes Made Practical Huanchen Zhang David G. - - PowerPoint PPT Presentation
Succinct Trie Indexes Made Practical Huanchen Zhang David G. Andersen, Michael Kaminsky, Andrew Pavlo, Kimberly Keeton DRAM price wont fall forever Price Year Memory-efficient data structures are helpful Smaller data structures More
SLIDE 2
SLIDE 3
Memory-efficient data structures are helpful More data resident in faster memory Better performance + lower costs Smaller data structures
SLIDE 4
The limit: information-theoretic lower bound (ITLB)
The minimum # of bits required to distinguish any
- bject in a class
|S| = n !"#2% bits
SLIDE 5
The limit: information-theoretic lower bound (ITLB)
The minimum # of bits required to distinguish any
- bject in a class
|S| = n !"#2% bits |n-node trie of degree k| = ⁄
'()* (
+% + 1
% !"#2+ − (+ − 1)!"#2(+ − 1) bits
SLIDE 6
The limit: information-theoretic lower bound (ITLB)
The minimum # of bits required to distinguish any
- bject in a class
|S| = n !"#2% bits |n-node trie of degree k| 256 9.44n = ⁄
'()* (
+% + 1
% !"#2+ − (+ − 1)!"#2(+ − 1) bits
SLIDE 7
The limit: information-theoretic lower bound (ITLB)
The minimum # of bits required to distinguish any
- bject in a class
|S| = n !"#2% bits |n-node trie of degree k| 256 9.44n = ⁄
'()* (
+% + 1
% !"#2+ − (+ − 1)!"#2(+ − 1) bits
FST = 10n
SLIDE 8
Succinct Data Structures
Use # of bits close to ITLB Implicit: Succinct: Compact: L + O(1) L + o(L) O(L) Suppose ITLB = L bits
FST
SLIDE 9
Why aren’t succinct data structures popular? Read-only Slow Complex Log-structured design
SLIDE 10
Existing succinct tries are slow
1 2 3
us GB
0.5 1.5 1 ART tx-trie PDT
Lookup Latency
50M 64-bit integer keys
Memory
including key suffixes
ART tx-trie PDT
SLIDE 11
Fast Succinct Trie (FST) is fast and small
1 2 3
us GB
0.5 1.5 1 ART tx-trie PDT FST
Lookup Latency
ART tx-trie PDT FST 50M 64-bit integer keys
Memory
including key suffixes
SLIDE 12
Encoding Mechanism
SLIDE 13
3 ways to succinctly encode ordinal trees
1 2 3 4 5 6 7 8 9 A B C D E
Ordinal tree: a rooted tree where each node can have an arbitrary # of children in order
SLIDE 14
3 ways to succinctly encode ordinal trees
1 2 3 4 5 6 7 8 9 A B C D E
|n-node ordinal tree| = Cn =
! "#! $" "
≈ 2' bits
SLIDE 15
3 ways to succinctly encode ordinal trees
1 2 3 4 5 6 7 8 9 A B C D E
110 10 110 1110 110 110 10 10 LOUDS: level-ordered unary degree sequence
SLIDE 16
3 ways to succinctly encode ordinal trees
1 2 3 4 5 6 7 8 9 A B C D E
110 10 110 1110 110 110 10 10 110 10 110 1110 110 110 0 10 0 0 0 10 0 0 0 LOUDS:
SLIDE 17
3 ways to succinctly encode ordinal trees
1 2 3 4 5 6 7 8 9 A B C D E
BP: balanced parenthesis
SLIDE 18
3 ways to succinctly encode ordinal trees
1 2 3 4 5 6 7 8 9 A B C D E
BP: ( ( ( ( ) ( ( ) ) ( ) ) ) ( ( ( ) ( ) ) ( ( ( ) ) ( ) ) ) )
SLIDE 19
3 ways to succinctly encode ordinal trees
1 2 3 4 5 6 7 8 9 A B C D E
BP: ( ( ( ( ) ( ( ) ) ( ) ) ) ( ( ( ) ( ) ) ( ( ( ) ) ( ) ) ) )
D 6 8 7 3 1 9 A 4 E B C 5 2
SLIDE 20
3 ways to succinctly encode ordinal trees
1 2 3 4 5 6 7 8 9 A B C D E
DFUDS: depth-first unary degree sequence
SLIDE 21
3 ways to succinctly encode ordinal trees
1 2 3 4 5 6 7 8 9 A B C D E
DFUDS: ( ( ) ( ) ( ( ( ) ) ( ) ) ) ( ( ) ( ( ) ) ) ( ( ) ( ) ) )
SLIDE 22
3 ways to succinctly encode ordinal trees
1 2 3 4 5 6 7 8 9 A B C D E
DFUDS: ( ( ) ( ) ( ( ( ) ) ( ) ) ) ( ( ) ( ( ) ) ) ( ( ) ( ) ) )
1 3 6 7 D 8 2 4 9 A 5 B E C
SLIDE 23
LOUDS-Sparse: succinctly encode tries
f t s $ a
- r
r t s y p i y $ t e p
v2 v1 v3 v8 v9 v10 v11 v4 v5 v6 v7 f s t $ a o r r s t y p i y $ t e p L: 1010 1 110 100 0 10 000 0 HC: 1001 0 101001 0 10 101 0 S: V:
v1 v2 v3 v4v5v6 v7v8v9v10v11
SLIDE 24
LOUDS-Sparse: succinctly encode tries
f t s $ a
- r
r t s y p i y $ t e p
v2 v1 v3 v8 v9 v10 v11 v4 v5 v6 v7 f s t $ a o r r s t y p i y $ t e p L: 1010 1 110 100 0 10 000 0 HC: 1001 0 101001 0 10 101 0 S: V:
v1 v2 v3 v4v5v6 v7v8v9v10v11
Why LOUDS?
- 1. Fast tree nav.
- 2. Good label locality
- 3. Easy implementation
SLIDE 25
Rank & select on bit-vectors
1 0 0 1 0 1 0 1 0 0 1 0 1 0 1 0 1 0 bv: rank(bv, i) = select(bv, i) = # of 1’s in bv up to position i position of the ith 1 in bv rank(bv, 7) = 4 Examples: select(bv, 7) = 14
5 10 15
SLIDE 26
Compute rank & select in constant time
The classic algorithm for computing rank bv
SLIDE 27
Compute rank & select in constant time
The classic algorithm for computing rank bv
…
!"#$ bits super block =
SLIDE 28
Compute rank & select in constant time
The classic algorithm for computing rank bv
…
… …
! "#$% bits basic block = #$"% bits super block =
SLIDE 29
Compute rank & select in constant time
The classic algorithm for computing rank bv
…
… …
! "#$% bits basic block = #$"% bits super block = per super block cumulative rank
SLIDE 30
Compute rank & select in constant time
The classic algorithm for computing rank bv
…
… …
! "#$% bits basic block = #$"% bits super block = per super block cumulative rank per basic block rank in super block
SLIDE 31
Compute rank & select in constant time
The classic algorithm for computing rank bv
…
… …
! "#$% bits basic block = #$"% bits super block = per super block cumulative rank per basic block rank in super block within super block all possible queries
SLIDE 32
Compute rank & select in constant time
The classic algorithm for computing rank bv
…
… …
! "#$% bits basic block = #$"% bits super block = per super block cumulative rank per basic block rank in super block within super block all possible queries & '(2*
SLIDE 33
Compute rank & select in constant time
The classic algorithm for computing rank bv
…
… …
! "#$% bits basic block = #$"% bits super block = per super block cumulative rank per basic block rank in super block within super block all possible queries & '(2* &
! "'(*
SLIDE 34
Compute rank & select in constant time
The classic algorithm for computing rank bv
…
… …
! "#$% bits basic block = #$"% bits super block = per super block cumulative rank per basic block rank in super block within super block all possible queries & '(2* &
! "'(*
remaining bits
SLIDE 35
Compute rank & select in constant time
The classic algorithm for computing rank bv
…
… …
! "#$% bits basic block = #$"% bits super block = per super block cumulative rank per basic block rank in super block within super block all possible queries & '(2* &
! "'(*
remaining bits
O(1) time
SLIDE 36
Compute rank & select in constant time
The classic algorithm for computing rank bv
…
… …
! "#$% bits basic block = #$"% bits super block =
O( %
#$%)
O( %
#$% ()()*)
per super block cumulative rank per basic block rank in super block within super block all possible queries
O( * ()* ()()*)
- (*)
+ ()2* +
! "()*
remaining bits
space:
O(1) time
SLIDE 37
Compute rank & select in constant time
The classic algorithm for computing rank Select is similar but trickier, often based on rank structures bv
…
… …
! "#$% bits basic block = #$"% bits super block =
O( %
#$%)
O( %
#$% ()()*)
per super block cumulative rank per basic block rank in super block within super block all possible queries
O( * ()* ()()*)
- (*)
+ ()2* +
! "()*
remaining bits
space:
O(1) time
SLIDE 38
Tree navigation relies on rank & select
f t s $ a
- r
r t s y p i y $ t e p
v2 v1 v3 v8 v9 v10 v11 v4 v5 v6 v7 f s t $ a o r r s t y p i y $ t e p L: 1010 1 110 100 0 10 000 0 HC: 1001 0 101001 0 10 101 0 S: V:
v1 v2 v3 v4v5v6 v7v8v9v10v11
child(i) = select(S, rank(HC, i)+1) parent(i) = select(S, rank(S, i)-1) value(i) = i - rank(HC, i)
5 10 15
SLIDE 39
Tree navigation relies on rank & select
f t s $ a
- r
r t s y p i y $ t e p
v2 v1 v3 v8 v9 v10 v11 v4 v5 v6 v7 f s t $ a o r r s t y p i y $ t e p L: 1010 1 110 100 0 10 000 0 HC: 1001 0 101001 0 10 101 0 S: V:
v1 v2 v3 v4v5v6 v7v8v9v10v11
child(i) = select(S, rank(HC, i)+1) parent(i) = select(S, rank(S, i)-1) value(i) = i - rank(HC, i)
5 10 15
SLIDE 40
Tree navigation relies on rank & select
f t s $ a
- r
r t s y p i y $ t e p
v2 v1 v3 v8 v9 v10 v11 v4 v5 v6 v7 f s t $ a o r r s t y p i y $ t e p L: 1010 1 110 100 0 10 000 0 HC: 1001 0 101001 0 10 101 0 S: V:
v1 v2 v3 v4v5v6 v7v8v9v10v11
child(i) = select(S, rank(HC, i)+1) value(i) = i - rank(HC, i)
5 10 15
SLIDE 41
Tree navigation relies on rank & select
f t s $ a
- r
r t s y p i y $ t e p
v2 v1 v3 v8 v9 v10 v11 v4 v5 v6 v7 f s t $ a o r r s t y p i y $ t e p L: 1010 1 110 100 0 10 000 0 HC: 1001 0 101001 0 10 101 0 S: V:
v1 v2 v3 v4v5v6 v7v8v9v10v11
child(i) = select(S, rank(HC, i)+1) value(i) = i - rank(HC, i)
5 10 15
SLIDE 42
Tree navigation relies on rank & select
f t s $ a
- r
r t s y p i y $ t e p
v2 v1 v3 v8 v9 v10 v11 v4 v5 v6 v7 f s t $ a o r r s t y p i y $ t e p L: 1010 1 110 100 0 10 000 0 HC: 1001 0 101001 0 10 101 0 S: V:
v1 v2 v3 v4v5v6 v7v8v9v10v11
child(i) = select(S, rank(HC, i)+1) value(i) = i - rank(HC, i)
5 10 15
SLIDE 43
Tree navigation relies on rank & select
f t s $ a
- r
r t s y p i y $ t e p
v2 v1 v3 v8 v9 v10 v11 v4 v5 v6 v7 f s t $ a o r r s t y p i y $ t e p L: 1010 1 110 100 0 10 000 0 HC: 1001 0 101001 0 10 101 0 S: V:
v1 v2 v3 v4v5v6 v7v8v9v10v11
child(i) = select(S, rank(HC, i)+1) value(i) = i - rank(HC, i)
2 2
5 10 15
SLIDE 44
Tree navigation relies on rank & select
f t s $ a
- r
r t s y p i y $ t e p
v2 v1 v3 v8 v9 v10 v11 v4 v5 v6 v7 f s t $ a o r r s t y p i y $ t e p L: 1010 1 110 100 0 10 000 0 HC: 1001 0 101001 0 10 101 0 S: V:
v1 v2 v3 v4v5v6 v7v8v9v10v11
child(i) = select(S, rank(HC, i)+1) value(i) = i - rank(HC, i)
3
5 10 15
SLIDE 45
Tree navigation relies on rank & select
f t s $ a
- r
r t s y p i y $ t e p
v2 v1 v3 v8 v9 v10 v11 v4 v5 v6 v7 f s t $ a o r r s t y p i y $ t e p L: 1010 1 110 100 0 10 000 0 HC: 1001 0 101001 0 10 101 0 S: V:
v1 v2 v3 v4v5v6 v7v8v9v10v11
child(i) = select(S, rank(HC, i)+1) value(i) = i - rank(HC, i)
5
5 10 15
SLIDE 46
Tree navigation relies on rank & select
f t s $ a
- r
r t s y p i y $ t e p
v2 v1 v3 v8 v9 v10 v11 v4 v5 v6 v7 f s t $ a o r r s t y p i y $ t e p L: 1010 1 110 100 0 10 000 0 HC: 1001 0 101001 0 10 101 0 S: V:
v1 v2 v3 v4v5v6 v7v8v9v10v11
child(i) = select(S, rank(HC, i)+1) value(i) = i - rank(HC, i)
5
5 10 15
SLIDE 47
Tree navigation relies on rank & select
f t s $ a
- r
r t s y p i y $ t e p
v2 v1 v3 v8 v9 v10 v11 v4 v5 v6 v7 f s t $ a o r r s t y p i y $ t e p L: 1010 1 110 100 0 10 000 0 HC: 1001 0 101001 0 10 101 0 S: V:
v1 v2 v3 v4v5v6 v7v8v9v10v11
child(i) = select(S, rank(HC, i)+1) value(i) = i - rank(HC, i)
5 10 15
SLIDE 48
Tree navigation relies on rank & select
f t s $ a
- r
r t s y p i y $ t e p
v2 v1 v3 v8 v9 v10 v11 v4 v5 v6 v7 f s t $ a o r r s t y p i y $ t e p L: 1010 1 110 100 0 10 000 0 HC: 1001 0 101001 0 10 101 0 S: V:
v1 v2 v3 v4v5v6 v7v8v9v10v11
child(i) = select(S, rank(HC, i)+1) value(i) = i - rank(HC, i)
6 6
5 10 15
SLIDE 49
Tree navigation relies on rank & select
f t s $ a
- r
r t s y p i y $ t e p
v2 v1 v3 v8 v9 v10 v11 v4 v5 v6 v7 f s t $ a o r r s t y p i y $ t e p L: 1010 1 110 100 0 10 000 0 HC: 1001 0 101001 0 10 101 0 S: V:
v1 v2 v3 v4v5v6 v7v8v9v10v11
child(i) = select(S, rank(HC, i)+1) value(i) = i - rank(HC, i)
6
5 10 15
SLIDE 50
Tree navigation relies on rank & select
f t s $ a
- r
r t s y p i y $ t e p
v2 v1 v3 v8 v9 v10 v11 v4 v5 v6 v7 f s t $ a o r r s t y p i y $ t e p L: 1010 1 110 100 0 10 000 0 HC: 1001 0 101001 0 10 101 0 S: V:
v1 v2 v3 v4v5v6 v7v8v9v10v11
child(i) = select(S, rank(HC, i)+1) value(i) = i - rank(HC, i)
12
5 10 15
SLIDE 51
Tree navigation relies on rank & select
f t s $ a
- r
r t s y p i y $ t e p
v2 v1 v3 v8 v9 v10 v11 v4 v5 v6 v7 f s t $ a o r r s t y p i y $ t e p L: 1010 1 110 100 0 10 000 0 HC: 1001 0 101001 0 10 101 0 S: V:
v1 v2 v3 v4v5v6 v7v8v9v10v11
child(i) = select(S, rank(HC, i)+1) value(i) = i - rank(HC, i)
12
5 10 15
SLIDE 52
Tree navigation relies on rank & select
f t s $ a
- r
r t s y p i y $ t e p
v2 v1 v3 v8 v9 v10 v11 v4 v5 v6 v7 f s t $ a o r r s t y p i y $ t e p L: 1010 1 110 100 0 10 000 0 HC: 1001 0 101001 0 10 101 0 S: V:
v1 v2 v3 v4v5v6 v7v8v9v10v11
child(i) = select(S, rank(HC, i)+1) value(i) = i - rank(HC, i)
12 12
5 10 15
SLIDE 53
Tree navigation relies on rank & select
f t s $ a
- r
r t s y p i y $ t e p
v2 v1 v3 v8 v9 v10 v11 v4 v5 v6 v7 f s t $ a o r r s t y p i y $ t e p L: 1010 1 110 100 0 10 000 0 HC: 1001 0 101001 0 10 101 0 S: V:
v1 v2 v3 v4v5v6 v7v8v9v10v11
child(i) = select(S, rank(HC, i)+1) value(i) = i - rank(HC, i)
8
5 10 15
SLIDE 54
Tree navigation relies on rank & select
f t s $ a
- r
r t s y p i y $ t e p
v2 v1 v3 v8 v9 v10 v11 v4 v5 v6 v7 f s t $ a o r r s t y p i y $ t e p L: 1010 1 110 100 0 10 000 0 HC: 1001 0 101001 0 10 101 0 S: V:
v1 v2 v3 v4v5v6 v7v8v9v10v11
child(i) = select(S, rank(HC, i)+1) value(i) = i - rank(HC, i)
16
5 10 15
SLIDE 55
Tree navigation relies on rank & select
f t s $ a
- r
r t s y p i y $ t e p
v2 v1 v3 v8 v9 v10 v11 v4 v5 v6 v7 f s t $ a o r r s t y p i y $ t e p L: 1010 1 110 100 0 10 000 0 HC: 1001 0 101001 0 10 101 0 S: V:
v1 v2 v3 v4v5v6 v7v8v9v10v11
child(i) = select(S, rank(HC, i)+1) value(i) = i - rank(HC, i)
16
5 10 15
SLIDE 56
Tree navigation relies on rank & select
f t s $ a
- r
r t s y p i y $ t e p
v2 v1 v3 v8 v9 v10 v11 v4 v5 v6 v7 f s t $ a o r r s t y p i y $ t e p L: 1010 1 110 100 0 10 000 0 HC: 1001 0 101001 0 10 101 0 S: V:
v1 v2 v3 v4v5v6 v7v8v9v10v11
child(i) = select(S, rank(HC, i)+1) value(i) = i - rank(HC, i)
16 16 16
5 10 15
SLIDE 57
Tree navigation relies on rank & select
f t s $ a
- r
r t s y p i y $ t e p
v2 v1 v3 v8 v9 v10 v11 v4 v5 v6 v7 f s t $ a o r r s t y p i y $ t e p L: 1010 1 110 100 0 10 000 0 HC: 1001 0 101001 0 10 101 0 S: V:
v1 v2 v3 v4v5v6 v7v8v9v10v11
child(i) = select(S, rank(HC, i)+1) value(i) = i - rank(HC, i)
7 16
5 10 15
SLIDE 58
Tree navigation relies on rank & select
f t s $ a
- r
r t s y p i y $ t e p
v2 v1 v3 v8 v9 v10 v11 v4 v5 v6 v7 f s t $ a o r r s t y p i y $ t e p L: 1010 1 110 100 0 10 000 0 HC: 1001 0 101001 0 10 101 0 S: V:
v1 v2 v3 v4v5v6 v7v8v9v10v11
child(i) = select(S, rank(HC, i)+1) value(i) = i - rank(HC, i)
9
5 10 15
SLIDE 59
Tree navigation relies on rank & select
f t s $ a
- r
r t s y p i y $ t e p
v2 v1 v3 v8 v9 v10 v11 v4 v5 v6 v7 f s t $ a o r r s t y p i y $ t e p L: 1010 1 110 100 0 10 000 0 HC: 1001 0 101001 0 10 101 0 S: V:
v1 v2 v3 v4v5v6 v7v8v9v10v11
child(i) = select(S, rank(HC, i)+1) value(i) = i - rank(HC, i)
9
5 10 15
SLIDE 60
Performance Optimization
SLIDE 61
LOUDS-Dense: optimize for the common case
f t s $ a
- r
r t s y p i y $ t e p
v2 v1 v3 v8 v9 v10 v11 v4 v5 v6 v7 Majority of nodes Frequently visited
Divided by size ratio
SLIDE 62
LOUDS-Dense: optimize for the common case
f t s $ a
- r
r t s y p i y $ t e p
v2 v1 v3 v8 v9 v10 v11 v4 v5 v6 v7 Space-efficient Fast
Divided by size ratio
SLIDE 63
f s t $ a o r L: 1010 1 11 HC: 1001 0 10 S: V:
v1 v2 f t s $ a
- r
r t s y p i y $ t e p
v2 v1 v3 v8 v9 v10 v11 v4 v5 v6 v7
LOUDS-Dense: optimize for the common case
Space-efficient Fast
SLIDE 64
L: HC: IsPrefixKey: V:
v1 v2 f t s $ a
- r
r t s y p i y $ t e p
v2 v1 v3 v8 v9 v10 v11 v4 v5 v6 v7
f st a
- r
1
LOUDS-Dense: optimize for the common case
Space-efficient Fast
SLIDE 65
LOUDS-DS: best of both worlds
L: HC: IsPrefixKey: V:
v1 v2 f t s $ a
- r
r t s y p i y $ t e p
v2 v1 v3 v8 v9 v10 v11 v4 v5 v6 v7 r s t y p i y $ t e p L: 0 100 010 000 0 HC: 1001 0 10 101 0 S: V: v3 v4v5v6 v7v8v9v10v11
f st a
- r
1 Space-efficient Fast
SLIDE 66
Observations: rank & select on LOUDS-DS
Either rank or select is required, but not both Space taken by auxiliary structures is small The bit vector (S) that requires select is dense
SLIDE 67
Optimizing rank structure for LOUDS-DS
bit-vector rank LUT
… …
basic block
size = 512 bits for LOUDS-Sparse size = 64 bits for LOUDS-Dense
within basic block: use popcount instruction
SLIDE 68
Optimizing rank structure for LOUDS-DS
bit-vector select samples
(every x 1’s)
…
SLIDE 69
Optimizing label search algorithm using SIMD
a b c d e g h I j k l m n o p q r u v w x y z L: f s t … node boundary 1 0 0 0
…
1 0 0 … S:
SLIDE 70
Optimizing label search algorithm using SIMD
a b c d e g h I j k l m n o p q r u v w x y z L: f s t … node boundary 1 0 0 0
…
1 0 0 … S: 128-bit SIMD
SLIDE 71
Optimizing label search algorithm using SIMD
a b c d e g h I j k l m n o p q r u v w x y z L: f s t … node boundary 1 0 0 0
…
1 0 0 … S:
SLIDE 72
Using prefetching to hide memory latency
f s t $ a o r r s t y p i y $ t e p L: 1010 1 110 100 0 10 000 0 HC: 1001 0 101001 0 10 101 0 S: V:
v1 v2 v3 v4v5v6 v7v8v9v10v11
SLIDE 73
1200 800 400
Lookup Latency
ns
base line LOUDS- Dense rank
- pt
select
- pt
SIMD search prefetch
What makes FST fast
50M 64-bit integer keys
SLIDE 74
100 200 300 400 500 200 400 600 800 1000
Memory(MB) better
B+tree ART C-ART FST low cost high cost
Where is FST in the performance-space trade-off
Cost function: ! = #$% r > 1 r < 1 favors performance favors space 50M 64-bit integer keys Latency(ns) $ = 1
SLIDE 75
Conclusion
LOUDS-DS
- A hybrid approach to succinctly encode tries
FST
- Matches performance of pointer-based tries
- 4 – 15x faster than existing succinct tries
- Consumes only close-to-optimal space