EP2037381A1 - Datenbank und Datenbankverarbeitungsverfahren - Google Patents

Datenbank und Datenbankverarbeitungsverfahren Download PDF

Info

Publication number
EP2037381A1
EP2037381A1 EP08164370A EP08164370A EP2037381A1 EP 2037381 A1 EP2037381 A1 EP 2037381A1 EP 08164370 A EP08164370 A EP 08164370A EP 08164370 A EP08164370 A EP 08164370A EP 2037381 A1 EP2037381 A1 EP 2037381A1
Authority
EP
European Patent Office
Prior art keywords
node
key
search
search key
data
Prior art date
Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
Withdrawn
Application number
EP08164370A
Other languages
English (en)
French (fr)
Inventor
Jonathan Richard Berger
Gawain Bosworth
David Edward McWalter
Current Assignee (The listed assignees may be inaccurate. Google has not performed a legal analysis and makes no representation or warranty as to the accuracy of the list.)
Metaswitch Networks Ltd
Original Assignee
Data Connection Ltd
Priority date (The priority date is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the date listed.)
Filing date
Publication date
Application filed by Data Connection Ltd filed Critical Data Connection Ltd
Priority to EP08165520.1A priority Critical patent/EP2040184B1/de
Publication of EP2037381A1 publication Critical patent/EP2037381A1/de
Withdrawn legal-status Critical Current

Links

Images

Classifications

    • G—PHYSICS
    • G06—COMPUTING; CALCULATING OR COUNTING
    • G06F—ELECTRIC DIGITAL DATA PROCESSING
    • G06F16/00—Information retrieval; Database structures therefor; File system structures therefor
    • G—PHYSICS
    • G06—COMPUTING; CALCULATING OR COUNTING
    • G06F—ELECTRIC DIGITAL DATA PROCESSING
    • G06F16/00—Information retrieval; Database structures therefor; File system structures therefor
    • G06F16/20—Information retrieval; Database structures therefor; File system structures therefor of structured data, e.g. relational data
    • G06F16/22—Indexing; Data structures therefor; Storage structures
    • G06F16/2228—Indexing structures
    • G06F16/2246—Trees, e.g. B+trees
    • G—PHYSICS
    • G06—COMPUTING; CALCULATING OR COUNTING
    • G06F—ELECTRIC DIGITAL DATA PROCESSING
    • G06F16/00—Information retrieval; Database structures therefor; File system structures therefor
    • G06F16/20—Information retrieval; Database structures therefor; File system structures therefor of structured data, e.g. relational data
    • G06F16/27—Replication, distribution or synchronisation of data between databases or within a distributed database system; Distributed database system architectures therefor
    • G—PHYSICS
    • G06—COMPUTING; CALCULATING OR COUNTING
    • G06F—ELECTRIC DIGITAL DATA PROCESSING
    • G06F16/00—Information retrieval; Database structures therefor; File system structures therefor
    • G06F16/90—Details of database functions independent of the retrieved data types
    • G06F16/907—Retrieval characterised by using metadata, e.g. metadata not derived from the content or metadata generated manually
    • H—ELECTRICITY
    • H04—ELECTRIC COMMUNICATION TECHNIQUE
    • H04L—TRANSMISSION OF DIGITAL INFORMATION, e.g. TELEGRAPHIC COMMUNICATION
    • H04L12/00—Data switching networks
    • H04L12/28—Data switching networks characterised by path configuration, e.g. LAN [Local Area Networks] or WAN [Wide Area Networks]

