Results 1  10
of
20
Small forwarding tables for fast routing lookups
 in ACM Sigcomm
, 1997
"... For some time, the networking community has assumed that it is impossible to do IP routing lookups in software fast enough to support gigabit speeds. IP routing lookups must �nd the routing entry with the longest matching pre�x, a task that has been thought to require hardware support at lookup freq ..."
Abstract

Cited by 212 (0 self)
 Add to MetaCart
(Show Context)
For some time, the networking community has assumed that it is impossible to do IP routing lookups in software fast enough to support gigabit speeds. IP routing lookups must �nd the routing entry with the longest matching pre�x, a task that has been thought to require hardware support at lookup frequencies of millions per second. We present a forwarding table data structure designed for quick routing lookups. Forwarding tables are small enough to �t in the cache of a conventional general purpose processor. With the table in cache, a 200 MHz Pentium Pro or a 333 MHz Alpha 21164 can perform a few million lookups per second. This means that it is feasible to do a full routing lookup for each IPpacket at gigabit speeds without special hardware. The forwarding tables are very small, a large routing table with 40,000 routing entries can be compacted to a forwarding table of 150�160 Kbytes. A lookup typically requires less than 100 instructions on an Alpha, using eight memory references accessing a total of 14 bytes. 1
Succinct Representation of Balanced Parentheses, Static Trees and Planar Graphs
, 1999
"... We consider the implementation of abstract data types for the static objects: binary tree, rooted ordered tree and balanced parenthesis expression. Our representations use an amount of space within a lower order term of the information theoretic minimum and support, in constant time, a richer set ..."
Abstract

Cited by 148 (11 self)
 Add to MetaCart
We consider the implementation of abstract data types for the static objects: binary tree, rooted ordered tree and balanced parenthesis expression. Our representations use an amount of space within a lower order term of the information theoretic minimum and support, in constant time, a richer set of navigational operations than has previously been considered in similar work. In the case of binary trees, for instance, we can move from a node to its left or right child or to the parent in constant time while retaining knowledge of the size of the subtree at which we are positioned. The approach is applied to produce succinct representation of planar graphs in which one can test adjacency in constant time.
Membership in constant time and almostminimum space
 SIAM Journal on Computing
, 1999
"... Abstract. This paper deals with the problem of storing a subset of elements from the bounded universeM = {0,...,M−1} so that membership queries can be performed efficiently. In particular, we introduce a data structure to represent a subset of N elements of M in a number of bits close to the informa ..."
Abstract

Cited by 69 (1 self)
 Add to MetaCart
Abstract. This paper deals with the problem of storing a subset of elements from the bounded universeM = {0,...,M−1} so that membership queries can be performed efficiently. In particular, we introduce a data structure to represent a subset of N elements of M in a number of bits close to the informationtheoretic minimum, B = lg
LOW REDUNDANCY IN STATIC DICTIONARIES WITH CONSTANT QUERY TIME
 SIAM J. COMPUT.
, 2001
"... A static dictionary is a data structure storing subsets of a finite universe U, answering membership queries. We show that on a unit cost RAM with word size Θ(log U), a static dictionary for nelement sets with constant worst case query time can be obtained using B +O(log log U)+o(n) (U) bits ..."
Abstract

Cited by 56 (9 self)
 Add to MetaCart
(Show Context)
A static dictionary is a data structure storing subsets of a finite universe U, answering membership queries. We show that on a unit cost RAM with word size Θ(log U), a static dictionary for nelement sets with constant worst case query time can be obtained using B +O(log log U)+o(n) (U) bits of storage, where B = ⌈log2 ⌉ is the minimum number of bits needed to represent all nn element subsets of U.
Are bitvectors optimal?
"... ... We show lower bounds that come close to our upper bounds (for a large range of n and ffl): Schemes that answer queries with just one bitprobe and error probability ffl must use \Omega ( nffl log(1=ffl) log m) bits of storage; if the error is restricted to queries not in S, then the scheme must u ..."
Abstract

Cited by 53 (7 self)
 Add to MetaCart
... We show lower bounds that come close to our upper bounds (for a large range of n and ffl): Schemes that answer queries with just one bitprobe and error probability ffl must use \Omega ( nffl log(1=ffl) log m) bits of storage; if the error is restricted to queries not in S, then the scheme must use \Omega ( n2ffl2 log(n=ffl) log m) bits of storage. We also
Compact Routing Tables for Graphs of Bounded Genus
, 2000
"... This paper deals with compact shortest path routing tables on weighted graphs with n nodes. For planar graphs we show how to construct in linear time shortest path routing tables that require 8n + o(n) bits per node, and O(log 2+ n) bitoperations per node to extract the route, for any constant > ..."
Abstract

