HEXA: Compact Data Structures for Faster Packet Processing

Transcription

1 Washington University in St. Louis Washington University Open Sholarship All Computer Siene and Engineering Researh Computer Siene and Engineering Report Number: HEXA: Compat Data Strutures for Faster Paket Proessing Authors: Sailesh Kumar, Jonathan Turner, Patrik Crowley, and Mihael Mitzenmaher Direted graphs with edge labels are used in paket proessing algorithms for a variety of network appliations. In this paper we present a novel representation for suh graph that signifiantly redues the memory required for suh graphs. This approah alled History-based Enoding, exeution and Addressing (HEXA) hallenges the onventional assumption that graph data strutures must store pointers of log2n bits to identify suessor nodes. HEXA takes advantage of implit information to redue the information that must be stored expliitly. We demonstrate that the binary tries used for IP route lookup an be implemented using just two bytes per stored prefix (roughly half the spae required by Eatherton s tree bitmap data struture) and that string mathing an be implemented using 2-3% of the spae required by onventional data representations. Compat representations are useful, beause they allow the performane-ritial part of paket proessing algorithms to be implemented using fast, on-hip memory, eliminating the need to retrieve information from muh slower off-hip memory. This an yield both substantially higher performane and lower power utilization. While enabling a... Read omplete abstrat on page 2. Follow this and additional works at: Part of the Computer Engineering Commons, and the Computer Sienes Commons Reommended Citation Kumar, Sailesh; Turner, Jonathan; Crowley, Patrik; and Mitzenmaher, Mihael, "HEXA: Compat Data Strutures for Faster Paket Proessing" Report Number: (27). All Computer Siene and Engineering Researh. Department of Computer Siene & Engineering - Washington University in St. Louis Campus Box 45 - St. Louis, MO ph: (34)

2 HEXA: Compat Data Strutures for Faster Paket Proessing Complete Abstrat: Direted graphs with edge labels are used in paket proessing algorithms for a variety of network appliations. In this paper we present a novel representation for suh graph that signifiantly redues the memory required for suh graphs. This approah alled History-based Enoding, exeution and Addressing (HEXA) hallenges the onventional assumption that graph data strutures must store pointers of log2n bits to identify suessor nodes. HEXA takes advantage of implit information to redue the information that must be stored expliitly. We demonstrate that the binary tries used for IP route lookup an be implemented using just two bytes per stored prefix (roughly half the spae required by Eatherton s tree bitmap data struture) and that string mathing an be implemented using 2-3% of the spae required by onventional data representations. Compat representations are useful, beause they allow the performane-ritial part of paket proessing algorithms to be implemented using fast, on-hip memory, eliminating the need to retrieve information from muh slower off-hip memory. This an yield both substantially higher performane and lower power utilization. While enabling a ompat representation, HEXA does not add signifiant omplexity to the graph traversal and update, thus maintaining a high performane. This tehnial report is available at Washington University Open Sholarship:

3 Department of Computer Siene & Engineering HEXA: Compat Data Strutures for Faster Paket Proessing Authors: Sailesh Kumar, Jonathan Turner, Patrik Crowley, Mihael Mitzenmaher Corresponding Author: Abstrat: Direted graphs with edge labels are used in paket proessing algorithms for a variety of network appliations. In this paper we present a novel representation for suh graph that signifiantly redues the memory required for suh graphs. This approah alled History-based Enoding, exeution and Addressing (HEXA) hallenges the onventional assumption that graph data strutures must store pointers of log2n bits to identify suessor nodes. HEXA takes advantage of implit information to redue the information that must be stored expliitly. We demonstrate that the binary tries used for IP route lookup an be implemented using just two bytes per stored prefix (roughly half the spae required by Eatherton s tree bitmap data struture) and that string mathing an be implemented using 2-3% of the spae required by onventional data representations. Compat representations are useful, beause they allow the performane-ritial part of paket proessing algorithms to be implemented using fast, on-hip memory, eliminating the need to retrieve information from muh slower off-hip memory. This an yield both substantially higher performane and lower power utilization. While enabling a ompat representation, HEXA does not add signifiant omplexity to the graph traversal and update, thus maintaining a high performane. Type of Report: Other Department of Computer Siene & Engineering - Washington University in St. Louis Campus Box 45 - St. Louis, MO ph: (34)

4

