1. A longest prefix first search tree for IP lookup Authors: Lih-Chyau Wuu, Tzong-Jye Liu, Kuo-Ming Chen Presenter: Chen-Yu Chung Date: 2008/09/24 Publisher/Conf.: Communications, 2005. ICC 2005. 2005 IEEE International Conference on

2. Outline  Introduction  The node struction  LPFST construction  IP lookup in LPFST  LPFST updating operation  Multiple LPFSTs construction  Performance  Conclusion

3. Introduction  We present a Longest Prefix First Search Tree (LPFST) scheme which puts the routing entry with longer prefix on the upper level of the tree.  This scheme can stop immediately as matching with some internal node while performing IP lookup  The tree has no dummy node, and some nodes may store two routing entries to minimize the number of tree nodes.

4. Outline  Introduction  The node struction  LPFST construction  IP lookup in LPFST  LPFST updating operation  Multiple LPFSTs construction  Performance  Conclusion

5. The node struction  Type: 0 or 1.  length: the length of the prefix.  prefix: the prefix of an entry of the routing table.  next-hop: the next-hop of the prefix.  contained-next-hop: the next-hop of the second prefix stored in type 1 node.  lchild/rchild: pointer which points to the left/right child of the node or NIL.

6. The node struction  Definition 1: The function Get(X, a, b) returning the value of the a-th to the b-th bits of the variable X, the 0-th bit is the leftmost bit of X. Ex: Get( “ 01011 ”, 1, 3)=101.  Definition 2: A prefix (P1/L1) is said to match with another prefix (P2/L2), L1>L2, if and only if Get(P1, 0, L2-1) ≡ P2.  Definition 3: Assumed that there are two routing entries (P1/L1; o1) and (P2/L2; o2), and L1>L2. A type 1 node can contain the two entries if and only if the node is at tree level L2 and P1 matches with P2. The type 1 node is formed as (1, L1, P1, o1, o2).

7. Outline  Introduction  The node struction  LPFST construction  IP lookup in LPFST  LPFST updating operation  Multiple LPFSTs construction  Performance  Conclusion

8. LPFST construction(1/9)  Algorithm LPFST (routing table) { read the first entry of the routing table to create the tree root; while (more entry in routing table) { read one entry (Px/Lx; ox) of routing table; form a type 0 node x=(0, Lx, Px, ox); Insert (x, root, 0); }

9. LPFST construction(2/9)  Algorithm Insert(x, y, level) { 1) if Lx>Ly then swap (x, y); //swap length, prefix, next-hop of x and y 2) if Lx=level then {transform y to Type 1 node and y =(1, Ly, Py, oy, ox); return;} 3) if Get(px, level, level)=0 then //inspect left or right child { if lchild(y) ≡ NIL then lchild(y)=x; else Insert(x, lchild(y), level+1); return; } else { if rchild(y) ≡ NIL then rchild(y)=x; else Insert(x, rchild(y), level+1); return; } }

10. The node struction(3/9)  A prefix (Px/Lx) is stored at a node whose tree level is less than or equal to its prefix length.

11. LPFST construction(4/9) 1,2 Type0 node Type1 node 1:next-hop 2:contained-next-hop A 00*

12. LPFST construction(5/9) 01* A 00* B 1,2 Type0 node Type1 node 1:next-hop 2:contained-next-hop

13. LPFST construction(6/9) 01* G 010* B A A 00* 1,2 Type0 node Type1 node 1:next-hop 2:contained-next-hop

14. LPFST construction(7/9) 010* C 0110001* G A 00* G B B 01*01* 1,2 Type0 node Type1 node 1:next-hop 2:contained-next-hop

15. LPFST construction(8/9) 0111* C 0110001* D A 00* G,B 010* G B 1,2 Type0 node Type1 node 1:next-hop 2:contained-next-hop

16. LPFST construction(9/9) 0110001* I 11001000* C A 00* D,B 0111* 010* G 11001001* E 10* C 1101111* F 11000* J 1,2 Type0 node Type1 node 1:next-hop 2:contained-next-hop

17. Outline  Introduction  The node struction  LPFST construction  IP lookup in LPFST  LPFST updating operation  Multiple LPFSTs construction  Performance  Conclusion

18. IP lookup in LPFST(1/2)  Function Lookup(DA, y, level) { next-hop=default route; while y≠NIL do { if Get(DA, 0, Ly -1) ≡ py then return oy; if y is a type 1 node then next-hop=contained-next-hop of y; if Get(DA, level, level) ≡ 0 then y=lchild(y); else y=rchild(y); level++; } return next-hop; }

19. IP lookup in LPFST(2/2) DA = 01100010 DA = 01101111 0110001* I 11001000* C A 00* D,B 0111* 010* G 11001001* E 10* C 1101111* F 11000* J

20. Outline  Introduction  The node struction  LPFST construction  IP lookup in LPFST  LPFST updating operation  Multiple LPFSTs construction  Performance  Conclusion

21. LPFST updating operation(1/3)  Case 1 Delete ( “ 11000* ” /5;J) 0110001* I 11001000* C A 00* D,B 0111* 010* G 11001001* E 10* C 1101111* F 11000* J

22. LPFST updating operation(2/3)  Case 2 0110001* I 11001000* C A 00* D,B 010* G 11001001* E 10* C 1101111* F 11000* J Delete ( “ 0111* ” /4;D) G

23. LPFST updating operation(3/3)  Case 3 0110001* I 11001000* C A 00* G,B 010* 11001001* E 10* C 1101111* F 11000* J Delete ( “ 010* ” /4;G) B Change mode 01*

24. Outline  Introduction  The node struction  LPFST construction  IP lookup in LPFST  LPFST updating operation  Multiple LPFSTs construction  Performance  Conclusion

25. Multiple LPFSTs construction(1/3)  In Internet, there is no routing entry with prefix length less than eight. The height of LPFST can be lowered by partitioning it into several smaller LPFSTs, and the improved scheme is called as Partition Longest Prefix First Search Tree (PLPFST).

26. Multiple LPFSTs construction(2/3)

27. Multiple LPFSTs construction(3/3)

28. Outline  Introduction  The node struction  LPFST construction  IP lookup in LPFST  LPFST updating operation  Multiple LPFSTs construction  Performance  Conclusion

29. Performance analysis(1/2)

30. Performance analysis(2/2)

31. Outline  Introduction  The node struction  LPFST construction  IP lookup in LPFST  LPFST updating operation  Multiple LPFSTs construction  Performance  Conclusion

32. Conclusion  Our LPFST and PLPFST not only eliminate dummy nodes but also minimize the number of tree nodes by letting some nodes to contain two routing entries.  However, the number of average memory accesses is more than the compress skill, and we are now investigating to integrate the compress skill with our schemes to furthermore lower the number of memory access and still preserve fast updating and scalability.