Scalable, Memory Efficient, HighSpeed IP Lookup Algorithms - PowerPoint PPT Presentation

Loading...

PPT – Scalable, Memory Efficient, HighSpeed IP Lookup Algorithms PowerPoint presentation | free to view - id: 1a9933-ZDc1Z



Loading


The Adobe Flash plugin is needed to view this content

Get the plugin now

View by Category
About This Presentation
Title:

Scalable, Memory Efficient, HighSpeed IP Lookup Algorithms

Description:

Since the introduction of Classless Inter Domain Routing (CIDR) in 1993, the IP ... packets every second, based on longest prefix matching, becomes a labyrinth. ... – PowerPoint PPT presentation

Number of Views:48
Avg rating:3.0/5.0
Slides: 40
Provided by: puni2
Category:

less

Write a Comment
User Comments (0)
Transcript and Presenter's Notes

Title: Scalable, Memory Efficient, HighSpeed IP Lookup Algorithms


1
Scalable, Memory Efficient, High-Speed IP Lookup
Algorithms
  • Rama Sangireddy,
  • Natsuhiko Futamura,
  • Srinivas Aluru,
  • Arun K. Somani

IEEE/ACM TRANSACTIONS ON NETWORKING, AUGUST 2005
2
Outline
  • Introduction
  • Elevator-Stairs Algorithm
  • logW-Elevator Algorithm
  • Results and Analysis

3
Introduction
  • Since the introduction of Classless Inter Domain
    Routing (CIDR) in 1993, the IP address lookup
    mechanism has been designed based on the longest
    prefix matching (LPM) algorithm.
  • when the IPv6 routing protocol is introduced
    where the address length is 128 bits, the problem
    of routing millions of communication packets
    every second, based on longest prefix matching,
    becomes a labyrinth.
  • IP routing tables are expanding in both the
    dimensions, i.e., address length and number of
    prefixes.

4
Introduction
  • we present two algorithmsElevator-Stairs
    algorithm and logW-Elevators algorithm.
  • Elevator-Stairs algorithm provides a search time
    of O(W/k k), update time of O(W/k k 2k),
    while requiring only O(N) memory.
  • logW-Elevators algorithm performs lookup in
    O(logW) time, update in O(N) time and requires
    O(NlogW) memory.

5
Elevator-Stairs Algorithm
  • Basic Concept
  • Elevator-Stairs algorithm is similar to a
    scenario wherein a tall building has an elevator
    that stops only at certain intermediate floors. A
    passenger desiring to reach any floor from the
    topmost floor of the building can take the
    elevator up to the nearest possible upper floor
    and then reach the destination floor by taking
    the stairs.

6
Elevator-Stairs Algorithm
7
Elevator-Stairs Algorithm
  • Build binary trie.
  • The space required for a binary trie is O(NW)
    where N is the number of strings and W is the
    maximum length of a string.
  • The space can be reduced to O(N) by compressing
    each maximal nonbranching path into one edge,
    which called PATRICIA trie.

8
Elevator-Stairs Algorithm
  • path label of a path in PATRICIA trie is the
    concatenation of edge labels along the path.
  • string depth of a node is the length of the path
    label from the root to the node.
  • level l in a PATRICIA trie to be the set of all
    the nodes that are at string depth l.

9
Elevator-Stairs Algorithm
10
Elevator-Stairs Algorithm
  • IP lookup using PATRICIA trie takes O(W) time in
    the worst case.
  • This run time complexity can be improved by
    leaping multiple bits at once.

11
Elevator-Stairs Algorithm
  • The Elevator-Stairs algorithm uses hash tables
    with multiple bits as a key to skip multiple
    levels of the PATRICIA trie.
  • We call this structure the kth-level-tree.

12
Elevator-Stairs Algorithm
  • For all the edges that cross a k-level, a
    nonbranching node is created at the k-level so
    that the node can be indexed in the
    kth-level-tree.
  • Each node in kth-level-tree at string depth ik
    has a pointer to the corresponding node in the
    PATRICIA trie, and a hash table H(u) that stores
    pointers to all the nodes at string depth (i1)k
    in the subtrie of PATRICIA trie with u as the
    root node.

13
Elevator-Stairs Algorithm
  • The key for a pointer stored in the hash table is
    obtained by the concatenation of edge labels
    between u and the corresponding node.
  • Each node in the kth-level-tree at string depth
    keeps a copy of the next hop port (NHP) of the
    corresponding node in the PATRICIA trie.

