1. Tuple pruning using bloom filters for packet classification
Publisher : IEEE MICRO Author : Hyesook Lim , So Yeon Kim Presenter : Yu-Hsiang Wang Date : 2010/09/29

2. Outline Introduction Background : tuple space pruning (TSP)
TSP using bloom filter
Performance evaluation

3. Introduction
Many packet classification algorithms, such as tuple space pruning, perform a separate lookup on each field to narrow the search space.
These algorithms cause off-chip memory accesses for both the individual field lookups and the final combined lookup.
replace with on-chip Bloom filters to reduce unnecessary off-chip memory accesses

4. Background (TSP 1/2) Tuple space : simple rule classification
Tuple space index : source / destination prefix length
Rule
tuple
R1 (00*, 00*)
(2 , 2)
R2 (0* , 01*)
(1 , 2)
R3 (1* , 0* )
(1 , 1)
R4 (00*, 0* )
(2 , 1)
R5 (0* ,1* )
R6 (* ,1* )
(0 , 1)
T(0,0)
T(0,1) R6
T(0,2)
T(0,3)
T(1,0)
T(1,1)
R3,R5
T(1,2) R2
T(1,3)
T(2,0)
T(2,1) R4
T(2,2) R1
T(2,3)
T(3,0)
T(3,1)
T(3,2)
T(3,3)
Tuple
Entries
(0 , 1) R6
(1 , 1)
R3,R5
(1 , 2) R2
(2 , 1) R4
(2 , 2) R1
Regard as a 2-dimension space

5. Background (TSP 2/2)
Pruning table : distinct source/destination prefixes
R1 (00* ,* ) T(2,0)
R2 (1* ,00* ) T(1,2)
R3 (01* , 100*) T(2,3)
R4 (101* ,100* ) T(3,3)
R5 (101* ,11* ) T(3,2)
R6 (1* , * ) T(1,0)
Incoming packet (0100,1001)
Dimension 1 lookup : T(2,3)
Dimension 2 lookup : T(1,0), T(2,0) ,T(2,3), T(3,3)
intersected tuples : T(2,3)
Pruning table
Dimension Dimension2
00* T(2,0)
* T(1,0)T(2,0)
1* T(1,0)T(1,2)
00* T(1,2)
01* T(2,3)
100* T(2,3)T(3,3)
101* T(3,2)T(3,3)
11* T(1,3)

6. TSP using bloom filter (1/5)
Replace pruning table (off chip) with bloom filters(on chip).
Tuple bloom filters for tuple
Bloom filter

7. TSP using bloom filter (2/5)
3 bloom filters with cyclic redundancy check(CRC) –8 generator
Pt : rule set composed of source and destination prefix pairs.
Pt = { R1(00* ,*) , R2(1*,00*) , R3(01*,100*) , R4 (101*,100*) ,
R5 (101*,11*) , R6 (1*, *) }
Pruning sets : distinct source/destination prefixes
P1 = { 00* , 1* ,01* ,101* } , P2 = { * ,00* ,100* ,11* }
Record distinct lengths : Lt = { (2,0) , (1,2) , (2,3) , (3,3) , (3,2) , (1,0) }
L1 = { 1 , 2 , 3 }
L2 = { 0 , 2 , 3 }

8. TSP using bloom filter (3/5)
Prefix -> CRC-8 generator -> CRC code
Choose indices from CRC code -> Set the correspond bits to 1 00
1,7
CRC-8 GENERATOR
at initial
Source bloom filter

9. TSP using bloom filter (4/5)
Hash table entry

10. TSP using bloom filter (5/5)
Incoming packet (0100 ,1001) Dimension 1 lookup : { * , 0* , 01*, 010* ,0100} L1={ 1 , 2 , 3 } Dimension 2 lookup : { * , 1* , 10*, 100* ,1001} L2= { 0 , 2 , 3 } Intersected list : { (2,0) , (2,2) , (2,3) , (3,0) , (3,2) , (3,3) } Lt { (2,0) , (1,2) , (2,3) , (3,3) , (3,2) , (1,0) }

11. Performance evaluation
: smallest multiple of 2 which is equal to or greater than n(P)
Source, destination filter size are increased by a factor. 4 , 8 ,16, 32 [n(P1)], 4, 8 ,16, 32 [n(P2)] , tuple filter size is fixed at 4[n(Pt)]

12. Performance evaluation
Source, destination filter size are fixed at 4[n(P1)], 4[n(P2)] , tuple filter size is increased by a factor . 1,2,….,32[n(Pt)]
The simulation result in using bloom filters with sizes 8[n(P1)], 8[n(P2)],8[n(Pt)] in performance.

13. Performance evaluation
Average 7~40 memory accesses per packet, each take 20 nanoseconds.
=>140~800ns per packet
=>1.25~7.14 million packets per second