5 HEXA: Compat Data Strutures for Faster Paket Proessing Sailesh Kumar, Jonathan Turner, Patrik Crowley Washington University Computer Siene and Engineering {sailesh, jst, Mihael Mitzenmaher Harvard University Eletrial Engineering and Computer Siene Abstrat Direted graphs with edge labels are used in paket proessing algorithms for a variety of network appliations. In this paper we present a novel representation for suh graph that signifiantly redues the memory required for suh graphs. This approah alled History-based Enoding, exeution and Addressing (HEXA) hallenges the onventional assumption that graph data strutures must store pointers of log 2 n bits to identify suessor nodes. HEXA takes advantage of implit information to redue the information that must be stored expliitly. We demonstrate that the binary tries used for IP route lookup an be implemented using just two bytes per stored prefix (roughly half the spae required by Eatherton s tree bitmap data struture) and that string mathing an be implemented using 2-3% of the spae required by onventional data representations. Compat representations are useful, beause they allow the performane-ritial part of paket proessing algorithms to be implemented using fast, on-hip memory, eliminating the need to retrieve information from muh slower off-hip memory. This an yield both substantially higher performane and lower power utilization. While enabling a ompat representation, HEXA does not add signifiant omplexity to the graph traversal and update, thus maintaining a high performane. S Index Terms ontent inspetion, IP lookup, string mathing I. INTRODUCTION everal ommon paket proessing tasks make use of direted graph data strutures in whih edge labels are used to math symbols from a finite alphabet. Examples inlude tries used in IP route lookup and string-mathing automata used to implement deep paket inspetion for virus sanning. In this paper, we develop a novel representation for suh data strutures that is signifiantly more ompat than onventional approahes. This ompatness an lead to higher performane in implementation ontexts where we have small on-hip memories with ample memory bandwidth and larger off-hip memories with more limited bandwidth. These harateristis are ommon to onventional proessors, network proessors, ASICs and FPGA implementations. We observe that the edge-labeled, direted graphs used by some paket proessing tasks have the property that for all nodes u, all paths of length k leading to u are labeled by the same string of symbols, for all values of k up to some bound. For example, tries satisfy this ondition trivially, sine for eah value of k, there is only one path of length k leading to eah node. The data struture used in the Aho-Corasik string mathing algorithm [2] also satisfies this property, even though in this ase there may be multiple paths leading to eah node. Sine the algorithms that traverse the data struture know the symbols that have been used to reah a node, we an use this history to define the storage loation of the node. By augmenting the history with some additional disriminating information, we an ensure that eah node is mapped to a distint storage loation using appropriate hashing tehniques. We find that in some appliations the amount of disriminating information needed an be remarkably small. For binary tries for example, two bits of disriminating information is suffiient. This leads to a binary trie representation that requires just two bytes per stored prefix for IP routing tables with more than K prefixes. We all the tehnique used to onstrut these ompat data representations, History-based Enoding, exeution and Addressing (HEXA). In Setion II, we introdue HEXA and apply it to binary tries. We show that the problem of seleting disriminators orresponds to finding a perfet mathing in a bipartite graph; we also show how the data struture an be inrementally modified. In Setion III, we desribe a variant of HEXA in whih the disriminator speifies the amount of history information that has to be used to identify the storage loation of a node. We then apply this tehnique to the data struture used by the Aho-Corasik string mathing algorithm as well as the bit-split version of the algorithm [6]. In Setion IV we report on the results of our evaluation of HEXA for binary tries and string mathing. Setion V overs the related work and the paper ends with onluding remarks in Setion VI. II. INTRODUCTION TO HEXA Direted graphs are ommonly used to implement various paket proessing algorithms whih are used in a variety of network appliations, some of whih are listed below: Longest prefix math IP lookup: IP routing involves a longest prefix math, where destination IP address of a paket is mathed against a large but finite set of prefixes and the longest mathing prefix determines the next hop. Tries, whih essentially are a direted graph without any yles, are often used to implement suh operations. Paket lassifiation: Paket lassifiation involves a multi-dimensional searh on paket s 5-tuple (soure/

6 2 destination addresses, ports and protool). Searh in eah dimension often onsists of a longest prefix math, whih is ommonly implemented using tries. These tries usually have a similar struture as an IP lookup trie. String mathing: Commerial network seurity devies like network intrusion detetion systems (NIDS), and appliation layer firewalls often use string based pattern mathing to identify maliious pakets. String mathing is usually performed with the aid of a finite automaton (e.g. Aho-Corasik, Wu-Manber et), whih is a direted graph with labeled edges. Nodes of these graphs usually have muh higher and varying out-degrees. Regular expression mathing: Modern seurity systems speify the patterns of interest using regular expressions. Regular expressions are also used to enable advaned network servies like ontent based routing, metering, et. Finite automata are usually used to implement regular expressions, whih are again a labeled direted graph. Complex expressions usually lead to relatively omplex graphs, as ompared to a string based automaton. There are several other appliations, whih use direted graph strutures. Some examples are a web indexing and searh engines, an aess ontrol list (ACL), or even a file system. In this paper, we will mostly fous on the first four appliations. Sine suh a wide variety of network appliations employ some form of direted graph traversal, a large body of researh literature has foused on improving its performane. For example, Srinivasan et al. propose multi-bit trie representation, where multiple nodes of a binary trie are merged into a single node. There are also shemes to ompatly enode these multibit trie nodes [3]. Another lass of direted graphs is finite automaton; in [5] authors present tehniques to improve the parsing performane of a finite automaton, whih is used to perform string mathing. It uses a similar tehnique, where multiple states of the automaton are merged into a single state and represented ompatly. In [6], authors propose an alternative tehnique to redue the spae by reduing the number of transitions from every node of the graph. While these solutions are generally speialized to their respetive appliations, a ommon theme is that memory an be redued by reduing the number of transitions and/or nodes in the graph. They show that this spae redution an also enhane parsing performane by utilizing the fast but limited on-hip memory. To the best of our knowledge, even with the above improvements, direted graphs are always implemented in the following onventional manner: eah node in the n node graph is denoted by a unique log 2 n bit identifier, whih also determines the memory loation of the node. At this memory loation, all transitions of the node (identifiers of the subsequent next nodes ) are stored, along with some auxiliary information. The auxiliary information may be a flag indiating if the node orresponds to a math in a string mathing automata or a valid prefix in an IP lookup trie, and an identifier for the string, or the next hop for the mathing prefix. The auxiliary information usually requires only a few bits and is kept one for every node; on the other hand, identifiers of the next node use log 2 n bits eah and are required one for every transition. Thus, in large graphs (say a million nodes) ontaining multiple transitions per node (say two), the memory required by the identifiers of the next node (2-bits per identifier, 2 suh identifiers per node) an be muh higher than the memory required by the auxiliary information. Another diffiulty with the onventional design is that the identifiers of the next node are read for eah symbol in the input stream, while the auxiliary information is read only upon a math. This neessitates that the identifiers be stored in a high speed memory (e.g. SRAM or embedded) in order to enable high parsing rate. For instane, a high performane lookup trie may store the set of identifiers, for every node in a fast memory along with a flag indiating whether the node orresponds to a prefix. On the other hand, the next hop information an be kept with a shadow trie, stored in a slow memory like DRAM. Similarly, in string mathing automaton, in addition to the next node identifiers, only a flag per node is needed in the fast memory, whih will indiate whether the node is a math. The prime motivation of suh separation of fast and slow path is to redue the high speed memory, whih is often expensive and less dense. The advantages are however undermined as the identifiers often represent a large fration of the total memory. While there is a general interest in reduing the total memory, learly there are inreased benefits in reduing the memory required to store these next node identifiers. In this paper, we propose a new method to store direted graph strutures that we dub HEXA (History based Enoding, exeution, and Addressing). While onventional methods use log 2 n bits to identify eah of n nodes in a graph, by taking advantage of the graph struture, HEXA employs a novel method that an use a fixed onstant number of bits per node for strutured graphs suh as tries. Thus, when HEXA based identifiers are used to denote the transitions of the graph, the fast memory needed to store these transitions an be dramatially redued. The total memory is also redued signifiantly, beause auxiliary information often represents a small fration of the total memory. The key to the identifiation mehanism used by HEXA is that when nodes are not aessed in a random ad-ho order but in an order defined by its transitions, the nodes an be identified by the way the parsing proeeds in the graph. For instane, in a trie, if we begin parsing at the root node, we an reah any given node only by a unique stream of input symbols. In general, as the parsing proeeds, we need to remember only the previous symbols needed to uniquely identify the nodes. To larify, we onsider a simple trie-based example before formalizing the ideas behind HEXA. A. Motivating Example Let us onsider a simple direted graph given by an IP

7 3 lookup trie. A set of 5 prefixes and the orresponding binary trie, ontaining 9 nodes, is shown in Figure. We onsider first the standard representation. A node stores the identifier of its left and right hild and a bit indiating if the node orresponds to a valid prefix. Sine there are 9 nodes, identifiers are 4 bits long, and a node requires total 9-bits in the fast path. The fast path trie representation is shown below, where nodes are shown as 3-tuple onsisting of the prefix flag and the left right hildren (NULL indiates no hild): 3., NULL, 7 6., NULL, NULL 9., NULL, NULL Here, we assume that the next hops assoiated with a mathing node are stored in a shadow trie whih is stored in a relatively slow memory. Note that if the next hop trie has a struture idential to the fast path trie, then the fast path trie need not ontain any additional information. One the fast path trie is traversed and the longest mathing node is found, we will read the next hop trie one, at the loation orresponding to the longest mathing node. We now onsider storing the fast path of the trie using HEXA. In HEXA, a node will be identified by the input stream over whih it will be reahed. Thus, the HEXA identifier of the nodes will be: (a) * P * P2 * P3 * P4 * P5., 2, 3 2., 4, (b) 4 P2 9 P5 4., NULL, NULL 5., 6, , 9, NULL 8., NULL, NULL These identifiers are unique. HEXA requires a hash funtion; temporarily, let us assume we have a minimal perfet hash funtion f that maps eah identifier to a unique number in [, 9]. (A minimal perfet hash funtion is also alled a one-toone funtion.) We use this hash funtion for a hash table of 9 ells; more generally, if there are n nodes in the trie, n i is the HEXA identifier of the i th node and f is a one-to-one funtion mapping n i s to [, n], Given suh a funtion, we need to store only 3 bits worth of information for eah node of trie in order to traverse it: the first bit is set if node orresponds to a valid prefix, and seond and third bits are set if node has a left and right hild. Traversal of the trie is then straightforward. We start at the first trie node, whose 3-bit tuple will be read from the array at index f(-). If the math bit is set, we will make a note of the math, and feth the next bit from the input stream to proeed to the next trie node. If the bit is () and the left (right) hild bit of the previous node was set, then we will ompute f(n i ), where n i is the urrent sequene of bits (in this 2 3 Figure : a) routing table, b) orresponding binary trie P4 P 6 P3 ase the first bit of the input stream) and read its 3 bits. We ontinue in this manner until we reah a node with no hild. The most reent node with the math bit set will orrespond to the longest mathing prefix. Continuing with the earlier trie of 9 nodes, let the mapping funtion f, has the following values for the nine HEXA identifiers listed above:. f(-) = 4 2. f() = 7 4. f() = 2 5. f() = 8 3. f() = 9 6. f() = 9. f() = 6 With this one-to-one mapping, the fast path memory array of 3-bits will be programmed as follow; we also list the orresponding next hops: Fast path,,,,,,,,,,,,,,,,,, Next hop P P2 P3 P4 P5 This array and the above mapping funtion are suffiient to parse the trie for any given stream of input symbols. This example suggests that we an dramatially redue the memory requirements to represent a trie by pratially eliminating the overheads assoiated with node identifiers. However, we require a minimal perfet hash funtion, whih is hard to devise. In fat, when the trie is frequently updated, maintaining the one-to-one mapping may beome extremely diffiult. We will explain how to enable suh one-to-one mappings with very low ost. We also ensure that our approah maintains very fast inremental updates; i.e. when nodes are added or deleted, a new one-to-one mapping an be omputed quikly and with very few hanges in the fast path array. B. Designing Effetive Mappings 7. f() = 5 8. f() = 3 We have seen that we an ompatly represent a direted trie if we have a minimal perfet hash funtion for the nodes of the graph. More generally, we might seek merely a perfet hash funtion; that is, we map eah identifier to a unique element of [, m] for some m n, mapping the n identifier into m array ells. For large n, finding perfet hash funtions beomes extremely ompute intensive and impratial. We an simplify the problem dramatially by onsidering the fat that HEXA identifier of a node an be modified without hanging its meaning and keeping it unique. For instane we an allow a node identifier to ontain few additional (say ) bits, whih we an alter at our onveniene. We all these -bits the node s disriminator. Thus, HEXA identifier of a node will be the history of labels on whih we will reah the node, plus its -bit disriminator. We use a (pseudo)-random hash funtion to map identifiers plus disriminators to possible memory loations. Having these disriminators and the ability to alter them provides us with multiple hoies of memory loations for a node. Eah node will have 2 hoies of HEXA identifiers and hene up to 2 memory loations, from whih we have to pik just one. The power of hoie in this setting has been studied and used in multiple-hoie hashing [23] and ukoo hashing [], and we use results from these analyses.