14
Elevator-Stairs Algorithm
15
Elevator-Stairs Algorithm
16
Elevator-Stairs Algorithm
  • Optimal Complexity of Multiple Metrics
  • Going through each level takes constant time
    provided hash table lookup takes constant time,
    and hence the total search time is O(W/k k),
    which is minimized when k O(vW) and achieves a
    search time of O(vW).

17
Elevator-Stairs Algorithm
  • The memory required for storing the
    kth-level-tree is O(NW/k) since O(N) edges may
    cross multiple k-levels and many nonbranching
    nodes may be created in the PATRICIA trie.
  • The memory space can be reduced to O(N).

18
Elevator-Stairs Algorithm
  • Update of Address Lookup Data Structure
  • There are two cases of insertion
  • a) the prefix that needs to be inserted forms a
    new leaf in the PATRICIA trie
  • b) the inserted prefix does not form a new leaf
    and in that case the structures of the PATRICIA
    tree and the kth-level-tree do not change.

19
Elevator-Stairs Algorithm
  • In case (a), a new leaf is attached to the tree
    at the point where the search ends.
  • If the edge to the leaf crosses a k-level, a new
    node is created on this edge at that level in the
    PATRICIA trie.
  • A node in kth-level-tree is also created to
    represent the new node in PATRICIA trie,
  • A pointer to the new node is added to the hash
    table in its ancestor in the kth-level-tree.

20
Elevator-Stairs Algorithm
  • In case the hash table becomes full, the hash
    table size is doubled and all the elements are
    rehashed.
  • This results in an amortized constant time per
    insertion.
  • Update takes search_time O(1)
  • O(W/k k) amortized time.

21
Elevator-Stairs Algorithm
  • In case (b), there are no changes in the
    structure of the PATRICIA trie, but the new port
    number must be copied to the nearest kth-level
    below the updated node in kth-level-tree.
  • This insertion takes search_time O(2k)
  • O(W/k k 2k) time.
  • The procedure for deletion of a prefix occurs in
    the same way as insertion.

22
Elevator-Stairs Algorithm
23
Elevator-Stairs Algorithm
24
logW-Elevator Algorithm
  • For IP address lookups, the algorithm contains
    kth-level-trees for k (W/2), (W/4), …, 2, in
    addition to the PATRICIA trie.
  • the total space required is O(NlogW) since each
    kth-level-tree consumes O(N) space.

25
logW-Elevator Algorithm
26
logW-Elevator Algorithm
  • If the node at level W/2 does not have an edge
    starting with (W/21)th bit of p, the longest
    match in PATRICIA trie is found.
  • If the node at level W/2 has an edge starting
    with (W/21)th bit of p, search should finish
    between level (W/21) and level W.
  • If there is no hash table entry with p1…W/2 as
    key, the search must finish between levels 1 and
    W/2.

27
logW-Elevator Algorithm
28
logW-Elevator Algorithm
29
logW-Elevator Algorithm
  • Optimal Complexity of Multiple Metrics
  • IP address lookup can be performed in O(logW)
    time using a memory space of O(NlogW).

30
logW-Elevator Algorithm
  • Update of Address Lookup Data Structure
  • There exist, again, two cases for insertion
  • a) the prefix that needs to be inserted forms a
    new leaf in the PATRICIA trie,
  • b) the inserted prefix does not form a new leaf
    in the PATRICIA trie and in that case the
    structures of the PATRICIA tree and the
    th-level-tree do not change.

31
logW-Elevator Algorithm
  • In case (a), a new edge is created in the
    PATRICIA trie and all the kth-level-trees that
    have a level crossing the edge to the newly
    created leaf may be modified.
  • Modification of each kth-level-tree takes
    amortized constant time, considering the
    occasional doubling of the hash tables.
  • Total modification consumes search_time O(logW)
    O(logW) time.

32
logW-Elevator Algorithm
  • In case (b), a modification of a port number has
    to be copied to the descendant nodes that do not
    have a port number assigned.
  • This may take search_time O(N) O(N) time.

33
logW-Elevator Algorithm
34
logW-Elevator Algorithm
35
Results and Analysis
36
Results and Analysis
37
Results and Analysis
38
Results and Analysis
  • 97.34 of time update occurs at leaf nodes of
    PATRICIA trie. In that scenario, the
    logW-Elevators algorithm can update in O(logW)
    time, while the Elevator-Stairs algorithm can
    update in O(W/k k) time.

39
(No Transcript)
About PowerShow.com