1. IP Routing Lookups Scalable High Speed IP Routing Lookups.
Based on a paper by:
Marcel Waldvogel, George Vaghese, Jon Turner, Bernhard Plattner.

2. Background and Motivation
Rapidly growing Internet increases demands for high performance routing.
Routing table lookup for a destination address is one of the key components of packet forwarding.
Given IP address, find out the output link that is the best choice to reach this IP.
Hierarchial IP address structure.
BMP – Best matching prefix problem.

3. The Address Lookup Problem
Address in a packet is compared to the stored prefixes starting from the left most bit.
The longest prefix found is the desired match.
The packet is forwarded to the specific next hop.
Next hop field changes – topology, traffic.
Set of prefixes changes rarely – inserting/removing network or host.

4. Address lookup using Tries1 1 1
Existing prefixes:
000, 001, 010, 011, 100, 101, 11, 111 1 1 1 1
Prefixes stored in a binary trie
Black nodes denote terminal nodes for prefixes.
Remember the most recent black node.
The search ends either in leaf or because of no matching branch to follow.
Time Complexity W (= 32 for IPv4 and 128 for IPv6) memory accesses.

5. Liner Search of Hash Tables
Organize prefixes into the hash tables by length.
Start searching from the longest prefix size.
W hash function computations in the worst case. W = maximal prefix length, 32 for IPv4.

6. Binary Search of Hash Tables. (Basic Scheme)
Organize prefixes into the hash tables by length.
Introduce markers.
Remember the last found BMP to avoid backtracking.
log2w hash function computations.

7. Binary Search of Hash Tables.
Hash tables with markers
Prefix length 1
P1=0 2
P1=00 11 00 3
P3=111
111
- Prefix 00
- Marker 11

8. Binary Search of Hash Tables. (Code)
Binary_Search(D) // Search for address D
Initialize search range R to cover the whole array L;
Initialize BMP found so far to NULL;
While R is not empty {
Let i correspond to the middle level in range R;
Extract the first L[i].length() bits of D into D’;
M = Search(D’,L[i].hash); // search hash for D’
if (M == NULL)
R = Upper half of R; // Not found
else if (M is a prefix and not a marker) {
BMP = M.bmp; break;}
else { // M is a pure marker or a marker and a prefix
BMP = M.bmp; // update the best matching prefix so far
R = lower half of R; }
End;

9. Mutating Binary Search
Every match in the binary search with some marker X
means that we need only search among the set of prefixes for which X is a prefix.
BS mutates (changes) the levels on which it searches dynamically
(in a way that always reduces the level to be searched) as it gets more match information.
Average number of memory lookups is 2 for IPv4 (32 bit)
Root
New Trie on failure
m = median length among all prefix lengths in trie X
New Trie on match
(first m bits of Prefix = X)

10. Mutating Binary Search (example:)
Prefix length
Mutating search trees
Hash Tables 16
E: …, Tree2 17 18 19
F: , Tree3
H: , Tree4 20
J: …1010, End 21
G: …11100, End
H: , Tree4 22 23 24
Hash entry structure:
Node_Name: Prefix(… stands for E), Tree to use from now on

11. Mutating Binary Search: Advantages / Disadvantages
Faster average lookup time.
Disadvantages:
Increased new prefix insertion time.
Increased storage requirements for optimal binary search trees family.

12. Mutating Binary Search: How to reduce the storage needed?
On match we use the new tree
On miss we use only the upper part of the current tree
We never use more then a single rope like branch from any specific tree.
So we can store ropes instead of binary trees

13. Ropes of a sub tree – the sequence of levels which binary search will follow on repeated failures.
Example:
Prefix length
Mutating search trees
Hash Tables 16
E: …, Tree2 17 18 19
F: , Tree3
H: , Tree4 20
J: …1010, End 21
G: …11100, End
H: , Tree4 22 23 24

14. Rope Variation of Mutating Binary Search Search for address D:
Rope Search(D) {
R default search sequence
BMP NULL
While R is not empty {
i first pointer found in R
D’ first L[i].length() bits of D
M Search(D’,L[i].hash) // search hash for D’
if (M != NULL) {
BMP M.bmp //update the best matching prefix so far
R M.rope //get the new Rope, possibly empty }

15. Possible variations
Arrays usage instead of hash tables for the initial prefix lookup.
Space time tradeoff :
wo prefix length for which array is used (wo=16)
2Wo space used (216)
Hardware implementations.
Rope search algorithm is simple
Can be pipelined

16. Mutating Binary Search: Implementation:
Precomputations – building the rope search data structure optimized for a given prefix set.
Insertions/deletions result in performance degradation

17. Conclusions:
Simple Binary search algorithm reduce number of memory accesses from W to log 2W. Where w = number of bits in the IP address. (5 = log 232 hash computations for IPv4)
Mutating Binary search algorithm further reduce the average case hash computations number to 2.
The DS initialization takes O(sum of prefix lengths)

18. Practical Measurements:
Practical measurements made on 200 MHz Pentium Pro, C using compiler max. optimizations on table with 33,000 entries
about 80ns for IPv4
about ns for IPv6

19. Generalized Level Compressed Tries.
Definition – Tries with n levels compressed into the hash tables.
Time complexity optimization problem under memory constrains.
To be presented the next lecture.