8 4 Note that when traversing the graph, when trying to aess a node we need to know its disriminator. Hene instead of storing a single bit for eah left and right hild, representing whether it exists or not, we store the disriminator if the hild exists. In pratie, we may also optionally reserve the all- - bit word to represent NULL (i.e. no hild), giving us only 2 - memory loations. For simpliity, in the following disussion, we ontinue to use all 2 memory loations for any -bit disriminator and ignore the expliit representation of NULL hild. Nevertheless, in the simulation onduted over tries, we reserve all- -bit word for NULL and use only 2 - memory loations. This problem an now be viewed as a bipartite graph mathing problem. The bipartite graph G = (V +V 2, E) onsists of the nodes of the original direted graph as the left set of verties, and the memory loations as the right set of verties. The edges onneting the left to the right orrespond to the edges determined by the random hash funtion. Sine disriminators are -bits long, eah left vertex will have up to 2 edges onneted to random right verties. We refer to G as the memory mapping graph. We need to find a perfet mathing (that is, a mathing of size n) in the memory mapping graph G, to math eah node identifier to a unique memory loation. If we require that m = n, then it suffies that is log log n + O() to ensure that a perfet mathing exists with high probability. More generally, using results from the analysis of ukoo hashing shemes [29], it follows that we an have onstant if we allow m to be slightly greater than n. For example, using 2-bit disriminators, giving 3 hoies, then m =.n guarantees that a perfet mathing exists with high probability. In fat, not only do these perfet mathings exist, but they are effiiently updatable, as we desribe in Setion II.C. Continuing with our example of the trie shown in Figure, we now seek to devise a one-to-one mapping using this method. We onsider m = n and assume that is 2, so a node an have 4 possible HEXA identifiers, whih will enable it to have up to 4 hoies of memory loations. A ompliation in omputing the hash values may arise beause the HEXA identifiers are not of equal length. We an resolve it by first appending to a HEXA identifier its length and then padding the short identifiers with zeros. Finally we append the disriminators to them. The resulting hoies of identifiers and the memory mapping graph is shown in Figure 2, where we assume that the hash funtion is simply the numerial value of the identifier modulo 9. In the same figure, we also show a perfet mathing with the mathing edges drawn in bold. With this perfet mathing, a node will require only 2-bits to be uniquely represented (as = 2). We now onsider inremental updates, and show how a oneto-one mapping in HEXA an be maintained when a node is removed and another is added to the trie. NULL pointers are required in tries. Aho-Corasik automaton does not use them, as all nodes have an outgoing transition over eah alphabet symbol. Nodes Input labels - Four hoies of HEXA identifiers,,,,,,,,,,,,,,,,,,,,,,,,,,, C. Updating a Perfet Mathing Choies of memory loations h() =, h() = 4 h() =, h() = 5 h() =, h() = 5 h() = 2, h() = 6 h() =, h() = 4 h() =, h() = 5 h() = 2, h() = 6 h() = 3, h() = 7 h() =, h() = 5 h() = 2, h() = 6 h() = 8, h() = 3 h() =, h() = 4 h() =, h() = 5 h() = 2, h() = 6 h() =, h() = 4 h() =, h() = 5 h() =, h() = 3 h() = 4, h() = 6 Bipartite graph and a perfet mathing Figure 2: Memory mapping graph, bipartite mathing. In several appliations, suh as IP lookup, fast inremental updates are ritially important. This implies that HEXA representations will be pratial for the appliations only if the one-to-one nature of the hash funtion an be maintained in the fae of insertions and deletions. Taking advantage of the hoies available from the disriminator bits, suh one-to-one mappings an be maintained easily. Indeed, results from the study of ukoo hashing immediately yield fast inremental updates. Deletions are of ourse easy; we simply remove the relevant node from the hash table (and update pointers to that node). Insertions are more diffiult; what if we wish to insert a node and its orresponding hash loations are already taken? In this ase, we need to find an augmenting path in the memory mapping graph, remapping other nodes to other loations, whih is aomplished by hanging their disriminator bits. Finding an augmenting path will allow the item to be inserted at free memory loation, and inreasing the size of the mathing in the memory mapping graph. In fat for tables sized so that a perfet mathing exists in the memory mapping graph, augmenting paths of size O(log n) exist, so that only O(log n) nodes need to be re-mapped, and these augmenting paths an be found via a breadth first searh over o(n) nodes [29]. In pratie, a random walk approah, where a node to be inserted if neessary takes the plae of one of its neighbors randomly, and this replaed node either finds an empty spot in the hash table or takes the plae of one of its other neighbors randomly, and so on, finds an augmenting path quite quikly [29]. We also note that even when m = n, so that our mathing orresponds to a minimal perfet hash funtion, using = O(log log n) disriminator bits guarantees that if we delete a node and insert a new node (so that we still have m = n), an augmenting path of length O(log n/ log log n) exists with high probability. We omit the straightforward proof. We will demonstrate in our experiments that the number of hanges needed to maintain a HEXA representation with node insertions and deletions is quite reasonable in pratie. Again, similar results an be found in the setting of ukoo hashing