Definitions

  • the present invention relates to databases and methods for storing and searching data in database tree structures.
  • the present invention relates to the processing of data stored in database tree structures for use in data packet routing applications.
  • IP networks include a number of interconnected router entities which are responsible for making decisions as to which paths data packets may flow through from source to destination. Routing protocols are used to gain information about the network and to determine routes between particular network destinations or different areas or subnets of the network. These routes may be stored at each router in a database known as a routing table. The process of creating and maintaining the contents of a routing table is commonly referred to as IP routing.
  • a router may also store information necessary for carrying out forwarding of data packets in a database commonly known as a forwarding table.
  • a forwarding table The process of receiving and transmitting data packets onto their destination using information stored in a forwarding table is commonly referred to as IP forwarding.
  • a routing table is generally not used directly in the packet forwarding process. Instead, the packet routing process outputs data relating to selected routes to a forwarding table according to route information and one or more routing protocols such as the Routing Information Protocol (RIP) or the Border Gateway Protocol (BGP). The contents of the forwarding table may then be accessed during the packet forwarding process, for example using efficient hardware implementations.
  • RIP Routing Information Protocol
  • BGP Border Gateway Protocol
  • IPv4 addresses are 32 bits long, which gives scope for over 4 billion IP addresses, and IPv6 addresses are still larger. Exchanging and updating forwarding information for this number of IP addresses at each router is generally impractical.
  • a router will typically maintain a forwarding table containing a number of IP address prefix entries and forwarding information corresponding to each of these prefix entries.
  • an IP address for the network destination may be examined by the router which may then search its routing table for the longest match to the IP destination address for the network destination.
  • the longest match comes in the form of the longest prefix matching the destination IP address, i.e. the route which has the greatest number of initial bits matching the IP network address. This is known as the 'longest prefix match.'
  • the router may then output this information to a forwarding table, so that when data packets for this destination address arrive at the router, they may be forwarded by a packet forwarding function or module in the router using forwarding information contained in the forwarding table.
  • the packet forwarding process may be repeated as often as required, and a data packet may be forwarded from router to router, until it arrives at the desired IP destination address.
  • IPv4 address is typically denoted as a series of four decimal numbers separated by decimal points. Each of the decimal numbers represents eight bits of a 32 bit IPv4 address, so that each decimal number ranges from zero to 255.
  • a prefix refers to an IP address or its initial portion.
  • IPv4 for example "192.168/16” is a 16-bit prefix of "192.168.1.4", “192.168.200.200” and “192.168.26.8", etc.
  • "192.168/16” is a 16-bit prefix of all the addresses "192.168.x.y” where 0 ⁇ x ⁇ 255 and 0 ⁇ y ⁇ 255.
  • a routing table at a router containing routing information for the prefix "192.168/16” may thus be able to route data packets for all IP destination addresses in the range "192.168.x.y". However, the router may also contain more specific routing information for a 32 bit IP destination such as "192.168.4.5".
  • a network IP address may thus be compared with all prefixes in the router's routing table in order to provide suitable, e.g. the most specific, routing information in the form of the longest matching prefix, which may then be output to a forwarding
  • Routing in IP networks thus involves a large amount of searching through routing tables of a large number of routers. Further, the routing tables may change frequently when new routes are added and other routes become obsolete. It is therefore desirable that the algorithms and data structures for implementing such systems are efficient in terms of high search speed whilst required data storage resources are kept down.
  • a tree is a widely-used data structure with a tree-shaped form having a set of linked nodes stemming from a root node.
  • Each node may contain a value or a condition and has zero or more child nodes, which are located immediately below it in the tree.
  • a node that has a child is called the child's parent.
  • a node has at most one parent.
  • a leaf node is a node of a tree data structure that has zero child nodes, which are often furthest from the root node.
  • An ancestor of a node is that node's parent, or that node's parent's parent, and so on.
  • the root is ancestor to every other node in the tree.
  • the set of ancestors of a given node are the (shortest) path through the tree from the root to that node.
  • the descendants of a node are that node's children, or that node's children's children, and so on.
  • Node A is an ancestor of node B if and only if node B is a descendant of node A.
  • a binary search tree is a binary tree data structure where each node has a corresponding key.
  • the left subtree of a node in a binary search tree contains only values less than the node's value and the right subtree of a node in a binary search tree contains only values greater than or equal to the node's value. Sorting and search algorithms for binary trees tend to be relatively efficient.
  • a digital tree is a tree for storing strings in which nodes are organised by substrings common to two or more strings. Searching of a digital tree involves use of the search keys only, i.e. values associated with each node are not read at each node as the tree is traversed. Instead, a node value may be read only once a suitable node key is found during search of the tree.
  • a trie sometimes called a prefix tree, is an ordered tree data structure that is used to store an associative array where the keys are strings. Unlike a binary search tree, no node in the tree stores the key associated with that node. Instead, the position of a node in the tree determines what key the node is associated with. All the descendants of any one node have a common prefix of the string associated with that node. The root node is commonly associated with the empty string.
  • tries include fast key lookup time and their suitability for longest-prefix matching.
  • Longest-prefix matching involves identifying a node whose node key shares the longest prefix with a given search key.
  • Tries also allow association of a search key with an entire group of node keys that have a common prefix. Tries have a disadvantage that when the set of node keys is sparse, i.e. when the actual node keys form a small subset of the set of potential keys, many of the internal nodes (non-leaf nodes) in the trie only have one descendant, giving the trie a high space occupancy.
  • the Patricia algorithm 'Practical Algorithm to Retrieve Information Coded in Alphanumeric', (Donald R. Morrison, Journal of the ACM, Column 15, Issue 4, October 1968, pp514-534 )1 is an algorithm which provides a flexible means of storing, indexing, and retrieving information in a large file, which is economical of index space and of reindexing time. It does not require rearrangement of text or indices as new material is added.
  • the Patricia algorithm can be used to create and process Patricia tree structures.
  • a Patricia tree sometimes called a radix tree, is an example of a binary digital trie in which any node which is an only child is merged with its parent. Traversal of a conventional trie uses every part of the key to determine which subtree to branch to, whereas by storing a search key part identifier, a Patricia tree nominates which element of the search key should be used next to determine the branching and hence which node should be traversed next. This removes the need for any nodes in the tree with just one descendant, so that only genuine branches are included in the index. This means that the index size is independent of the length of stored phrases.
  • the Patricia algorithm allows quick determination of whether a search key corresponds to a node key in the tree, for n nodes requiring 'of the order of log n' computations (O(log n)), whether a search key is prefixed by any node key in the tree, and if so which such prefix is longest in O(log n) computations, and whether a search key prefixes any node keys in the tree in O(log n) computations, and if so to walk through the m node keys prefixed in O(m) computations.
  • These properties make the Patricia algorithm a suitable choice for IP forwarding applications which rely on fast matching of IP destination addresses to prefixes, i.e. search keys to node keys.
  • a data structure constructed according to the Patricia algorithm has a limitation in that node keys stored in the data structure cannot prefix one another.
  • a method of searching a database using a search key said database containing data stored in a tree structure, said tree structure including a plurality of nodes, a node having associated data comprising:
  • the present invention allows searching of data in a database where one or more nodes stored in the database have associated node keys which are prefixes of node keys associated with other nodes stored in the database.
  • the invention thus allows a wider range of node keys to be represented in the database.
  • a search of the database involves traversing a first node whose node key prefixes the node key of a second node
  • the invention allows identification of the first node subsequently to traversal of the second node. This may involve comparing the node key of an identified node with a search key in order to determine whether there is an exact match, a prefix match, or no match between the identified node key and the search key.
  • the invention typically requires storage of two node pointers and data identifying a part of the search key to be used when traversing the node, i.e. a search key part identifier. Limited access to node keys is required during searching of the database and the search speed is advantageously independent of search key length.
  • No node keys need be stored in the tree structure itself. Instead a node key may be stored elsewhere, and for example associated with its node by a pointer. Alternatively, this may be implemented by embedding the node and its node key in a common data structure so that their association is determined by their relative fixed position in memory. Such an implementation would then require no pointer between the node and its node key.
  • third data indicating that said second node key is prefixed by said first node key is stored.
  • the first node whose node key prefixes the search key may be identified.
  • this may be achieved by storing data associated with a node pointer pointing from the second node to the first node and following this node pointer in order to traverse the tree structure from the second node to the first node.
  • nodes whose node keys are prefixes of each other may be identified and traversed using such node pointers.
  • this may be achieved by traversing one or more nodes above the first node in the tree structure after the traversal to the second node, but prior to the subsequent traversal to the first node.
  • all or part of the tree structure may be searched an additional time, but the additional search may finish during traversal of the first node instead of continuing on to traverse the second node.
  • this may be achieved by, during traversal of the tree, making note of one or more nodes whose search key part identifiers match those of their parents, i.e. by keeping track of which nodes have potential prefix matching node keys.
  • a particular node's search key part identifier relates to a search key bit to be used to determine a node pointer to be used when traversing the particular node.
  • search key part identifier instead of having to inspect the node key of each individual node when traversing the node, only its search key part identifier need be inspected in order to determine which node to traverse next. This gives increased efficiency in terms of computational complexity associated with searching the tree structure.
  • a particular node's search key part identifier relates to a relative location of a search key bit to be used compared to a previously used search key bit.
  • a node's search key part identifier may be relative to one or more previously traversed nodes.
  • a particular node's search key part identifier may relate to an absolute location of a search key bit to be used. This can help to reduce the amount of processing required during traversal of a node, for example reducing the number of search key and node key bits that need be compared.
  • inspection of a search key part identifier allows determination of a node pointer's type, i.e. whether a pointer from a particular node is an ancestor pointer or a child pointer, by checking whether a node referenced by a pointer has a lower search key part identifier. This can help avoid the need for flags or suchlike indicating node pointer types.
  • data parameters are stored in association with one or more nodes in said plurality.
  • information can be associated with each data node in the form of a stored data parameter.
  • stored data parameters can be viewed as a payload associated with the tree structure.
  • An end-result result of a search of the tree structure may include accessing and subsequent outputting of a stored data parameter.
  • stored data parameters may include routing or forwarding information associated with a route, network entity, network address, or part of a network, etc.
  • searching of the database comprises searching using an algorithm which is substantially similar to the Patricia algorithm, which provides efficient search capabilities.
  • a method of storing data in a database said database containing data stored in a tree structure, said tree structure including a plurality of nodes, a node having associated data comprising:
  • the present invention allows storing of data in a database where some nodes stored in the database have associated node keys which are prefixes of node keys associated with other nodes stored in the database.
  • the invention thus allows a wider range of node keys to be represented in the database.
  • a new node added to the database may be allocated a search key part identifier that is equal to the search key part identifier of a node immediately above the new node in the tree structure. This means that a new node may be skipped-over during subsequent searching of the tree structure, helping to further speed-up such subsequent searching.
  • the given prefix relationship comprises the node key of said given identified node being prefixed by said insertion search key.
  • the tree structure contains a node with an associated node key 000 and the database is searched using a search key 00 corresponding to the node key of a node to be added to the tree structure.
  • the proximate relationship comprises said new node being inserted above said given identified node in said tree.
  • a new node whose node key prefixes the node key of an existing node may be added above the existing node in the tree.
  • the new node may be inserted immediately above the given identified node in the tree structure, or further above the given identified node in the tree structure.
  • a node pointer that previously pointed to said given identified node is adjusted to point to said new node.
  • a node pointer is created pointing from said new node to said given identified node.
  • the given prefix relationship comprises the node key of said given identified node key being a prefix of said insertion search key.
  • the tree structure contains a node with an associated node key 00 and the database is searched using a search key 000 corresponding to the node key of a node to be added to the tree structure.
  • the proximate relationship comprises said new node being inserted below said given identified node in said tree.
  • a new node whose associated node key is prefixed by the node key associated with an existing node may be added below the existing node in the tree.
  • a node pointer that previously pointed from said given identified node is adjusted to point to said new node.
  • a node pointer is created pointing from said new node to a node below said new node in said tree.
  • a node pointer is created pointing from said new node to a node above said new node in said tree whose node key prefixes the node key of said new node.
  • the invention allows traversal between nodes whose associated node keys prefix each other.
  • the pointer created pointing to a node above said new node in said tree points to a node whose node key has the longest matching prefix to the node key of said new node of nodes above said new node in said tree.
  • the node with the next longest matching prefix of a search key can be identified. This can be useful, for example in an IP routing application when there has been an error or failure associated with the longest matching prefix, for example a broken or overloaded communication link.
  • a pointer pointing from said new node is adjusted to point to a root node, said root node having an empty node key.
  • the tree structure may contain a root node located at the top of the tree.
  • the root node may have an associated empty node key which prefixes all node keys in the tree.
  • at least one pointer from a new node inserted into the tree structure may point upwards to the root node.
  • the new node is removed from said tree structure by reversing one or more of the steps involved in inserting said new node into said tree structure.
  • the node may be removed from the tree and the relevant node pointers removed and adjusted accordingly.
  • the removal process may be reversible such that exactly the same steps used to insert the new node may be taken in reverse. However, if further nodes are added to the tree structure after the new node has been added, then removing the new node may involve steps which differ from those used previously to add the node.
  • this may correspond to a situation where a network node represented by a node in the tree structure may no longer be contactable via a particular IP address.
  • the node in the tree may be removed completely from the tree structure.
  • data associated with the node in the tree may be amended to reflect new contact details for the node.
  • a method of data packet routing in a data communications network comprising:
  • the network may be an Internet which operates according to an Internet Protocol.
  • the database may contain data packet routing information for a number of routes in a data communications network and associated node keys may be associated with network addresses.
  • the network entity may be a route in said network and said storing of data comprises inserting a new node into said data packet routing database corresponding to said route.
  • Addition of a new node to the database may for example occur in response to a new route, network entity or subnet becoming contactable whose network address is prefixed by or is a prefix of a node key associated with a node already in the forwarding database.
  • the route may be an existing route in said network and said storing of data comprises amending data in said data packet routing database associated with said existing route.
  • the amended data may comprise one or more node keys or search key part identifiers associated with one or more routes, nodes or entities represented in the database.
  • contact details for an existing route may change such that its new network address is prefixed by or is a prefix of a node key associated with a node already in the routing database.
  • Data associated with a node may be deleted completely from the tree structure or amended to reflect a new address.
  • network address data corresponding to a new or existing route in the network may be received at a network entity such as an IP router.
  • the router may include a routing table implemented in a tree structure containing node keys which are prefixes of each other.
  • the tree structure may be searched for node keys corresponding to a network address of the route or other such contact information associated with the route. If a tree node with an exactly matching or prefix matching node key is found, data associated with the node may be inspected and updated to reflect different routing information for the route, or a new node inserted to represent new routing information for the route.
  • the invention thus allows for routing with prefix matching to network addresses where no exact network address match exists in a routing database.
  • the invention allows routing even when a network address has a prefix relationship with one or more node keys corresponding to other routes.
  • Data packet routing protocols such as the Border Gateway Protocol (BGP) rely on the selection and advertisement of network address prefixes, so the invention may be suitably applied to networks such as the Internet where prefix matching is implemented.
  • Border Gateway Protocol BGP
  • forwarding information and/or route data associated with said route are output to a data packet forwarding table.
  • new or updated routing information for a route may be used to populate a data packet forwarding table.
  • said data identified in said forwarding table comprises network address data.
  • the network address data and/or the destination address data comprise Internet Protocol (IP) address data.
  • IP Internet Protocol
  • routing for network entities with network address containing IP address data may be carried out using the invention.
  • data packets containing IP address data may be forwarded to their destinations using the invention.
  • apparatus adapted to perform the method of the first, second and third aspects of the present invention.
  • FIG. 1 shows a system diagram of a data communications network according to an embodiment of the present invention.
  • the network comprises a routing network 118 including a number of interconnected core routers 100a, 100b, 100c and edge routers 102, 104, 106, 108.
  • Core routers 100a, 100b, 100c form the main connection links (backbone) of routing network 118 and emphasize in the transfer of large data volumes over the network.
  • Edge routers 102, 104, 106, 108 route data packets between respective local area networks 110, 112, 114, 116 and the backbone network formed by core routers 100a, 100b, 100c.
  • Figure 2 shows the architecture of an IP router 200 according to an embodiment of the present invention.
  • the router 200 is connected to a number of neighbouring nodes 212, 214, for example as shown in Figure 1 .
  • Router 200 includes a route processor 202 responsible for learning the network's topology in terms of routes between various parts of or entities located in the network.
  • Route processor 202 interfaces with neighbouring nodes 212, 214 in order to construct and maintain routing table 220.
  • Routing table 220 may be in the form of a tree structure database.
  • Route processor 202 stores routing information relating to various routes and routing protocols in routing table 220.
  • Route processor 202 is also responsible for providing route computation and updates 204 by outputting forwarding information and/or network address data to forwarding table 206.
  • Router 200 also includes a packet forwarder 210 responsible for receiving incoming data packets 216 and transmitting outgoing data packets 218.
  • packet forwarder 210 responsible for receiving incoming data packets 216 and transmitting outgoing data packets 218.
  • destination IP address data is read from the data packet and used in a search of forwarding table 206.
  • This search 208 involves searching forwarding table 206 for the IP destination address data of the data packet in order to determine corresponding forwarding information.
  • the forwarding information may contain an output port of router 200 to which to direct the data packet and the next hop, i.e. which neighbouring node, to transmit the packet on to.
  • Figure 3 shows an exemplary forwarding table 312 for a router 200, 300 according to an embodiment of the present invention.
  • Figure 3 depicts router 300 being interconnected to routers 303, 304, 306, 308 and 310. In reality, router 300 may be connected to many more other routers 326 and other such network devices.
  • Router 300 includes a route processor 302 which contains a routing table, for example in the form of a tree structure database 324. Router 300 also includes a forwarding table database 312 connected to route processor 302 Route processor 302 represents and keeps track of the network topology around router 300 using a tree structure stored in the tree structure database. Route processor 302 processes the tree structure and outputs new routes and route updates to forwarding table database 312. Note that route processor 302 may not necessarily output data to forwarding table database 312 every time a new route is added to or a route is amended in tree structure database 324.
  • the tree structure and forwarding table databases may exist as separate entities or alternatively a combined database entity. Likewise the route processor and packet forwarder may be separate entities or combined into a single entity.
  • Tree structure database 324 includes data relating to the tree structure in which the routing table database data is stored. This may include data associated with a plurality of nodes, each of the nodes having one or more node pointers, an associated node key, and a search key part identifier.
  • a node pointer may include data associated with nodes that may be traversed when the tree structure is being searched, for example a node located above or below the node in the tree structure.
  • a search key part identifier may include data identifying a search key part which may be used to determine a node pointer to be used when traversing the node. Search key part identifiers are discussed in more detail below.
  • Forwarding table database 312 may be used to store data output by route processor 302 relating to a number of prefixes and associated forwarding information for each of the prefixes.
  • the first column of forwarding table 312 includes the prefixes "1010", “1110”, “1010001”, and “101000111000”, shown as items 314, 316, 322, 324 respectively.
  • the default prefix 320 serves as a 'catch all' for all prefixes other than "1010", “1110", “1010001", and "101000111000”.
  • Item 318 shows that in practice, many more prefixes and associated forwarding information may be contained in forwarding table 312.
  • IPv4 addresses consist of 32 bits, which may be represented by four decimal numbers separated by decimal points, with each decimal number representing eight bits of a 32 bit IP address as discussed previously above.
  • IPv6 addresses consist of 128 bits which may be represented as eight hexadecimal 16-bit numbers separated by colons. The following binary examples are abstract and can correspond with any IP addressing scheme.
  • the second column of forwarding table 312 includes forwarding information for the prefixes listed in the forwarding table, i.e. where a data packet should be forwarded to according to the longest prefix match for the data packet's IP destination address.
  • the IP destination data used to search the routing table may be referred to as the search key and the prefixes at each of the nodes may be referred to as node keys.
  • the present invention overcomes the prefix limitation of algorithms such as the Patricia algorithm and associated tree structures without compromising their efficient search properties and without necessarily increasing the required data storage.
  • each node may contain a search key part identifier, and one or more node pointers.
  • the node pointers may be pointers to left (typically associated with a binary zero) or right (typically associated with a binary one) nodes to look at next when traversing the node.
  • a search key part identifier may identify a search key part which may be used to determine a node pointer to be used when traversing the node.
  • the search key part identifier may include a relative or absolute location of one or more bits in the search key or a number of bits in the search key that may be skipped when traversing the node.
  • a relative number of bits may for example be relative to a bit used to traverse a node above the relevant node, or a previously traversed node.
  • a search key part identifier thus indicates how many bits may be skipped, i.e. which bit of the search key should be examined, in order to determine the pointer to follow from the node when traversing the tree using a particular search key.
  • search key part identifier Use of a search key part identifier means that some search key bits may be skipped, i.e. ignored, during a search, so when a node is identified as a result of a search, a one-off comparison with the node key is required to check the match. A search may thus succeed or fail on the result of a comparison of a node key with a search key.
  • An upward step may for example involve following a node pointer that points from the node currently being traversed to a node above that node in the tree (commonly referred to as an ancestor pointer).
  • a step to the same node may for example involve following a pointer from the node currently being traversed to the same node in the tree (commonly referred to as a self-pointer).
  • FIG. 4 An example depiction of a tree structure according to an embodiment of the invention is shown in Figure 4 .
  • the tree contains three nodes, shown by items 400, 402 and 404.
  • each node key may correspond to a destination address prefix (for example as shown in the first column of forwarding database 312 in Figure 3 ) and each node could have an associated stored data parameter relating to forwarding information for that destination address prefix (for example as shown in the second column of forwarding database 312 in Figure 3 ).
  • the structure of the tree shown in Figure 4 may be stored in a tree structure database (for example as shown by item 324 in Figure 3 ).
  • the three nodes in Figure 4 are shown with their node keys in binary notation, being 0000, 0001 and 00100 respectively.
  • Each of the nodes has an associated search key part identifier, denoted in Figure 4 as the values in brackets at each node.
  • the node with a node key of 0000 has a search key part identifier of 2
  • the node with a node key of 0001 has a search key part identifier of 3
  • the node with a node key of 00100 has a search key part identifier of 3.
  • the search key part identifier for a node here denotes the absolute number of bits of the search key that should be skipped in order to determine which node pointer to follow when traversing the node.
  • nodes keys need not be, and are typically not, stored at the nodes themselves.
  • Another way to view the search key part identifier is that it can also be used to distinguish between nodes in the tree below the node being traversed, i.e. the search key part identifier denotes which bit in the node keys of the nodes below the node being traversed should be examined in order to distinguish between those node keys. So, for example, node 400 in Figure 4 with node key 0000, has a search key part identifier 2.
  • bit 2 (which is the third bit counting from the left-hand side after bit 0 and bit 1) distinguishes between the node keys of node 402 with search key part identifier 0001 and node 404 with search key part identifier 00100.
  • bit 2 of node 402 node's key is a binary zero and bit 2 of node 404 node's key is a binary one.
  • the tree starts at root node 400 with a node key of 0000 and a search key part identifier of 2.
  • the left pointer in node 400 corresponding to a binary zero, shown by item 406 is a child pointer as it points from node 400 to its left child node 402.
  • the left pointer in node 402, shown by item 410 is an ancestor pointer as it points from node 402 back to an ancestor node 400.
  • the right pointer in node 402, shown by item 412 is a self pointer as it points from node 402 to the same node 402.
  • the right pointer in node 400, shown by item 408, is a child pointer as it points from node 400 to its right child node 404.
  • the left pointer in node 404 is a self pointer as it points from node 404 to the same node 404.
  • the right pointer in node 404 is a self pointer as it points from node 404 to the same node 404.
  • the tree can be searched using a search key in order to check whether the tree contains a node key corresponding to the search key.
  • the search process which begins at the root node, is now described for a number of different search keys.
  • a zero in the search key corresponds to a left branch, i.e. follow the left pointer
  • a one in the search key corresponds to a right branch, i.e. follow the right pointer.
  • a search ends when a pointer to a node upwards in the tree or a self pointer is followed, or a search key part identifier of a traversed node indicates a bit that is beyond the end of the search key in question.
  • Bit 0 of the search key is on the left hand side of the search key (a zero), followed by the bit 1 (a zero), bit 2 (a one), bit 3 (a zero) and bit 4 (a zero), with a total of five bits.
  • the search process starts by traversing node 400.
  • the search key part identifier of this node is 2, so bit 2 of the search key should be inspected first.
  • Bit 2 of the lookup key is a 1, so the search branches right from there along right pointer 408 in Figure 4 to traverse node 404.
  • the search key part identifier of node 404 is 3, so bit 3 of the search key should be inspected.
  • Bit 3 of the search key is a zero, so the search branches left from there along the left pointer 414.
  • the search process is still traversing node 404, indicating that a self pointer has been followed, so the search ends here.
  • the search key can now be compared to the node key at the node, which can be seen to be identical (both 00100). This indicates a match, i.e. a successful search, meaning that search key 00100 is contained in the tree.
  • the actual stored data parameters associated with the nodes may be stored elsewhere and are not required during the traversal process.
  • the stored data parameters may be inspected at the end of a search.
  • the search process starts at node 400 with search key part identifier of 2.
  • Bit 2 of the search key is a zero, so the process branches left from there along left pointer 406 to traverse node 402.
  • the search key part identifier of node 402 is 3, so bit 3 of the search key should be inspected.
  • Bit 3 of the search key is a 1, so the process branches right from there along right pointer 412.
  • the search process is still traversing node 402, indicating that a self pointer has been followed, so the search ends here. Comparing the search key with the node key results in a failure as the node key of node 402 is 0001, which is not the same as the search key which is 0101. The search thus provides the information that nothing in the tree prefixes or is prefixed by this search key.
  • the search process starts at node 400 with a search key part identifier of 2. Bit 2 of the search key is a zero, so the search process branches left from there along left pointer 406 to traverse node 402.
  • the search key part identifier of node 402 is 3, so bit 3 of the search key should be inspected. Bit 3 of the search key is a 0, so the process branches left from there along left pointer 410 to traverse node 400.
  • the search process is now at node 400, indicating that a pointer upwards to an ancestor node has been followed, so the search ends here. Comparing the search key with the node key at the node gives a match, i.e. a successful search meaning that search key 0000 is contained in the tree.
  • the search process starts at node 400 with a search key part identifier of 2.
  • Bit 2 of the search key is a zero, so the process branches left from there along left pointer 406 to traverse node 402.
  • the search key part identifier of node 402 is 3, so bit 3 of the search key should be inspected.
  • Bit 3 of the search key is a 1, so the process branches right from there along right pointer 412 to traverse node 402.
  • the search process is still at node 402, indicating that a self pointer has been followed, so the search ends here. Comparing the search key with the node key at the node, gives a match up to the node length, i.e. the first four bits of the search key match the four bits of the node key at the node identified by the search. There are several bits left over in the search key, i.e. 01010, so this node key is the longest prefix node key contained in the tree for this search key.
  • the search process starts at node 400 with a search key part identifier of 2. Bit 2 is past the end of the search key, so the search stops here. Comparing the search key with the node key at the node identified at the end of the search gives a match up to search key length, i.e. the first two bits of the search key match the first two bits of the node key. This means that this node key is prefixed by the search key.
  • the search process starts at node 400 with a search key part identifier of 2.
  • Bit 2 of the search key is a zero, so the process branches left from there along left pointer 406 to traverse node 402.
  • the search key part identifier of node 402 is 3, so bit 3 of the search key should be inspected.
  • Bit 3 is past the end of the search key, so the search stops here. Comparing the search key with the node value at the node identified at the end of the search gives a match up to the search key length, i.e. the first three bits of the search key match the first three bits of the node key. This means that this node key is prefixed by the search key.
  • the search finds the shortest node key prefixed by the search key.
  • a list of node keys in the tree which are prefixed by the search key can be determined by traversing the subtree, i.e. the node itself and all descendents of that node, of the matched node, including pointers back up to their ancestors (but not the descendents of those ancestors).
  • search key 00 it can be seen that the whole tree is prefixed by this search key as nodes 402 and 404 are in the subtree for node 400.
  • search key 000 it can be seen that the 400 and 402 nodes are prefixed by this search key as node 402 has an ancestor pointer to node 400, but that the remainder of the tree, is not, as node 404 is not in the subtree for node 402.
  • Node 400 has a search key part identifier of 2 and no self pointers. So, searching using a search key of 0000 (or any search key prefixed by 0000) will result in traversal past this node with the search not ending at that node. A search using this search key returns to find node 400 using the ancestor pointer 410 at node 402.
  • any node that has no self pointer is the ancestor of a node somewhere in its subtree.
  • a node may have two self pointers, a self and a child, a self and an ancestor, two children, or a child and an ancestor. In the latter two cases, the node must be the ancestor of a descendent within its subtree.
  • each node in the tree requires at least one ancestor or self pointer to it.
  • n nodes there are exactly n+1 pointers available to fill this role, however the tree structure is arranged.
  • the right child of node 404 is the pointer that will not be followed during a successful search.
  • Tree structures such as those constructed according to the Patricia algorithm have an inherent restriction, that no node key in the tree may be the prefix of any other node key in the tree.
  • the present invention extends conventional tree structures such as the Patricia tree structure as described below.
  • the extension does not suffer from the drawbacks described above, whilst allowing nodes with node keys that prefix each other to be stored in the tree and also nodes with node keys that are prefixed by node keys of other nodes in the tree to be inserted into the tree. Further, the present invention does not detract from the search performance and key prefixing qualities when used with algorithms such as the Patricia algorithm.
  • the node with the longer node key is a descendent node of the node with the shorter node key.
  • the node with the shorter node key will be allocated the same search key part identifier as its parent.
  • the node with the shorter node key is a new type of node referred to herein as a skipped-prefix node.
  • the search key part identifier of a skipped-prefix node matches its parent's, and consequently one of its node pointers is unusable during searching of the tree. That node pointer may be referred to as being 'off the downward tree.
  • a search of the tree will traverse through the skipped-prefix node to its child, no matter what search key is being looked up, i.e. the skipped-prefix node is always skipped during downward traversal. Multiple such skipped-prefix nodes may be inserted into the tree if multiple prefixing node keys exist, for example if 0, 00, 000 and 0000 need to be represented in the tree.
  • skipped-prefix nodes that have been traversed through during a search may be examined in reverse order to find the longest search key match.
  • the invention introduces skip-back node pointers which are used to indicate either:
  • a node containing no key also known as an empty key, may be kept in the tree at a root node, so that the root will be a skipped-prefix node if there are any other nodes in the tree, and the root node will have a search key part identifier of zero. This can help to minimise special case treatment for manipulating the root node.
  • a node can be identified as a skipped-prefix node if and only if it has a child node and either:
  • Figure 5 is a flow chart showing searching of a tree structure according to an embodiment the present invention.
  • the search process begins at step 500 where nodes in the tree are traversed, as described above using a search key. This will typically begin at a root node located at the top of the tree.
  • the search will identify a node in the tree, either when a self-pointer is followed, a pointer to a node upwards in the tree is followed, or a search key part identifier of a traversed node indicates a bit that is beyond the end of the search key in question.
  • This information is noted because the most recently traversed node whose search key part identifier matches that of its parent node is a potential prefix matching node. It should be noted that any such potential prefix match is not resolved during traversal of the tree, i.e. node keys of such nodes are not compared to the search key during traversal of the tree. Noting of this information may involve use of a pointer, a flag or any such feature that allows the most recently traversed potential prefix matching node to be identified.
  • the search key is then compared in step 502 with the node key of the node identified in the search.
  • the search process ends at this node in step 512.
  • the node key of the identified node is a match in the tree structure for the search key.
  • step 504 If the search key does not match the node key of the node identified in the search, see step 504, the search process continues on to step 506.
  • the node key of the root node may be the longest prefix that exists for the search key. Under the simplifying assumption that the root node key is the empty key, this is always the case.
  • step 506 If the last potential prefix match node is not the root node, see step 506, the search process continues on to step 508.
  • step 508 the search key is compared to the node key of the last potential prefix node that was traversed.
  • the search key does match the node key of the last potential prefix node that was traversed, see step 510, then the search ends at step 516.
  • the node key of the last potential prefix node that was traversed is a match in the tree structure for the search key.
  • step 510 the search process continues on to repeat steps 506, 508 and 510 as necessary, until either the root node is reached or a match is found to a node key of a potential prefix match node. In this way, nodes with successively shorter node keys will be inspected until a node with a matching prefix node key is reached. If no such node with a matching prefix node key is found, then the root node may be reached as its empty key prefixes all node keys.
  • Figure 6 is a flow chart showing insertion of new data into a tree structure according to an embodiment of the present invention.
  • step 600 begins in step 600 when new data to be added to the tree is received.
  • the tree is searched using a search key corresponding to the new data to be added in step 602. If the search results in a node with a node key exactly matching the search key being identified, as shown in step 604, then the data is already represented in the tree and the data insertion is rejected in step 614.
  • Step 606 the new data is added to the tree by inserting a new skipped-prefix node according to a Procedure A, as depicted in Figure 7 .
  • Step 700 in Figure 7 shows that a new skipped-prefix node corresponding to the new data is inserted above the node identified in the search.
  • a child node pointer that previously pointed to the node identified in the search is adjusted in step 702 to point to the new skipped-prefix node.
  • a child node pointer from the new skipped-prefix node is created pointing to the node identified in the search in step 704.
  • a skip-back node pointer pointing from the new skipped-prefix node to the last skipped-prefix ancestor node traversed is created in step 706.
  • the pointers of any descendants of the inserted node that indicated the last skipped-prefix node traversed are updated to instead indicate the inserted node in step 707.
  • the new skipped-prefix node is allocated a search key part identifier equal to the search key part identifier of the node above it in the tree in step 710. This completes the node insertion Procedure A for the case where the search identifies a node with a node key which is prefixed by the search key.
  • Step 608 the new data is added to the tree by inserting a new non-skipped-prefix node and updating the node identified in the search to be a skipped-prefix node according to a procedure B, as depicted in Figure 8 .
  • Step 800 in Figure 8 shows that a new node corresponding to the new data is inserted below the node identified in the search.
  • a child node pointer that previously pointed from the node identified in the search is adjusted in step 802 to point to the new node.
  • a child node pointer from the new node is created pointing to the node below it in step 804.
  • the node above is updated to be a skipped-prefix node.
  • a skip-back node pointer pointing from the newly updated skipped-prefix node to the last skipped-prefix ancestor node traversed during insertion is created in step 806. Any descendants of the inserted node that indicated that ancestor are changed to instead indicate the newly updated skipped-prefix node in step 807.
  • a node key equal to the search key, i.e. the key to be inserted, is allocated to the newly inserted node in step 808.
  • the newly inserted node is allocated a search key part identifier equal to the search key part identifier of the node above it in the tree in step 810, that is the former search key part identifier of the newly-updated skipped-prefix node.
  • the newly updated skipped-prefix node is then allocated a search key part identifier equal to the search key part identifier of the node above it in the tree in step 812. This completes the node insertion Procedure B for the case where the search identifies a node with a node key which prefixes the search key.
  • the node key of the identified node and the search key differ at a particular bit.
  • the tree may be searched an additional time, but this time stopping the search at the node with the differing bit, as shown in step 612.
  • the new data is added 620 to the tree by inserting a new node according to a procedure C, as depicted in Figure 9 . Note that in this case the new node is not a skipped-prefix node.
  • Step 900 in Figure 9 shows that a new node corresponding to the new data is inserted below the node having a node key with a differing bit to the search key.
  • Step 912 also includes creating a child node pointer from the inserted node to the first node below the new node in its subtree.
  • a node pointer (may be an ancestor pointer or a self pointer) of the node having a node key with a differing bit to the search key is adjusted to be a child node pointer pointing from the node with the differing node key bit, to the inserted node.
  • a node key equal to the search key is allocated to the new node in step 908.
  • the new node is allocated a search key part identifier equal to the bit number of the differing bit in step 910. This completes the node insertion Procedure C for the case where the search identifies a node with a node key which does not exactly match or prefix match the search key.
  • step 612 data may be replaced by storing during the initial search process, data which identifies the node whose node key differs from the search key at a particular bit. This data could then be used to traverse to the node with the differing bit, without having to conduct an additional search of the tree.
  • Figure 10 shows a tree structure according to an embodiment of the present invention.
  • the tree structure consists of a root node 1000 with an empty node key and search key part identifier of zero (shown in brackets).
  • the node keys associated with each node have been included in the diagram at each node for explanatory purposes. The node keys themselves will typically be stored elsewhere.
  • the left node pointer 1014 from root node 1000 points to node 1002 which has a node key of 00 and a search key part identifier of 1.
  • the left node pointer 1018 from node 1002 is a self pointer.
  • the right node pointer 1090 from node 1002 is a self-pointer.
  • the right pointer 1016 from root node 1000 points to node 1006 which has a node key of 111 and a search key part identifier of 2.
  • the left node pointer 1058 from node 1006 points to node 1008 and the right node pointer 1032 from node 1006 is a self pointer.
  • Node 1008 has a node key of 1101100 and search key part identifier of 5.
  • the left node pointer 1060 from node 1008 points to node 1010.
  • Node 1010 has a node key of 1101101 and a search key part identifier of 6.
  • the left node pointer 1024 from node 1010 is an ancestor pointer to node 1008 and the right pointer 1026 from node 1010 is a self pointer.
  • the right node pointer 1062 from node 1008 points to node 1012.
  • Node 1012 has a node key of 11011101 and a search key part identifier of 5.
  • the left node pointer 1028 from node 1012 is a self pointer and the right node pointer 1030 from node 1012 is also a self pointer.
  • Figure 11 shows an extension of the tree structure of Figure 10 by insertion of a new node according to an embodiment of the present invention. Related nodes have been given related item numbers, but '1000's in Figure 10 compared to '1100's in Figure 11 .
  • the structure has an empty root node 1100 with a search key part identifier of zero (shown in brackets).
  • the left pointer 1114 from root node 1100 points to node 1102 which has a node key of 00 and search key part identifier of 1.
  • the left node pointer 1118 from node 1102 is a self pointer.
  • the right node pointer 1156 from node 1102 points to node 1104.
  • Node 1104 has a node key of 01 and search key part identifier of 1.
  • the left node pointer 1120 from node 1104 is a self pointer and the right node pointer 1122 from node 1104 is also a self pointer.
  • the right pointer 1116 from root node 1100 points to node 1106 which has a node key of 111 and search key part identifier of 2.
  • the left node pointer 1158 from node 1106 points to node 1108 and the right node pointer 1132 from node 1106 is a self pointer.
  • Node 1108 has a node key of 1101100 and search key part identifier of 5.
  • the left node pointer 1160 from node 1108 points to node 1110.
  • Node 1110 has a node key of 1101101 and search key part identifier of 6.
  • the left node pointer 1124 from node 1110 is an ancestor pointer to node 1108 and the right node pointer 1126 from node 1110 is a self pointer.
  • the right node pointer 1162 from node 1108 points to node 1112.
  • Node 1112 has a node key of 11011101 and a search key part identifier of 5.
  • the left node pointer 1128 from node 1112 is a self pointer and the right pointer 1130 from node 1112 is also a self pointer.
  • Forming the structure of Figure 11 involves inserting an additional node 1104 with a node key of 01 and search key part identifier of 1 into the structure of Figure 10 .
  • This insertion will be carried out according to procedure C shown in Figure 9 , as the search key 01 corresponding to the node key of the node to be inserted, neither exactly matches, nor is prefixed by, nor is a prefix for, any of the node keys of nodes already in the tree.
  • Insertion of the new node involves searching the tree of Figure 10 using a search key of 01. This search will result in traversal of node 1002 where self-pointer 1090 is followed.
  • the node having a node key which differs from the search key at a particular bit position is node 1002 with node key 00.
  • the new node will thus be inserted below node 1002 as shown in Figure 11 as new node 1104.
  • This node has no subtree, so two self-pointers are created to/from node 1104 and right pointer 1090 from node 1002 is adjusted to be a child pointer 1156 from node 1102 to new node 1104.
  • Figure 12 shows an extension of the tree structure of Figure 11 by insertion of a new node according to an embodiment of the present invention.
  • Forming the structure of Figure 12 involves inserting a new node 1234 with a node key of 000 and search key part identifier of 1 into the structure.
  • the new node will not be a skipped-prefix node itself.
  • the key to be inserted, 000 is prefixed by the node key 00 of existing node 1202. This means that node 1202 will be updated to be a skipped-prefix node.
  • Insertion of the additional node involves searching the tree of Figure 11 using a search key of 000. Searching using the search key 000 will identify node 1102. The new node to be added for key 000 is added below node 1102 where the search ended, according to Procedure B as shown in Figure 8 . This is depicted in Figure 12 , where the newly inserted node 1234 is located below node 1202 in the tree.
  • Newly inserted node 1234 is allocated a search key part identifier equal to that of the node above it in the tree (step 810), which in this case is that of node 1102, i.e. a search key part identifier equal to 1.
  • the node key 000 of new node 1234 is prefixed by the node key 00 of node 1202 above it, so node 1202 is updated to be a skipped-prefix node.
  • node 1202 is now a skipped-prefix node is denoted by the dotted diamond around it.
  • the left node pointer 1114 from root node 1100 is adjusted to point 1266 to skipped-prefix node 1202 below it in the tree.
  • Left node pointer 1118 from skipped-prefix node 1202 is adjusted to point to node 1234.
  • Right node pointer 1156 from skipped-prefix node 1202 is adjusted to be a skip-back pointer 1236 to root node 1200 above it in the tree.
  • the root node has also has a dotted diamond around it to denote it is a skipped-prefix node, as its empty node key prefixes the node keys of all other nodes in the tree.
  • pointer 1236 is a skip-back node pointer is denoted by the dashed arrow notation in Figure 12 .
  • Skip-back node pointer 1236 points back to the node with the next skipped-prefix node above node 1202, which in this case is root node 1200 with an empty key.
  • node 1202 is now a skipped-prefix node, so its search key part identifier is updated to be the same as that of its parent, the parent being in this case root node 1200 with a search key part identifier of zero (step 812).
  • skipped-prefix node 1202 with node key 00 will always be skipped and the search process will always move directly on to traverse node 1234 with node key 000.
  • Figure 13 shows an extension of the tree structure of Figure 12 by insertion of a further skipped-prefix node according to an embodiment of the present invention.
  • Forming the structure of Figure 13 involves inserting a further skipped-prefix node 1338 with a node key of 0 into the structure. Insertion of the further skipped-prefix node involves searching the tree of Figure 12 using a search key of 0.
  • the search key 0 prefixes the node key 00 of node 1202, so searching using the search key 0 will identify node 1202.
  • the new skipped-prefix node to be added for key 0 is added above node 1202 where the search ended, according to Procedure A as shown in Figure 7 . This is depicted in Figure 13 , where the new skipped-prefix node 1338 is located above node 1302 in the tree.
  • This further node 1338 is a skipped-prefix node, denoted by the dotted diamond around it.
  • the left node pointer 1266 from root node 1200 is adjusted to point 1370 to further skipped-prefix node 1338.
  • a left node pointer 1368 from further skipped-prefix node 1338 is created to point to node 1302 below it in the tree.
  • a right pointer 1342 from further skipped-prefix node 1338 is created as a skip-back pointer to root node 1300 above it in the tree.
  • the skip-back pointer 1236 from skipped-prefix node 1202 is adjusted to point back to the next skipped-prefix node above it, which in this case is node 1338, as shown by skip-back pointer 1340.
  • Skip-back pointer 1342 points back to the next skipped-prefix above node 1338, which in this case is root node 1300 with an empty key. This reverse path of skipped-prefix pointers up the tree may be followed in order to find the sequence of potential prefix matches for a search key.
  • skipped-prefix node 1338 inherits the same search key part identifier as its parent, the parent being in this case root node 1300 with a search key part identifier of zero.
  • skipped-prefix nodes 1338 and 1302 with node keys 0 and 00 respectively, will be skipped and the searching will move directly on to traverse node 1334 having node key 000.
  • Figure 14 shows an extension of the tree structure of Figure 13 by insertion of a still further skipped-prefix node according to an embodiment of the present invention.
  • Forming the structure of Figure 14 involves inserting a still further skipped-prefix node 1442 with a node key of 110 into the structure. Insertion of the new node involves searching the tree of Figure 13 using a search key of 110.
  • the search key 110 prefixes the node key 1101100 of node 1308, so searching the tree using the search key 110 will identify node 1308.
  • the new skipped-prefix node to be added with node key 110 is added above node 1308 where the search ended, according to Procedure A as shown in Figure 7 .
  • This is depicted in Figure 14 , where the new skipped-prefix node 1442 is located above node 1408 in the tree.
  • the left node pointer 1374 from node 1306 is adjusted to point 1474 to new skipped-prefix node 1442.
  • a left node pointer 1472 from new skipped-prefix node 1442 is created pointing to node 1408 below it in the tree.
  • a right node pointer 1444 from new skipped-prefix node 1442 is created as a skipped-prefix pointer to root node 1400.
  • Skipped-prefix pointer 1444 points back to the node that is the next skipped-prefix ancestor above node 1442, which in this case is root node 1400 with an empty key.
  • new skipped-prefix node 1442 inherits the same search key part identifier as its parent, the parent being in this case being node 1406 with a search key part identifier of 2.
  • Figure 15 shows an extension of the tree structure of Figure 14 by insertion of a yet still further skipped-prefix node according to an embodiment of the present invention.
  • Forming the structure of Figure 15 involves inserting a new further skipped-prefix node 1546 with a node key of 11011 into the structure. Insertion of the new skipped-prefix node involves searching the tree of Figure 14 using the search key 11011.
  • the search key 11011 prefixes node key 1101100 of node 1408, so searching the tree using this search key identifies node 1408 whose search key part identifier of indicates a bit that is beyond the end of the five bit search key.
  • the node key for the node to be inserted is a prefix of the node key at the node found in the search, so the node to be added for search key 11011 is added above node 1408 where the search ended.
  • the new skipped-prefix node to be added with node key 11011 is added above node 1408 where the search ended, according to Procedure A as shown in Figure 7 .
  • New skipped-prefix node 1546 is a skipped-prefix node, denoted by the dotted diamond around it.
  • the left node pointer 1472 from skipped-prefix node 1442 is adjusted to point 1578 to new skipped-prefix node 1546 below it in the tree.
  • a left node pointer 1576 from new skipped-prefix node 1546 is created to point to node 1508 below it in the tree.
  • a right node pointer 1580 from new skipped-prefix node 1546 is created as a skipped-prefix pointer to skipped-prefix node 1542 above it in the tree.
  • Skipped-prefix pointer 1580 points back to the next skipped-prefix node above node 1546, which in this case is node 1542.
  • new skipped-prefix node 1546 inherits the same search key part identifier as its parent, the parent being in this case being skipped-prefix node 1542 with a search key part identifier of two.
  • skipped-prefix nodes 1542 and 1546 with node keys 110 and 11011 respectively will be skipped and the search process will move on to traverse node 1508 with node key 1101100.
  • Figure 16 shows an extension of the tree structure of Figure 15 by insertion of another skipped-prefix node according to an embodiment of the present invention.
  • Forming the structure of Figure 16 involves inserting a new skipped-prefix node 1682 with a node key of 1 into the structure. Insertion of the new node involves searching the tree of Figure 15 using a search key of 1.
  • the search key 1 prefixes the node key 111 of node 1606, so searching of the tree using this search key identifies node 1506.
  • the new skipped-prefix node to be added for node key 1 is added above node 1606 identified in the search, according to Procedure A as shown in Figure 7 . This is depicted in Figure 16 , where the new skipped-prefix node 1682 is located above node 1606 in the tree.
  • the right node pointer 1588 from root node 1500 is adjusted to point 1688 to new skipped-prefix node 1682.
  • a right node pointer 1684 from new skipped-prefix node 1682 is created pointing to node 1606 below it in the tree.
  • a left node pointer 1686 from new skipped-prefix node 1682 is created as a skipped-prefix pointer to root node 1600.
  • Skipped-prefix pointer 1544 from node 1542 is adjusted to point 1644 back to the next skipped-prefix node above node 1642, which in this case is node 1682 with a node key of 1.
  • skipped-prefix pointer 1644 in this case does not point to node 1606 immediately above node 1642 in the tree, but to node 1682 above node 1644. This is because node 1606 with node key 111 is not itself a skipped- prefix node, whereas node 1682 with node key 1 is a skipped-prefix node.
  • new skipped-prefix node 1682 inherits the same search key part identifier as its parent, the parent being in this case root node 1600 with a search key part identifier of zero.
  • the extended tree structure shown in Figure 16 can be seen to have a total of six skipped-prefix nodes, including the root node.
  • the extended tree of Figure 16 can be searched by carrying out a search process using a search key in order to check whether the tree contains a node key corresponding to the search key.
  • the search process which begins at root node 1600, is now described for a number of different search keys.
  • a zero in the search key corresponds to a left branch and a one in the search key corresponds to a right branch.
  • a search ends when a pointer to a node upwards in the tree or a self pointer is followed, or a search key part identifier of a traversed node indicates a bit that is beyond the end of the search key in question.
  • the search process starts at root node 1600 with an empty key and a search key part identifier of 0, shown by item 1600 in Figure 16 .
  • Bit 0 of the search key is a zero, so the search process branches left from there along the left node pointer from root node 1600 to traverse skipped-prefix node 1638 which has a search key part identifier of zero.
  • Bit zero of the search key is a zero, so the search process branches left along the left node pointer from skipped-prefix node 1638 to traverse skipped-prefix node 1634 which has a search key part identifier of zero.
  • Bit zero of the search key is a zero, so the search process branches left along the left node pointer from skipped-prefix node 1634 to traverse node 1606.
  • the search process is now at node 1606 which has a search key part identifier of 1.
  • Bit 1 of the search key is a 1, so the search process branches right along the right node pointer from node 1606 to traverse node 1604.
  • the search process is now at node 1604 which has a search key part identifier of 1.
  • Bit 1 of the search key is a 1, so the search process branches right along the right node pointer from node 1604, which is a self pointer to the same node 1604, so the search ends here.
  • the search process starts at root node 1600 with an empty key and a search key part identifier of 0, shown by item 1600 in Figure 16 .
  • Bit 0 of the search key is a zero, so the search process branches left from there along the left node pointer from root node 1600 to traverse skipped-prefix node 1638.
  • the search process is now at skipped-prefix node 1638 which has a search key part identifier of zero.
  • Bit zero of the search key is a zero, so the search process branches left along the left node pointer from skipped-prefix node 1638 to traverse skipped-prefix node 1634.
  • the search process is now at skipped-prefix node 1634 which has a search key part identifier of zero.
  • Bit zero of the search key is a zero, so the search process branches left along the left node pointer from skipped-prefix node 1634 to node 1606.
  • the search process is now at node 1606 which has a search key part identifier of 1.
  • Bit 1 of the search key is a 0, so the search process branches left along the left node pointer from node 1606 which is a self pointer to the same node 1606, so the search ends here.
  • Comparison of the search key with the node key at the node does not result in a match.
  • the last skipped-prefix node that was encountered during the search process was node 1634 with node key 00.
  • the search key is then compared with the node key at this node, where it is seen that the first two bits of the search key match the node key of node 1634. This means that the first two bits of the search key, i.e. 00, form the longest prefix in the tree for this search key.
  • the search process starts at root node 1600 with an empty key and a search key part identifier of 0, shown by item 1600 in Figure 16 .
  • Bit 0 of the search key is a 1, so the search process branches right from there along the right node pointer 1688 from root node 1600 to traverse skipped-prefix node 1682.
  • the traversal process is now at skipped-prefix node 1682 which has a search key part identifier of zero.
  • Bit zero of the search key is a 1, so the search process branches right along the right node pointer 1684 from skipped-prefix node 1682 to traverse node 1606.
  • the search process is now at node 1606 which has a search key part identifier of 2.
  • Bit 2 of the search key is a zero, so the search process branches left along the left node pointer from node 1606 to traverse node 1642.
  • the search process is now at skipped-prefix node 1642 which has a search key part identifier of 2.
  • Bit 2 of the search key is a 0, so the search process branches left along the left node pointer from skipped-prefix node 1642 to traverse skipped-prefix node 1646.
  • the search process is now at skipped-prefix node 1646 which has a search key part identifier of 2.
  • Bit 2 of the search key is a 0, so the search process branches left along the left node pointer from skipped-prefix 1646 to traverse node 1608.
  • the search process is now at node 1608 which has a search key part identifier of 5.
  • Bit 5 of the search key is a 1, so the search process branches right along the right node pointer from node 1608 to traverse node 1612.
  • the search process is now at node 1612 which has a search key part identifier of 5.
  • Bit 5 of the search key is a 1, so the search process branches right along the right node pointer from node 1612, which is a self pointer to node 1612, so the search ends here.
  • Comparison of the search key with the node key at the node does not result in a match.
  • the last skipped-prefix node that was encountered during the search was node 1646 with node key 11011.
  • the search key is then compared with the node key at this node, where it is seen that there is a match up to the node key length of five bits. This means that the first five bits of the search key, i.e. 11011 form the longest prefix in the tree for this search key.
  • the search process for this search key proceeds as per the previous search example.
  • the skip-back node pointer 1680 is then followed to the previous skipped-prefix node that was encountered during the search, i.e. node 1642 with node key 110.
  • Comparison of the search key with the node key at node 1642 results in a match up to the node key length. This means that the first three digits of the search key, i.e. 110, form the longest prefix in the tree for this search key.
  • the structure and algorithm of the present invention perform efficiently in terms of computational complexity.
  • the tree structure contains no nodes with node keys that prefix any other node keys in the tree, the tree requires O(log n) computations ('of the order log n computations) for search, and also for insertion and deletion of nodes.
  • search behaves similarly to a conventional search to select a list of prefixes to check, followed by a linear scan of those prefixes, from best match to worst match.
  • lookup requires O(p + log n) computations.
  • Insertion and deletion of nodes is typically O(log n).
  • Worst-case insertion is O(n) because a complete walk of a subtree is required to update ancestor pointers.
  • Worst-case deletion is O(nlog n) because a deletion potentially disturbs O(log n) skipped-prefix nodes and each disturbance requires a similar walk of a subtree.
  • worst cases are not-commonly encountered, and under realistic stress, insertion and deletion have been found to behave consistently with a requirement for O(log n) computations.
  • the invention may be applied to storage and retrieval of node addresses in Constrained Shortest Path First (CSPF) IP routing databases where fast database access and update is required, for example while the network is 'converging' or 'reconverging' as large numbers of routes are recalculated after an update to the network.
  • CSPF Constrained Shortest Path First
  • Some destinations are provided as a prefix rather than a full explicit IP address, and would therefore require special handling by systems using the prior art Patricia algorithm and tree structure, which implies that such systems converge at a slower rate.
  • the invention may also be applied to storage and retrieval of IP addresses in IP Routing Information Bases (RIBs).
  • IP routing protocols such as Open Shortest Path First (OSPF), Intermediate System-Intermediate System (IS-IS), Routing Information Protocol (RIP), Border Gateway Protocol (BGP), etc.
  • OSPF Open Shortest Path First
  • IS-IS Intermediate System-Intermediate System
  • RIP Routing Information Protocol
  • BGP Border Gateway Protocol
  • the invention may also find application in the storage and retrieval of IP addresses in an IP routing Forwarding Information Base (FIB), where a mixture of IP address prefixes and full-length IP addresses may be included.
  • FIB IP routing Forwarding Information Base
  • This is the composite of all the RIBs known to a router, and can be used to populate IP forwarding tables in hardware.
  • the scope of the invention should not limited to IP routing applications.
  • the invention may also be applied in any application where it is desirable to searching stored data without actually accessing that data.
  • data values may be stored in a location that is difficult to access such as in old or slow hardware, or which may have a constrained network bandwidth, or which may be pay-per-access, or where legal constraints exist such as copyright, etc.
  • a storage algorithm is required to search among these data values without actually storing a copy of the data values themselves, or accessing them unnecessarily. The invention allows this, requiring only a single access to the search result.
  • the invention may be applied for prefix matching in the representation of a hierarchy such as in the field of taxonomy.
  • a large catalogue of biological data may be efficiently represented and searched by use of the invention. All categories in, for example modem Linnaean taxonomy could be represented, and a search on a particular species/subspecies would yield either an exact match or a match on the most specific order/family/genus/species presently stored.
  • the invention could be applied in the storage and retrieval of entries from a telephone directory. All entries in a particular area could be efficiently listed, where a prefix may be the first few digits representing a telephone dialling code or localised area.
  • the invention permits quick retrieval even with a large database with billions of entries, such as all telephone numbers currently assigned globally. Here, only the length of the key being searched is significant in determining bounds on lookup times. The number of other non-prefix keys in the database has no effect on lookup time.
  • the invention could be applied in applications where rapid manipulation of very long keys is required and where manipulation independent of key length is desirable.
  • the invention could be used to index all the books in a copyright library, using only a low amount of data structure storage per book.
  • the prefix matching properties of the invention could be used to quickly determine whether a matching book is stored or not.
  • the invention could be employed to quickly determine whether an example text is among a large number of near-identical stored versions of the same long text. This could find particular application in modem scanning and text-reading technologies, or in comparative analyses of hand-copied ancient texts or suchlike.
  • the invention could be applied wherever efficient search and update of a massive database of keys is required. This could for example include a large quantity of biometric data for each individual currently within a particular state.
  • the search tree constructed by the invention can then function in isolation from the central database.
  • the invention could be used to index and search a massive central database on mobile devices without holding or accessing any of the actual content of the database on any mobile device.
  • Routing and forwarding are herein described as two distinct processes. However, routing and forwarding may be combined in some implementations and the invention could equally be applied to such combined implementations.

Landscapes

  • Engineering & Computer Science (AREA)
  • Theoretical Computer Science (AREA)
  • Databases & Information Systems (AREA)
  • General Physics & Mathematics (AREA)
  • Physics & Mathematics (AREA)
  • General Engineering & Computer Science (AREA)
  • Data Mining & Analysis (AREA)
  • Software Systems (AREA)
  • Computer Networks & Wireless Communication (AREA)
  • Signal Processing (AREA)
  • Library & Information Science (AREA)
  • Computing Systems (AREA)
  • Data Exchanges In Wide-Area Networks (AREA)
  • Information Retrieval, Db Structures And Fs Structures Therefor (AREA)
EP08164370A 2007-09-14 2008-09-15 Datenbank und Datenbankverarbeitungsverfahren Withdrawn EP2037381A1 (de)

Priority Applications (1)

Application Number Priority Date Filing Date Title
EP08165520.1A EP2040184B1 (de) 2007-09-14 2008-09-15 Datenbank und Datenbankverarbeitungsverfahren

Applications Claiming Priority (1)

Application Number Priority Date Filing Date Title
GB0717970A GB2452760A (en) 2007-09-14 2007-09-14 Storing and searching data in a database tree structure for use in data packet routing applications.

Related Child Applications (1)

Application Number Title Priority Date Filing Date
EP08165520.1A Division EP2040184B1 (de) 2007-09-14 2008-09-15 Datenbank und Datenbankverarbeitungsverfahren

Publications (1)

Publication Number Publication Date
EP2037381A1 true EP2037381A1 (de) 2009-03-18

Family

ID=38658976

Family Applications (2)

Application Number Title Priority Date Filing Date
EP08165520.1A Active EP2040184B1 (de) 2007-09-14 2008-09-15 Datenbank und Datenbankverarbeitungsverfahren
EP08164370A Withdrawn EP2037381A1 (de) 2007-09-14 2008-09-15 Datenbank und Datenbankverarbeitungsverfahren

Family Applications Before (1)

Application Number Title Priority Date Filing Date
EP08165520.1A Active EP2040184B1 (de) 2007-09-14 2008-09-15 Datenbank und Datenbankverarbeitungsverfahren

Country Status (4)

Country Link
US (1) US9672234B2 (de)
EP (2) EP2040184B1 (de)
CN (1) CN101388030B (de)
GB (1) GB2452760A (de)

Families Citing this family (26)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
JP5337308B2 (ja) * 2010-08-06 2013-11-06 インターナショナル・ビジネス・マシーンズ・コーポレーション 文字列生成方法、プログラム及びシステム
US8527546B2 (en) 2010-11-25 2013-09-03 International Business Machines Corporation Generating a checkpoint image for use with an in-memory database
US9155320B2 (en) 2011-07-06 2015-10-13 International Business Machines Corporation Prefix-based leaf node storage for database system
US9965821B2 (en) * 2012-03-09 2018-05-08 Nvidia Corporation Fully parallel in-place construction of 3D acceleration structures in a graphics processing unit
CN102609545A (zh) * 2012-03-14 2012-07-25 福建榕基软件股份有限公司 树型结构中快速搜索定位树结点的方法
US9876638B2 (en) * 2012-06-22 2018-01-23 Palo Alto Research Center Incorporated System and method for compressed level-ordered edge sequence encoding
US9223846B2 (en) * 2012-09-18 2015-12-29 International Business Machines Corporation Context-based navigation through a database
TWI483138B (zh) * 2012-10-12 2015-05-01 Acer Inc 遠端動態資料的處理與驗證方法、系統，以及電腦可讀記錄媒體
US9064030B2 (en) * 2012-11-29 2015-06-23 International Business Machines Corporation Tree traversal in a memory device
US9536016B2 (en) * 2013-01-16 2017-01-03 Google Inc. On-disk multimap
US9342512B1 (en) * 2013-03-15 2016-05-17 Tasktop Technologies, Incorporated System and method for repairing data synchronization links
US9697220B2 (en) * 2013-12-13 2017-07-04 Oracle International Corporation System and method for supporting elastic data metadata compression in a distributed data grid
US9529835B2 (en) * 2014-02-28 2016-12-27 Red Hat Israel, Ltd. Online compression for limited sequence length radix tree
JP6549704B2 (ja) 2014-09-25 2019-07-24 オラクル・インターナショナル・コーポレイション 分散コンピューティング環境内でゼロコピー２進基数木をサポートするためのシステムおよび方法
US9692727B2 (en) * 2014-12-02 2017-06-27 Nicira, Inc. Context-aware distributed firewall
US10152503B2 (en) * 2015-10-29 2018-12-11 The Dun & Bradstreet Corporation Data communications system and method that maximize efficient usage of communications resources
WO2017217163A1 (ja) * 2016-06-17 2017-12-21 日本電信電話株式会社 アクセス分類装置、アクセス分類方法及びアクセス分類プログラム
US10171419B2 (en) 2016-06-19 2019-01-01 Mellanox Technologies TLC Ltd. IP route caching with two search stages on prefix length
US10148571B2 (en) * 2016-06-20 2018-12-04 Mellanox Technologies Tlv Ltd. Jump on a match optimization for longest prefix match using a binary search tree
US10491521B2 (en) 2017-03-26 2019-11-26 Mellanox Technologies Tlv Ltd. Field checking based caching of ACL lookups to ease ACL lookup search
US10684960B2 (en) 2017-12-04 2020-06-16 Mellanox Technologies Tlv Ltd. Managing cache memory in a network element based on costs associated with fetching missing cache entries
US10515015B2 (en) 2018-03-20 2019-12-24 Mellanox Technologies Tlv Ltd. Hash table-based mask length computation for longest prefix match caching
US10616113B2 (en) 2018-07-19 2020-04-07 Mellanox Technologies Tlv Ltd. Longest prefix match using a binary search tree with compressed hash tables
KR102322729B1 (ko) * 2019-03-04 2021-11-05 어드밴스드 뉴 테크놀로지스 씨오., 엘티디. 블록체인 월드 스테이트 머클 패트리샤 트라이 서브트리의 업데이트
CN110390128B (zh) * 2019-06-10 2022-03-29 华南理工大学 一种易经八卦阵二叉树排布阵三步快速查找地址构建方法
US11502957B2 (en) 2020-05-14 2022-11-15 Mellanox Technologies, Ltd. Avoiding markers for longest prefix match based on binary search tree algorithm

Citations (4)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US6396842B1 (en) 1998-04-30 2002-05-28 3Com Corporation Method of searching using longest match based Randix Search Trie with variable length keys and having prefix capability
US20020065812A1 (en) * 2000-03-09 2002-05-30 The Web Access, Inc. Method and apparatus for accessing information within an electronic system
US6594675B1 (en) * 1999-08-26 2003-07-15 International Business Machines Corporation Method, system for using file name to access application program where a logical file system processes pathname to determine whether the request is a file on storage device or operation for application program
US20060004721A1 (en) 2004-04-23 2006-01-05 Bedworth Mark D System, method and technique for searching structured databases

Family Cites Families (10)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US6029170A (en) * 1997-11-25 2000-02-22 International Business Machines Corporation Hybrid tree array data structure and method
US6421660B1 (en) * 1997-12-19 2002-07-16 International Business Machines Corporation Enhanced searching method and apparatus for variable bit chains
US7249149B1 (en) * 1999-08-10 2007-07-24 Washington University Tree bitmap data structures and their use in performing lookup operations
US7111071B1 (en) * 2000-06-29 2006-09-19 Intel Corporation Longest prefix match for IP routers
GB2406679B (en) 2000-11-30 2005-05-18 Coppereye Ltd Database
KR100488414B1 (ko) * 2000-12-30 2005-05-11 한국전자통신연구원 다중탐색 트리의 노드 생성 방법, 및 그에 따라 생성된 다중탐색 트리 구조의 자료 탐색 방법
US7426518B2 (en) * 2003-03-28 2008-09-16 Netlogic Microsystems, Inc. System and method for efficiently searching a forwarding database that is split into a bounded number of sub-databases having a bounded size
US7299235B2 (en) * 2003-07-28 2007-11-20 Rightorder, Incorporated Method and apparatus for ternary PATRICIA trie blocks
US7693850B2 (en) * 2004-07-19 2010-04-06 Rightorder, Inc. Method and apparatus for adding supplemental information to PATRICIA tries
US7624226B1 (en) * 2005-12-20 2009-11-24 Netlogic Microsystems, Inc. Network search engine (NSE) and method for performing interval location using prefix matching

Patent Citations (4)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US6396842B1 (en) 1998-04-30 2002-05-28 3Com Corporation Method of searching using longest match based Randix Search Trie with variable length keys and having prefix capability
US6594675B1 (en) * 1999-08-26 2003-07-15 International Business Machines Corporation Method, system for using file name to access application program where a logical file system processes pathname to determine whether the request is a file on storage device or operation for application program
US20020065812A1 (en) * 2000-03-09 2002-05-30 The Web Access, Inc. Method and apparatus for accessing information within an electronic system
US20060004721A1 (en) 2004-04-23 2006-01-05 Bedworth Mark D System, method and technique for searching structured databases

Also Published As

Publication number Publication date
CN101388030B (zh) 2014-06-11
EP2040184B1 (de) 2019-03-13
EP2040184A1 (de) 2009-03-25
GB2452760A (en) 2009-03-18
CN101388030A (zh) 2009-03-18
US20090077076A1 (en) 2009-03-19
US9672234B2 (en) 2017-06-06
GB0717970D0 (en) 2007-10-24

Similar Documents

Publication Publication Date Title
EP2040184B1 (de) Datenbank und Datenbankverarbeitungsverfahren
Ruiz-Sánchez et al. Survey and taxonomy of IP address lookup algorithms
EP1358739B1 (de) Verfahren und vorrichtung zur leitweglenkungstabellenverwaltung
US8090901B2 (en) TCAM management approach that minimize movements
US6067574A (en) High speed routing using compressed tree process
US6553002B1 (en) Apparatus and method for routing data packets through a communications network
KR100586461B1 (ko) 파이프라인 이진 트리를 이용한 ｉｐ 어드레스 검색 방법,하드웨어 구조 및 기록매체
US6560610B1 (en) Data structure using a tree bitmap and method for rapid classification of data in a database
US6691124B2 (en) Compact data structures for pipelined message forwarding lookups
US7433871B2 (en) Efficient ipv4/ipv6 best matching prefix method and apparatus
US6594655B2 (en) Wildcards in radix- search tree structures
US6792423B1 (en) Hybrid longest prefix match and fixed match searches
US20040254909A1 (en) Programming routes and access control lists in comparison tree data structures and their use such as in performing lookup operations
US10148571B2 (en) Jump on a match optimization for longest prefix match using a binary search tree
WO2003079618A2 (en) System and method for longest prefix match internet protocol lookup
US7249149B1 (en) Tree bitmap data structures and their use in performing lookup operations
US7478109B1 (en) Identification of a longest matching prefix based on a search of intervals corresponding to the prefixes
US7233579B1 (en) Routing table for forwarding Internet Protocol (IP) packets through a communications network
KR100662254B1 (ko) 라우팅 시스템에서의 패킷 분류 장치 및 이를 위한 룰 구축 방법
JP3660311B2 (ja) テーブル検索装置および方法およびプログラムおよび記録媒体
KR100814077B1 (ko) 우선순위 트라이를 이용한 ｉｐ 주소 검색 방법 및 이를제공하는 패킷 중계 장치
KR100460188B1 (ko) 인터넷 프로토콜 주소 룩-업 방법
KR100459542B1 (ko) 인터넷 프로토콜 주소 룩-업 장치
KR20030075016A (ko) 클래스 분할 기법을 이용한 라우팅 테이블 자료구조,라우팅 테이블을 이용한 라우팅 경로 검색방법 및 장치
McLaughlin et al. High-speed ip address lookups using hardware based tree structures

Legal Events

Date Code Title Description
PUAI Public reference made under article 153(3) epc to a published international application that has entered the european phase

Free format text: ORIGINAL CODE: 0009012

17P Request for examination filed

Effective date: 20080915

AK Designated contracting states

Kind code of ref document: A1

Designated state(s): AT BE BG CH CY CZ DE DK EE ES FI FR GB GR HR HU IE IS IT LI LT LU LV MC MT NL NO PL PT RO SE SI SK TR

AX Request for extension of the european patent

Extension state: AL BA MK RS

17Q First examination report despatched

Effective date: 20090421

AKX Designation fees paid

Designated state(s): AT BE BG CH CY CZ DE DK EE ES FI FR GB GR HR HU IE IS IT LI LT LU LV MC MT NL NO PL PT RO SE SI SK TR

RAP1 Party data changed (applicant data changed or rights of an application transferred)

Owner name: METASWITCH NETWORKS LTD

STAA Information on the status of an ep patent application or granted ep patent

Free format text: STATUS: THE APPLICATION IS DEEMED TO BE WITHDRAWN

18D Application deemed to be withdrawn

Effective date: 20190402