Análisis de Contenido
5. Resumen del artículo
In this chapter, we discuss how to use our hash-based algorithmic tools with the CA-RAM memory architecture to solve the packet classification problem. Because of the fact that some packet classification rules have all wildcard bits in one or two of the source or the destination prefixes fields, we will not be able to apply the restricted hashing scheme to the PC application. Instead, we consider both the grouped hashing and its extension the progressive hashing scheme. As we mentioned in Section1, for the PC application, we use a special type of hashing that is called Tuple Space Search (TSS).
The original TSS is a 2D space where one dimension represents the source prefix length and the second dimension is the destination prefix length as shown in Figure 2-b. Each dimension starts from 0 and runs till 32, which is the maximum length of the IPv4 address. Thus, the TSS has 33 × 33 = 1089 cells, where each cell originally is an independent hash table that is augmented with special data structures that are called “markers and precom- putations” [47]. Note that our TSS is different from the original TSS in that we store all the rules inside one big hash table, CA-RAM, but we use the same notion of splitting rules into a 2D space, then use hashing.
The markers and precomputations of the original TSS scheme are tools to find the best matching rule out of multiple rules. Each cell has a “marker” that points to the next cell where the best matching rule may exist in case no match is found at the present cell. In addition, a cell has a “pre-computed” cell address marking the next best cell to search for a match, in case a match is found at the current cell. The main problem with the original TSS scheme is that many of the hash tables are empty [54, 45]. In addition, finding the optimal (best or most cost efficient) matching rule presents a problem, since we may have to search the entire TSS to find it. In other words, the original TSS has a high average memory
access time that is not practical (i.e., searching 1089 hash tables). This problem has been tackled by the introduction of markers and precomputations [32], which represent extra-high preprocessing overhead [45].
One solution to the original TSS is to group multiple cells into a single cell, or in other words, to merge multiple hash tables into one hash table, called “coarse-grained TSS” [45]. This solution eliminates the TSS problem by augmenting the 2D TSS into multiple seg- ments and merging all the hash tables in each segment (partition) into a single hash table. However, coarse-grained TSS still suffers from the overhead of computing the markers and precomputations, in addition to space fragmentation due to the use of multiple hash tables. We introduce three different hash-based TSS solutions in this chapter. The three solu- tions are based on our version of the coarse-grained TSS optimization and the progressive hashing. We either use a single CA-RAM (hash table) or two CA-RAMs to store our ver- sion of the TSS. Moreover, we avoid using markers and precomputations via applying our I-Mark scheme [20,21]. We note that the I-mark overhead computation algorithm is O(N2), where N is the number of filters, while each of the markers and the precomputations require O(Wd), where W is the number of bits in one dimension of the TSS and d is the number of dimensions where 2 ≤ d ≤ 5.
We start in Section 6.1, where we discuss in general the special hardware requirements for utilizing our CA-RAM as a packet classification engine. In Section 6.2, we show our first scheme, which uses the progressive hashing in addition to the I-Mark. It also serves as a baseline for our subsequent schemes as it simply adds all the PC rules into a single hash table (CA-RAM). Section 6.3 is our second PC solution, where instead of using the same coarse-grained 2D TSS we use a dynamic partitioning scheme to split the TSS. Our main goals in this solution are to: enhance the space utilization, reduce the average memory lookup time, and hence, reduce use of power. Then, in Section 6.4, we show our two CA- RAMs PC solution, where we use the fact that some PC databases have non-unique pairs of source and destination prefixes of their rules. We use one CA-RAM to store the source and destination prefixes of the PC rules; while the second CA-RAM is used to store the rest of the rules. Finally, in Section 6.5, we discuss the simulation results and the performance estimation of our three PC CA-RAM-based solutions.
RAM
RAM
Hash Hash Function Function h(.) h(.) IP Packet Header IP Packet Header…
…
One Filter One Filter SP/SP/lenlenDP/lenDP/lenSPortSPortDPortDPortProtProtRIDRIDPriPri AFAF Row Buffer
MP MP MPMP MPMP MPMP MPMP Priority Encoder Priority Encoder … … SP/
SP/lenlenDP/DP/lenlenSPortSPortDPortDPortProtProtRIDRIDPriPri Row Buffer
Prefix MatchPrefix
Match Range MatchRange Match MatchMatchExact Exact
RID RID Final Result Final Result Pri Pri AF AF To NP To NP
Figure 20: The CA-RAM detailed architecture for the packet classification application.
6.1 THE CA-RAM ARCHITECTURE FOR PACKET CLASSIFICATION