9 5 a a a 2 b a a III. BOUNDED HEXA (BHEXA) Our urrent desription of HEXA is useful when graph is ayli and the total number of input symbols that we parse is bounded. However, in yli graphs, the length of HEXA identifiers may beome unbounded if we ontinue reeiving input symbols. Additionally, the presene of yles may introdue multiple sets of input symbols over whih we an reah the same node, thereby reating multiple distint HEXA identifiers, and a loss of the uniqueness property of HEXA identifiers. Suh onditions may also exist, when there are multiple inoming transitions into a node, whih are labeled with different symbols. There are instanes suh as a regular expression based finite automaton, where these onditions are ommon, there are another lass of appliations in whih all inoming transitions into a node are labeled with idential symbol. For example, in Aho-Corasik based string mathing automata, even though there are several yles, all inoming transitions at all nodes have idential labels, exept for the root node. Furthermore, a large fration of total nodes have long inoming paths labeled with idential sequenes of symbols, thus potentially reating long unique identifiers. Several variants of string mathing automata (e.g. Wu-Manber [4] and Commentz-Walter [3]), inluding the reently proposed bitsplit version of Aho-Corasik [6], whih is one of the fastest known embedded implementation, exhibit similar harateristis. For suh graphs, we introdue an extension alled bounded HEXA (bhexa) whih examines a variable but finite number of symbols in the history to identify a node, instead of examining the entire history. Sine the number of history symbols that we examine may be different for different nodes, bhexa identifiers require additional bits to indiate this length. Having variable length identifiers potentially reates multiple hoies of identifiers for nodes, whih may help in finding a mapping between identifiers and array loations and redue the dependene on disriminator bits or even avoid using them. To larify, we onsider a simple string-based example. A. Motivating Example a 7 a 8 b 9 3 Let us onsider Aho-Corasik automaton for the 3 strings: ab, ab and abba, defined over the alphabet {a, b, }. The automaton (shown in Figure 3) onsists of 9 nodes (all symbols for whih a transition is not shown in the figure are b b 4 a 5 Figure 3: Aho-Corasik automaton for the three strings ab, ab and abba. a 6 b assumed to lead to state ). A standard implementation of this automaton will use 4-bit node identifiers. These identifiers will determine the memory loation where the transitions of the node will be stored. There are three transitions per node (over symbols a, b and, respetively) and assuming that a math flag is required for every node, the fast path memory will store four entries for eah of the nine nodes, as shown below:. no, 2,, 7 2. no, 2, 3, 7 3. no, 2, 4, 6 6. math, 8,, 7 9. math, 2, 4, 6 Sine node identifiers are 4 bits, eah node requires 3 bits of fast path memory. We now explain how to use bhexa to represent this automaton. Sine bhexa allows identifiers to ontain variable number of input symbols from the history, our first objetive is to identify the legitimate bhexa identifiers for the nodes. Clearly, we would like to keep the identifier unique for eah node, irrespetive of the path that leads to the node. The identifier of the root node is, as it is visited without reeiving any input symbol (zero path length). The identifiers of the nodes whih are one transition away from the root may ontain up to one symbol from the history beause all single transition path that will lead to suh nodes will be labeled with idential symbol. As an example, all inoming edges into node 2 are labeled with a; thus its identifier an either be or a. Similarly, the identifier of node 7 an be or. In general, a node whih is k transitions away from the root may have the bhexa identifier of any length up to k symbols. For example, both paths a 2 b 3 and b a b leads to the node 3, and the last two symbols in these paths are idential; onsequently, its bhexa identifier an either be or b or ab. Choies of bhexa identifiers for the remaining nodes are listed below:. 4., b, bb, abb 7., 2., a 5., a, ba, bba, abba 8., a, a 3., b, ab 6.,, b, ab 9., b, ab, ab Notie that eah of the above bhexa identifier is legitimate. However, we must ensure that, the ones we hoose are unique, so that no two nodes end up with idential identifiers. If we employ -bit disriminators with bhexa identifiers then we may allow up to 2 nodes pik idential identifiers and then use different disriminator values to make them unique. The memory mapping method that we present in the next setion enfores these onstraints and ensures that bhexa identifier of eah node is unique. Notie again that, a -bit disriminator will only provide 2 loations when NULL has to be represented expliitly with an all- -bit word. B. Memory Mapping 4. no, 5,, 7 5. math, 2, 3, 7 7. no, 8,, 7 8. no, 2, 9, 7 The next step is to selet a bhexa identifier for every node, suh that they are mapped to unique memory loations. A large fration of nodes, being away from the root node, will have several hoies of bhexa identifiers of different lengths, whih will improve the probability of a one-to-one mapping. These hoies however ome at a ost; if a node an have up to k symbols long bhexa identifier giving it k hoies and

