Segmented Hash: An Efficient Hash Table Implementation for High Performance Networking Subsystems

transcript

Segmented Hash: An Efficient Hash Table Implementation for High Performance Networking

Subsystems

Sailesh KumarPatrick Crowley

2 - Sailesh Kumar - 04/21/23

Problem Statement

How to implement deterministic hast tables

Near worst case O(1) deterministic performance

We are given with a small amount of on-chip memory

On-chip memory limited to 1-2 bytes per table entry

In this paper we tackle the above problem

Hash Tables

Hash table uses a hash function which is used to index the table entries» hash("apple") = 5

hash("watermelon") = 3hash("grapes") = 9hash("cantaloupe") = 7hash("kiwi") = 0hash("mango") = 6hash("banana") = 2

» hash("honeydew") = 2

This is called collision» Now what

bananaWatermelon

applemango

cantaloupe

grapes

9Linear ProbingDouble HashingHash2(honeydew) = 3

honeydew

honeydewLinear Chaining

honeydew

No. of keys mapped to a

bucket is called collision chain

length

Performance Analysis

Average performance is O(1) However, worst-case performance is O(n) In fact the probability of collision chain > 1 is

pretty high

10 20 30 40 50 60 70 80 90 100

Load m/n (%)

Co llis io n c h a in > 1

Co llis io n c h a in > 2

These keys will take twice time to be

probed

These will take thrice the time to be

probed

Pretty high probability that performance is half or three times

Segmented Hashing

Uses power of multiple choices» has been proposed and used earlier by several authors

A N-way segmented hash» Logically divides the hash table array into N equal segments» Maps the incoming keys onto a bucket from each segment» Picks the bucket which is either empty or has minimum keys

h( ) k i is mappedto this bucket

h( )k i+1 is mappedto this bucket

2 1 1 1 2 1 21 2

A 4-way segmented hash table

Segmented Hash Performance

More segments improves the probabilistic performance» With 64 segments, probability of collision chain > 2 is nearly

zero even at 100% load» More deterministic hash table performance

10 20 30 40 50 60 70 80 90 100

Load m/n (%)

collis

1 s e g me n t

10 20 30 40 50 60 70 80 90 100

Load m/n (%)

collis

2} 1 s e g me n t

An Obvious Deficiency

O(N) memory probes per query» Requires N times higher memory bandwidth

How to ensure an O(1) memory probes per query

Use Bloom filters implemented using small on-chip memory (filters out unnecessary memory accesses)

Before going further brief introduction of Bloom filters

2 1 1 1 2 0 1 21 2

k ih( ) Every query requires 4 probes

Bloom Filter

m-bit Array

Bloom Filter

m-bit Array

Bloom Filter

m-bit Array

Bloom Filter

m-bit Array

(false positive)

Adding per Segment Filters

2 1 1 1 2 0 1 21 2

k ih( ) k i can go to any of the 3 buckets

h1(ki)

h2(ki)

hk(ki)

mb bits

We can select any of the above three segments and insert the key into the

corresponding filter

False Positive Rates

With Bloom Filters, there is likelihood of false positives» False positive means unnecessary memory accesses

With N segments, clearly the false positive rates will be at least N times higher» In fact, it will be even higher, because we have to also

consider several permutations of false positives

We use Selective Filter Insertion algorithm, which reduces the false positive rates by several orders of magnitude

Selective Filter Insertion Algorithm

k ih( )

2 1 1 1 2 0 1 21 2

k i can go to any of the 3 buckets

h1(ki)

h2(ki)

hk(ki)

mb bits

Insert the key into segment 4, since fewer bits are set. Fewer

bits are set => lower false positive

With more segments (or more choices), our

algorithm sets far fewer bits in the Bloom filter

Selective Filter Insertion Details

Greedy policy

For every arriving key

We choose the segment where minimum bits are set in the Bloom filter

We show that this leads to unbalanced segments» Reduced performance

Selective Filter Insertion Algorithmk1

Reduced No. of

choices

Selective Filter Insertion Enhancement

Objective is to keep segments balanced

Might need to make sub-optimal choices at times

One way is to avoid the most loaded segment» Reduces number of choices by 1

However, it leads to situations where two segments alternately leads

Things get complicated» More detailed version of algorithm can be found in paper

Selective Filter Insertion Results

8 16 24 32 40 48 56 64

Bloom Filter bits per hash table entry

O p t im um k

N o r m a l B lo o m f ilt e r

Se le c t iv e F ilt e r I n se r t io n s

6 4 se gm e n t s

Simulation Results

64K buckets, 32 bits/entry Bloom filter. Simulation runs for 500 phases.

» During every phase, 100,000 random searches are performed. Between two phases, 10,000 random keys are deleted and inserted.

Hash policy = Linear Chaining

0 20 40 60 80 100

Load (%)

1 s eg m en t

1 66 4

Conclusion

We presented a way to implement

» Hash tables with deterministic performance» We utilize small on-chip memory to achieve it» We also show that on-chip memory requirements are modest» Well within the Moore’s law» A 1M hash table for example needs 1-2MB of on-chip memory

Questions?

Segmented Hash: An Efficient Hash Table Implementation for High Performance Networking Subsystems

Documents