Tuple pruning using bloom filters for packet classification

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

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

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

Background (TSP 1/2) Tuple space : simple rule classification Tuple space index : source / destination prefix Rule tuple length R 1 (00*, 00*) (2 , 2) R 2 (0* , 01*) (1 , 2) R 3 (1* , 0* ) (1 , 1) T(1, 0) T(1, 1) T(1, 2) T(1, 3) R 3, R R 2 5 R 4 (00*, 0* (2 , 1) ) Tuple Entries T(2, 0) T(2, 1) T(2, 2) T(2, 3) R 4 R 1 R 5, (0* (0 1) , 1* R 6 (1 , 1) ) , 1) (1 R 3, R 5 R 6, (* (1 2) , 1* R 2 (0 , 1) ) (2 , 1) R 4 T(3, 0) T(3, 1) T(3, 2) T(3, 3) (2 , 2) R 1 T(0, 0) T(0, 1) T(0, 2) T(0, 3) R 6 Regard as a 2 -dimension space

Background (TSP 2/2) Pruning table : distinct source/destination prefixes T(1, 2) Pruning table Dimension 1 Dimension 2 R 3 (01* , 100*) T(2, 3) 00* * R 4 (101* , 100* ) T(3, 3) T(2, 0) T(1, 0)T(2, 0) R 5 (101* , 11* ) T(3, 2) 1* 00* T(1, 0)T(1, 2) R 6 (1* T(1, 0) 01* 100* R 1 (00* , * R 2 (1* ) T(2, 0) , 00* ) , * ) T(2, 3) 101* Incoming packet (0100, 1001) T(3, 2)T(3, 3) T(2, 3)T(3, 3) 11* T(1, 3) 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)

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

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 = { R 1(00* , *) , R 2(1*, 00*) , R 3(01*, 100*) , R 4 (101*, 100*) , R 5 (101*, 11*) , R 6 (1*, *) } Pruning sets : distinct source/destination prefixes P 1 = { 00* , 1* , 01* , 101* } , P 2 = { * , 00* , 11* } Record distinct lengths : Lt = { (2, 0) , (1, 2) , (2, 3) , (3, 2) , (1, 0) } L 1 = { 1 , 2 , 3 } L 2 = { 0 , 2 , 3 }

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

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

TSP using bloom filter (5/5) Incoming packet (0100 , 1001) Dimension 1 lookup : { * , 01*, 010* , 0100} L 1={ 1 , 2 , 3 } Dimension 2 lookup : { * , 10*, 100* , 1001} L 2= { 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, 2) , (1, 0) }

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

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

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