10 6 it selets the longest identifier, then up to log 2 k bits will be needed to indiate its length. During the graph traversal, these bits are required to determine the exat number of history symbols that forms the bhexa identifier of the node. In our example automaton, if node 5 selets abba as its bhexa identifier then 3-bits will be needed to indiate its length. We an however omit this identifier from the set of legitimate identifiers of node 5, thereby keeping the bhexa identifiers within 4 symbols and requiring only 2-bits. For ompleteness, we also keep -bit disriminators ( may be zero, if we do not need them). Notie that instead of storing the omplete bhexa identifier, only + log 2 k bits worth of information is required to be stored; this information along with the history of input symbols are suffiient to re-generate the omplete bhexa identifier of any given node. Continuing with our example, we onstrut a memory mapping graph (as desribed in Setion II.B), whih is shown in Figure 4. In the graph we use m=, thus an extra memory ell is available for the nine nodes. We also limit the bhexa identifiers ontain up to three history symbols and do not use disriminators. The edges of the graph are determined by the hash funtion h, whih is: k h = ( = s ) mod i i i ; for the bhexa identifier s s k In this formula, the input symbols are assumed to take these numerial values: =, a=, b=2, =3. In the same figure, a maximum mathing in the memory mapping graph is highlighted, whih assigns a unique memory loation to eah node of the automaton. Aording to this mathing, the bhexa identifiers of the nodes are hosen as: Nodes bhexa a ab bb bba b a b length Notie again that we only store the length of bhexa identifiers in the memory (and disriminators, if they are used). During the graph traversal, the length and the history of input symbols are suffiient to reonstrut the omplete bhexa identifier. Sine the length an be enoded with 2-bits in this ase and there are no disriminators, the fast path will require total 7 bits per node: a math flag and 2-bits eah to indiate the length of the bhexa identifiers of the three next nodes for the symbols a, b and, respetively. The resulting programming of the fast path memory is shown below: Mem. loation node math flag a b Compared to a standard implementation (3-bits per node), Nodes Choies of bhexa identifiers, a, a, ab, b, bb, abb, a, ba, bba,, b, ab,, a, a, b, ab, ab h( ) = h( ) = h(a) = bhexa uses about half memory (7-bits per node). There may however be irumstanes when a perfet mathing does not exist in the memory mapping graph. There are two possible solutions to resolve this problem. The first solution is upward expansion, in whih additional memory ells are alloated; eah new ell improves the likelihood of a larger mathing. The seond solution is sideways expansion, in whih an extra bit is added, either to the disriminator of the bhexa identifier or to its length, whihever leads to larger mathing. Notie that eah suh extra bit doubles the number of edges in the memory mapping graph, whih is likely to produe signifiantly larger mathing. Unfortunately, sideways expansion also inreases the memory rapidly. For example, if the urrent bhexa identifiers require 3-bits, then a single bit of sideways expansion will inrease the total memory by 33%. A memory effiient way of finding mapping between nodes and memory loations should iterate between two phases. In the first phase, upward expansion will be applied until the added memory exeeds the memory needed by a single bit of sideways expansion. If all nodes are not yet mapped then the seond phase will begin, whih will reset the previous upward expansion and perform a bit of sideways expansion. If some nodes are still not mapped then the first phase is repeated (without resetting the sideways expansion). This method is expeted to find map the nodes while also minimizing the memory. In real bhexa implementations, however, some new hallenges may also arise, whih we disuss in the oming setion. C. Pratial Considerations Choies of memory loations h( ) = h(a) = h(ab) = 5 h( ) = h(b) = 2 h(bb) = 6 h(abb) = h( ) = h(a) = h(ba) = 4 h(bba) = 9 h( ) = h() = 3 h(b) = 8 h(ab) = 4 h( ) = h() = 3 h( ) = h(a) = h(a) = 4 h( ) = h(b) = 2 h(ab) = 5 h(ab) = 9 Bipartite graph and a maximum mathing Figure 4: Memory mapping graph, bipartite mathing. The hallenges that may appear during the implementation of bhexa are likely to depend primarily on the harateristis of the direted graph. The first hallenge may arise when the direted graph ontains long paths, all of whose edges have idential labels. Consider the Aho-Corasik automaton for l haraters long string suh as aaaaa There will be l+ nodes in the automaton and the legitimate bhexa identifier for the i th node will be any suh string (aaa ) of length less than i. In this ase, if we attempt to map every node to a memory loation without employing any disriminator then the