Cited by 30 (11 self)
 Add to MetaCart
This paper deals with compact shortest path routing tables on weighted graphs with n nodes. For planar graphs we show how to construct in linear time shortest path routing tables that require 8n + o(n) bits per node, and O(log 2+ n) bitoperations per node to extract the route, for any constant > 0. We obtain the same bounds for graphs of crossingedge number bounded by o(n= log n), and we generalize for graphs of genus bounded by > 0 yielding a size of n log +O(n) bits per node. Actually we prove a sharp upper bound of 2n log k +O(n) for graphs of pagenumber k, and a lower bound of n log k o(n log k) bits. These results are obtained by the use of dominating sets, compact coding of noncrossing partitions, and kpage representation of graphs.
Low Redundancy in Static Dictionaries with O(1) Worst Case Lookup Time
 IN PROCEEDINGS OF THE 26TH INTERNATIONAL COLLOQUIUM ON AUTOMATA, LANGUAGES AND PROGRAMMING (ICALP '99
, 1999
"... A static dictionary is a data structure for storing subsets of a nite universe U , so that membership queries can be answered efficiently. We study this problem in a unit cost RAM model with word size (log jU j), and show that for nelement subsets, constant worst case query time can be obtained us ..."
Abstract

Cited by 27 (6 self)
 Add to MetaCart
A static dictionary is a data structure for storing subsets of a nite universe U , so that membership queries can be answered efficiently. We study this problem in a unit cost RAM model with word size (log jU j), and show that for nelement subsets, constant worst case query time can be obtained using B +O(log log jU j) + o(n) bits of storage, where B = dlog 2 jUj n e is the minimum number of bits needed to represent all such subsets. For jU j = n log O(1) n the dictionary supports constant time rank queries.
Low Redundancy in Dictionaries with O(1) Worst Case Lookup Time
 IN PROC. 26TH INTERNATIONAL COLLOQUIUM ON AUTOMATA, LANGUAGES AND PROGRAMMING (ICALP
, 1998
"... A static dictionary is a data structure for storing subsets of a finite universe U , so that membership queries can be answered efficiently. We study this problem in a unit cost RAM model with word size ze jU j), and show that for nelement subsets, constant worst case query time can be obtain ..."
Abstract

Cited by 18 (0 self)
 Add to MetaCart
(Show Context)
A static dictionary is a data structure for storing subsets of a finite universe U , so that membership queries can be answered efficiently. We study this problem in a unit cost RAM model with word size ze jU j), and show that for nelement subsets, constant worst case query time can be obtained using B +O(log log jU j) + o(n) bits of storage, where B = dlog jU j e is the minimum number of bits needed to represent all such subsets. The solution for dense subsets uses B + O( jU j log log jU j log jU j ) bits of storage, and supports constant time rank queries. In a dynamic setting, allowing insertions and deletions, our techniques give an O(B) bit space usage.
Error Correcting Codes, Perfect Hashing Circuits, and Deterministic Dynamic Dictionaries
, 1997
"... We consider dictionaries of size n over the finite universe U = and introduce a new technique for their implementation: error correcting codes. The use of such codes makes it possible to replace the use of strong forms of hashing, such as universal hashing, with much weaker forms, such as clus ..."
Abstract

Cited by 18 (2 self)
 Add to MetaCart
We consider dictionaries of size n over the finite universe U = and introduce a new technique for their implementation: error correcting codes. The use of such codes makes it possible to replace the use of strong forms of hashing, such as universal hashing, with much weaker forms, such as clustering. We use
Tables Should Be Sorted (on Random Access Machines)
, 1995
"... We consider the problem of storing an n element subset S of a universe of size m, so that membership queries (is x 2 S?) can be answered efficiently. The model of computation is a random access machine with the standard instruction set (direct and indirect adressing, conditional branching, addit ..."
Abstract

Cited by 16 (4 self)
 Add to MetaCart
(Show Context)
We consider the problem of storing an n element subset S of a universe of size m, so that membership queries (is x 2 S?) can be answered efficiently. The model of computation is a random access machine with the standard instruction set (direct and indirect adressing, conditional branching, addition, subtraction, and multiplication). We show that if s memory registers are used to store S, where n s m=n , then query time \Omega\Gammame/ n) is necessary in the worst case. That is, under these conditions, the solution consisting of storing S as a sorted table and doing binary search is optimal. The condition s m=n is essentially optimal; we show that if n + m=n o(1) registers may be used, query time o(log n) is possible.