11 7 Number of HEXA identifier hoies no memory over-provisioning % memory over-provisioning 3% memory over-provisioning % memory over-provisioning.e+2.e+3.e+4.e+5.e+6 Number of nodes in the trie Figure 4: For different memory over-provisioning values and trie sizes, the number of hoies of HEXA identifier that is needed to suessfully perform the memory mapping bhexa identifier of any i th node will be i haraters long. Sine there are l+ nodes, the longest bhexa identifier will ontain l symbols and log 2 l bits will be required to store its length. If we employ disriminator bits then the longest bhexa identifiers an be redued by a fator of 2, nevertheless the total number of bits that will be stored per bhexa identifier will remain the same. Clearly, large l will undermine the memory savings ahieved by using bhexa. While suh strings are not ommon, we would still like to deouple the performane of bhexa from the harateristis of the strings sets. One way to takle the problem is to allow the length bits to indiate superlinear inrements in bhexa identifier length. For instane, if there are three length bits available then they may be enabled to represent the bhexa lengths of,, 2, 3, 5, 7, 2, and 6, thereby overing a muh larger range of bhexa lengths. Of ourse, the exat values that the length bits will represent will depend upon the strings database. Seond way to takle the problem is to employ a small on-hip CAM to store those nodes of the automaton that ould not be mapped to a unique memory loation due to the limited number of length and disriminator bits. In our previous example, if l is 9, and the bhexa lengths are represented with 3-bits, then at least 2 nodes of the automaton an not be mapped to any unique memory loation. These nodes an be stored in the CAM and an be quikly looked at during the parsing. We refer to the fration of total nodes that an not be mapped to unique memory loation as the spill fration. In our experiments, we find that for real world string sets, the spill frations remains low, hene a small CAM will suffie. IV. EXPERIMENTAL EVALUATION We have performed a thorough experimental evaluation of the HEXA and bhexa representations. First, we onsider HEXA based representation of real world IP lookup tries. The results demonstrate that, HEXA an dramatially redue the memory required by a binary trie; at the same time it an also redue the memory in more sophistiated trie implementations Memory over-provisioning.5..5.e+2.e+3.e+4.e+5.e+6 like multi-bit trie and tree bit-map. Seond, we employ HEXA to implement the finite automata, whih are used to perform string mathing operations. We onsider two flavors of high performane string mather, the lassi Aho-Corasik automaton, and the reently proposed bit-split version. We show that, in both ases, HEXA redues memory by up to five times without sarifiing the parsing performane. A. Results on Tries Number of nodes in the trie 3 HEXA hoies 4 HEXA hoies 7 HEXA hoies Figure 5: For different number of hoies of HEXA identifiers and trie sizes, the memory over-provisioning that is needed to suessfully perform the memory mapping BGP tables have grown steadily over the past two deades from less than 5 entries in the early 99s to nearly 75, entries in 2 to 35, entries today, and the growth is expeted to ontinue in the near future. Binary tries are a standard method to implement these BGP tables and enable fast lookup. High performane implementations of these lookup tries onsider multiple input bits at a time, thereby reating multi-bit nodes. The multi-bit nodes an be represented ompatly by using tree bit-map tatis. In our experiments, we have employed HEXA to implement both binary trie as well as multi-bit trie. Unless otherwise speified, the reported results are based on the prefixes in more than fifty BGP tables obtained from [9]. ) Binary Tries In Figure 4, for varying trie sizes, we plot the number of hoies of HEXA identifiers that are needed to ensure that a perfet mathing exists in the memory mapping graph with more than 9% probability. As expeted, more hoies of HEXA identifiers or inreased memory over-provisioning ((m n)/m) improves the hanes of a perfet mathing. In ompliane with the theoretial analysis, for m=n, the required number of HEXA identifier hoies remains O(log n). However, when m is slightly greater than n (results for, 3 and % are reported here), the required number of hoies beomes onstant, independent of the trie size. Reall that the number of HEXA identifier hoies determines the number of disriminator bits that are needed for a node, thus a small memory over-provisioning is desirable in order to keep the disriminators onstant in size. From a pratial point, we would like to keep the number of

12 8 Fast path trie memory (MB) without HEXA with HEXA Stride Figure 6: Memory needed to represent the fast path portion of the trie with and without HEXA. 32 tries are used, eah ontaining between -2k prefixes. hoies of HEXA identifiers a power of two minus one, so that one disriminator value will be used to indiate a null hild node and all remaining permutations of disriminator values will be used in finding better mathing. Thus, we are interested in suh number of HEXA hoies as, 3, 7, et. Therefore, we fix the number of HEXA hoies at these values, and plot the memory over-provisioning needed to suessfully perform a memory mapping (Figure 5). It is lear that that for 3 HEXA identifier hoies, the required memory over-provisioning is %. Thus, 2.2 bits are enough to represent eah node identifier. 2) Multi-bit tries We now extend our evaluation of HEXA to multi-bit tries where tree bit-maps are used to represent the multi-bit nodes. Notie that when HEXA is used for suh tries, the bit-masks used for the tree bitmap nodes are not affeted; only the pointers to the hild nodes are replaed with the hild s disriminator. The first design issue in suh tries is to determine a stride whih will minimize the total memory. We aomplish this experimentally by applying different strides to our datasets and measuring the total fast path memory. The results are reported in Figure 6. Clearly, strides of 3, 4 and 5 are the most appropriate hoies, when HEXA is not used. When HEXA is employed, large strides no longer remain effetive in reduing the memory. This happens beause a unibit HEXA trie requires just 2-bits of disriminator to represent a node, thus there is little room for further memory redutions by representing a subset of nodes with a bitmap. In fat, with inreasing stride, the bitmaps grow exponentially and quikly surpass any memory savings ahieved with the tree bitmap based multi-bit nodes. Note that smaller strides may not be aeptable in off-hip memory based implementations. However, in an embedded implementation suh as pipelined trie [26], small stride may enable higher throughput, as reported in [27]. This happens beause with small stride, one an employ muh deeper pipelines and eah pipeline stage an be kept ompat and fast. In our tehnial report version [28], we report the paket throughput, and power and die area estimates of HEXA based representations. We find that HEXA results in high paket throughput while dissipating muh lower power ompared to the state-of-the art methods. 3) Inremental Updates We now present the results of inremental updates on tries represented with HEXA. In our experiments, we remove a node and add another to a HEXA trie, and then attempt to find a mapping for the newly added node. The general objetive of triggering minimum hanges in the existing mapping is ahieved by finding the shortest augmenting path in the memory mapping graph, between the newly added node and some free memory loation (as desribed in Setion II.C). We find that the shortest augmenting path indeed remains small, thus a small number of existing nodes are remapped. In Figure 7, we plot the probability distribution of the number of nodes that are remapped during an update. It is lear that no update is likely to take more than 9 memory operations and a large majority of updates require less than ten memory operations. Thus, update operations in a HEXA trie an be arried out quikly, irrespetive of the trie shape and update patterns. B. Results on Strings In this setion, we report the results obtained from the experiments in whih we use bhexa to implement string based pattern mathers. We have obtained the string sets from a olletion of soures: peptide protein signatures [25], Bro signatures [2], and string omponents of the Ciso seurity Probability. Probability # of memory operations per update # of memory operations per update Figure 7: PDF of the number of memory operations required to perform a single trie update. Left trie size =, nodes, Right trie size =, nodes.

13 9 Spill fration bhexa length=4, no disriminator bhexa length=8, no disriminator bhexa length=4; -bit disriminator Spill fration.3.2. Bro (bhexa length=8, no disriminator) Protein (bhexa length=8; -bit disriminator) Ciso622 (bhexa length=8, -bit disriminator) Ciso62 (bhexa length=8, -bit disriminator) Spill fration Random (bhexa length=8, 3-bit disriminator) Protein (bhexa length=8; 3-bit disriminator) Bro (bhexa length=8, 2-bit disriminator) Ciso62 (bhexa length=6, 2-bit disriminator) Memory over-provisioning Memory over-provisioning Memory over-provisioning Figure 8: Plotting spill fration: a) Aho-Coroasik automaton for random strings sets, b) Aho-Coroasik automaton for real world string sets, and ) random and real world strings with bit-split version of Aho-Corasik. signatures [2]. We have also used randomly generated signatures whose lengths were kept omparable to the real world seurity signatures. These strings were implemented with Aho-Corasik automaton; in most experiments we did not use failure pointers as they redue the throughput. Without failure pointers, an automaton has 256 outgoing transitions per node, and may require large amounts of memory. In order to ope up with suh high fan-out issue, we have onsidered the reently proposed bit-split version of Aho-Corasik, wherein multiple state mahines are used, eah handling a subset of the 8-bits in eah input symbol. For example, one an use eight binary state mahines, with eah mahine looking at a single bit of the 8-bit input symbols, thereby reduing the total number of per node transitions to 6. First, we report the results on randomly generated sets of strings onsisting of a total ASCII haraters. In Figure 8(a), we plot the spill fration (number of automaton nodes that ould not be mapped to a memory loation) as we vary the memory over-provisioning. It is lear from the plot that it is diffiult to ahieve zero spill without using disriminators. With a single bit of disriminator and less than % memory over-provisioning, spill fration beomes zero, even when the bhexa lengths are limited to 4. Thus, total 3-bits are needed in this ase, to identify any given node: one for its disriminator and two to indiate the length of its bhexa identifier. This represents more than five fold redution in the memory when ompared to a standard implementation, whih will require 6-bits to represent a node. Next we report similar results for real world string sets. In Figure 8(b), we plot the spill fration for the set of protein strings, and the strings extrated from the Bro signatures, and Ciso seurity signatures. We only report results of those bhexa onfigurations (number of disriminator bits and maximum bhexa length) that keep the spill fration at an aeptably low value. For the Bro strings, about % memory over-provisioning is needed in order to keep the spill fration below.2%. The spill level orresponds to nodes whih remain unmapped in the automaton onsisting of total 5853 nodes. The bhexa onfiguration in this ase does not use any disriminator and limits the length to 8, thus total of 3-bits are needed to identify any given node. For the protein patterns, again a % memory over-provisioning is needed in a onfiguration that uses -bit disriminator and up to 8 haraters long bhexa identifiers. Thus, in this ase, 4-bits are needed to represent a node. In the Ciso string set ontaining total 622 strings, there was one string that onsisted of \x4 ASCII symbol repeated 5 times, whih reates up to 5 states with idential bhexa identifiers. This is preisely the issue that we have desribed in Setion III.C. With restrited bheha length and limited disriminator bits, it is impossible to uniquely identify eah of the resulting 5 nodes. Consequently, in a onfiguration where we employ 4-bits per bhexa identifier, 35 nodes remain unmapped even if we arbitrarily inrease the memory overprovisioning (refer to third set of vertial olumns in Figure 8(b)). As we remove this string from the database, we were able to redue the spill fration to.% with no memory overprovisioning and for an idential bhexa onfiguration (last set of vertial olumns in Figure 8(b)). These results suggest that bhexa based representations redues the memory by between 3 to 5 times, when ompared to standard representations. In our final set of experiments, we attempted to represent bit-split Aho-Corasik automaton with bhexa. We have employed four state-mahines, eah handling two bits of the 8-bit input harater. To our surprise, we found that bit-split versions were more diffiult to map to the memory, and requires longer disriminators and bhexa identifiers, whih inreases the number of bits per node. In spite of employing the tehniques we have disussed in setion III.C (e.g. using superlinear inrease in the bhexa length), we generally require 5 bits to represent eah node of a bit-split automaton. This represents approximately 2-3 fold redution in memory as ompared to a standard implementation. The results are plotted in Figure 8(). To summarize, bhexa based representations ahieve between 2-5 fold redutions in the memory. Suh redutions will not only aid in reduing the on-hip memory but also yield higher throughput at lower power dissipation levels. The omplete set of these results an be found in the tehnial report version of the paper [28]. V. RELATED WORK Tries have been studied extensively as a means to implement longest prefix math funtions. To redue memory usage of a trie, leaf pushing has been proposed in [], wherein prefixes at non-leaf nodes are pushed down to the leaves. Thus, eah node stores either a prefix pointer or a pointer to the array of hildren. However, leaf-pushed nodes