Method and apparatus for finding a perfect hash function and making minimal hash table for a given set of keys
Download PDFInfo
 Publication number
 US20060248079A1 US20060248079A1 US11116648 US11664805A US2006248079A1 US 20060248079 A1 US20060248079 A1 US 20060248079A1 US 11116648 US11116648 US 11116648 US 11664805 A US11664805 A US 11664805A US 2006248079 A1 US2006248079 A1 US 2006248079A1
 Authority
 US
 Grant status
 Application
 Patent type
 Prior art keywords
 set
 hash
 keys
 function
 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.)
 Abandoned
Links
Images
Classifications

 G—PHYSICS
 G06—COMPUTING; CALCULATING; COUNTING
 G06F—ELECTRICAL DIGITAL DATA PROCESSING
 G06F17/00—Digital computing or data processing equipment or methods, specially adapted for specific functions
 G06F17/30—Information retrieval; Database structures therefor ; File system structures therefor
 G06F17/30943—Information retrieval; Database structures therefor ; File system structures therefor details of database functions independent of the retrieved data type
 G06F17/30946—Information retrieval; Database structures therefor ; File system structures therefor details of database functions independent of the retrieved data type indexing structures
 G06F17/30949—Information retrieval; Database structures therefor ; File system structures therefor details of database functions independent of the retrieved data type indexing structures hash tables
Abstract
Description
 [0001]The subject matter of this patent application is closely related to the subject matter of patent application U.S. Ser. No. xx/xxx,xxx, Compressed representations of tries, which has the same inventor and assignee as the present patent application and is being filed on even date with this application. U.S. Ser. No. xx/xxx,xxx is further incorporated by reference into this patent application for all purposes.
 [0002]1. Field of the Invention
 [0003]The present invention relates generally to computer systems, and more specifically to techniques for locating data through the use of a hash function.
 [0004]2. Description of Related Art
 [0005]In computer systems there is a constant effort to reduce the amount of storage and time required to locate data. This is especially true with devices such as routers and switches that route Internet Protocol (IP) messages in a network. Such devices have a limited amount of memory and must route messages as rapidly as possible.
 [0006]
FIG. 1 shows a prior art means of looking up data associated with an IP address. An IP address is a 32 bit datum. It is normally expressed in eight bit quantities called octets where each 8 bits of the 32 bits is separated by “.”. Each octet has a range of 0 to 255. The expression of addresses can be seen in the column marked ADDRESS in the table 103. If the first octet of the IP address is used as a key to look up data, the simplest means of finding the associated data is to store it in an array of 256 elements using the first octet of the address as an index into the array. This method is simple and fast, but it is not minimal in that the array of 256 elements is sparsely populated, with only 7 elements occupied by data.  [0007]To reduce the amount of memory required to store the seven elements of the table, a technique called hashing is used. Hashing is implemented using a hash function. The hash function is passed a string of bits commonly referred to as a key and returns a hash value that is associated with the key. The hash value is typically used as an index into a hash table, a hash table being an array of data elements of a known size. The array element referenced by the hash value contains the data associated with the key. In the Internet switching context, the data is typically a pointer to routing information that is associated with the key.
 [0008]The input and output of a hash function can be expressed as hash_value=ƒ(s), where s is the key. The form of a hash function is implementation dependent, but a typical hash function is ƒ(s)=s mod p. The modulus is used because it returns the remainder of s divided by p and therefore allows an array of p elements to be used as the hash table.
FIG. 1 shows at 101 a prior art technique for hashing a set of keys. Technique 101 transforms a set of IP addresses 103 using a hash function and a hash table. The top octet of the IP address is used as a key. The key has a range of values of 0 to 255. Hash function 105 is said to be perfect for a set S of octets if the value of p used in the hash function has been chosen such that none of the keys produce the same hash value when applied to s mod p. If two of the keys produce the same hash value, a collision occurs. In order to prevent a collision from occurring, it is necessary to have a hash function 105 that indexes into a hash table 107 where no collisions occur. Value p in hash function 105 also defines the size of hash table 107. The obvious shortcoming of this is method is that the hash table is sparsely populated. (i.e. the table is not minimal in that there are not an equal number of elements and keys) There is more space wasted in the hash table 107 than used. The sparseness of hash table 107 could be even greater if the modulus required to produce a perfect hash in function 105 were greater than 16.  [0009]An alternate priorart technique for hashing a set of keys which allows for smaller initial memory allocation is hash chaining.
FIG. 2 illustrates an implementation of this technique at 201. A hash table of this type has as its base component a structure that allows the storage of a key, data, and pointer to the next entry in the chain. The following C structure defines a possible implementation of such a structure:struct hash_element { int key; char data[256]; struct hash_element *next; };  [0010]To implement a hash table a programmer initially allocates an array of n elements, where n is a prime number chosen for its value in proximity to the number of elements that need be stored in the table. Hashing technique 201 has array 203 containing seven elements. Data corresponding to the set of keys S 225 is inserted into array 203 using the hash values produced by hash function 227 from the keys as indexes into array 203. Inserting the data corresponding to the first three keys 0,6, and 2 of set S 225 using the results of the hash function 225 inserts the data in elements 205, 213, and 209 respectively of array 203. At this point the hash function is perfect, as no collisions have been encountered. Insertion of the data corresponding to the fourth key of the set S 227 causes a collision, as the result of the hash function for the value 9 will return a hash value of 2. There already exists data with an index of 2, the element 209. An additional hash_element is allocated with the data and the key 9 being stored in the new element 211. The element 209 is updated to also include the address of element 211 as the next element in the chain. Insertion of the data with the key of 19 causes the key and data to be stored at element 5 of array 215. Inserting data with a key of 12 causes hash function 225 to return an index of 5. An additional hash_element is allocated with the data and the key 9 being stored in new element 217. Element 215 is updated to also include the address of element 217 as the next element in the chain. Inserting data with a key of 5 causes an additional hash element to be allocated 219 with the key and data being stored in the element. Element 217 is updated with the address of element 219 as the next element in the chain.
 [0011]As is evident from table 203, using a hash function to determine the location of data results in varying numbers of memory accesses to fetch the data associated with the key. Data elements at 205, 209, 215, and 213 can each be accessed with a single memory reference, while the data elements at 211 and 217 each can be accessed with two memory references. Accessing data element 219 requires three memory references. The more memory references, the more time it takes to access data associated with a key. In addition to the differences in time required to reference data elements, table 203 is memory inefficient. Original array 203 contained seven elements, which equals the number of elements that needed to be stored in the table. Three additional elements were allocated in discrete memory locations while locations in the original array 207, 221, and 223 remained empty. Additionally, the key and pointer must be stored with the data to allow collisions to be resolved. Hash function of 201 can be said to trade off time for space, whereas the hash function 101 trades space for time.
 [0012]What is needed to overcome the foregoing problems of hash table sparseness and inequality of time to reference data is a method of finding a perfect hash for a given set of keys and storing the data corresponding to the set of keys in a minimal hash table. It is an object of the present invention to provide such a technique. Other objects and advantages will be apparent to those skilled in the arts to which the invention pertains upon perusal of the following Detailed Description and drawing, wherein:
 [0013]
FIG. 1 shows a prior art hash function, set of keys, and hash table.  [0014]
FIG. 2 shows a prior art chain method hash table populated with a set of keys.  [0015]
FIG. 3 shows a representation of a perfect hash function and the hashed values produced by applying the perfect hash function to a set of keys and how the representation may be used to obtain addresses of data corresponding to the keys.  [0016]
FIG. 4 shows a block of code for finding a perfect hash function for a set of keys.  [0017]
FIG. 5 shows a block of code for producing the representation of the perfect hash function and the hashed values.  [0018]
FIG. 6 shows a block of code that uses the representation of the perfect hash function and the hashed values to produce an address of the data corresponding to a given key.  [0019]
FIG. 7 shows a flow chart of the logic required to find a perfect hash function for a set of keys.  [0020]Reference numbers in the drawing have three or more digits: the two righthand digits are reference numbers in the drawing indicated by the remaining digits. Thus, an item with the reference number 203 first appears as item 203 in
FIG. 2 .  [0021]The first part of the present invention is a technique for finding a perfect minimal hash function for a given small set of keys. The second part is a technique for making and using a bitmap representation of the perfect hash function.
 [0000]Finding a Perfect Hash Function
 [0000]The Mathematics of Finding a Perfect Hash Function
 [0022]In the area of Internet Protocol Routing it is often observed that a small set of keys will have values belonging to a large range of values. When this is the case, the keys are said to sparsely populate the range of values. The set of IP addresses 103 illustrates a small set of seven keys with a range of 256 possible values. Often such a set will contain only contain 46 keys. For the moment it is assumed that the set has only two keys, S={s_{1}, s_{2}}. Then given the function h_{p}(s)=s mod p where p is a prime number pε{1,2,3,5,7,11,13, . . . ,} a collision occurs whenever h_{p}(s_{1})=h_{p}(s_{2}). If p=2, both s_{1 }and s_{2}s are even, then h_{2}(s_{1})=h_{2}(s_{2})=0 and the keys collide. If both keys are odd, then h_{2}(s_{1})=h_{2}(s_{2})=1 and they still collide. So it can be quickly determined whether for a given two keys a hash function is perfect.
 [0023]If the set of keys is increased, a perfect hash may be found for the set of keys by using the Chinese remainder theorem. The Chinese remainder theorem states that is possible given the remainders an integer gets when it's divided by an arbitrary set of divisors to uniquely determine the integer's remainder when it is divided by the least common multiple of those divisors. Using the theorem it possible to show that the smallest value of the set of keys is h_{p}(s_{1})=h_{p}(s_{2}) for all possible values of p. Where
p=2 h _{2}(s _{1})=h _{2}(s _{2}) forces s _{2}=2a _{2} +s _{1 }
p=3 s _{2}=3a _{3} +s _{1 }
p=5 s _{2}=5a _{5} +s _{1 }
. . .
a_{2 }is an integer greater than zero. In order for p=5, p=3 and p=2 cases to be true, then s_{2}=5*2*3*a_{2}+s_{1 }or the minimum 5*2*3+s_{1}.  [0024]An object of the invention is to find a set of values of p for a given set of keys such that at least one of the hash functions s mod p is perfect. To find such a set of values of p, a set of coprime numbers is used rather than prime numbers. A set of numbers are coprime if they do not share a common set of factors. A set of coprime factors less than 32 is:
pεP={31,29,28,27,25,23,19,17,13,11}.
This means that for any key s_{1 }the next largest key that collides with it for every h_{p}(s)=s mod p is s_{2}=31*29*28*27*25*23*19*17*13*11+s_{1}=18,050,444,111,700. The set of P is chosen as an example, the actual set is an implementation detail.  [0025]Where h_{p}(s)=s mod p where p is a coprime number pεP={31,29,28,27,25,23,19,17,13,11} and there are only two keys, as long as the keys are less than 18,050,444,111,700 (less than 44 bits), then there exists a hash function that is perfect for some pεP. This means that for keys less than 48 bits as in internet bridging, it is 1,099,511,627,776:1 odds that a perfect hash function exists where pεP. Because an initial hash has presorted the keys, the odds of not finding a value of p which yields a perfect hash function for the keys are extremely low.
 [0026]If there are three keys, then the p=2 condition is:
p=2 h _{2}(s _{1})=h _{2}(s _{2}) or h _{2}(s _{1})=h _{2}(s _{3}) or h _{2}(s _{3})=h _{2}(s _{2})
forces s_{i}=2a_{2}+s_{j }where a_{2 }some integer greater than zero for some s_{i}, s_{j }i≠j. Thus if there are N keys, one key doesn't need to be the product of the members of P. The product of some of the members of the set P make up part of the value of each key. Thus if there were three keys, and the smallest was s_{1}, s_{2 }could be 11*13*17*19*23+s_{1}, and s_{3 }could be 25*27*28*29*31+s_{1}. Thus the size of the first key that prevents the family of hash functions from being perfect drops very quickly as the number of keys N increases. This means the statistical likelihood of having two keys that collide increases with N.  [0027]Whenever a failure to find a hash occurs, the initial hash function can be recomputed to use the next set of coprime numbers available. An alternative, is to create another level of hashing, with keys that result in collisions when applied to a first hash function being then applied to a slightly different hash function. If a collision occurs that cannot be resolved at the first level, the number of keys at the second level will be reduced, making it easier to find a perfect hash function at the second level. Modifying the hash function to be h(x)=(c*x) mod p where c is a large prime number reduces the odds of failure to zero.
 [0028]An alternative method of resolving collisions is to create an additional hash table chained from the first that employs a hash function that is perfect for the keys the collide in the first hash table. Statistically, whether the first hash is likely to succeed is based on the amount of memory allocated. The remaining collisions have odds of failing around 18,050,444,111,700 to 1. In a third hash, the odds of a collision are over 18,050,444,111,700^{2 }to 1. For a fourth hash the odds of a collision is 18,050,444,111,700^{4 }to 1. There are not enough possible keys to need more than a second hash using any of the internet routing key forming strategies in current use. A key that does not work using the method of the current invention is hundreds of bits long.
 [0000]Finding a Perfect Hash Function for a Given Set of Keys
 [0029]
FIG. 7 is a flow chart of a method of finding a perfect hash function for a given set of keys. At 703 the method is entered with a set of keys. A set of coprime numbers is produced at 705. The initial set of coprime numbers is the set of coprime numbers less than 32. If an alternate set of coprimes is required, then expand the set to coprime numbers larger than 32. At 707 get the next coprime number p from the set of coprime numbers. At 709 get the next key from the set of keys. At 711 test each member of the set of keys to determine if there is a collision when s mod p is computed with the current values of s and p. If a collision has occurred 713, then determine if there are still elements left in the current set of coprime numbers 717. If there are additional elements in the current set of coprime numbers, then branch to 707. If a collision has not occurred 713, then test if all of the keys in the set of keys have been tested 715. If all the keys have not been tested, get the next member of the set of keys 709. If all the keys of the set of keys have been tested and no collision has occurred, then a perfect hash function has been found 719.  [0030]The method of
FIG. 7 may be used with hash functions other than s mod p, and the method may be set forth more broadly as a method of finding a hash function ƒ(s,p) for a set of keys. The steps of the method are:  [0031]defining a set of values P such that P has a high probability of including a value p such that ƒ(s,p) is perfect for the set of keys; and
 [0032]repeating the steps of

 selecting a value of p from P; and
 testing ƒ(s,p) with the selected p and the set of keys to determine whether ƒ(s,p) with the selected p is perfect for the set of keys
until a value of p is found for which ƒ(s,p) is perfect for the set of keys or all of the values of p have been tested.
Using a Perfect Hash Function to Translate a Set of Keys Into Entries in a Minimal Hash Table

 [0035]
FIG. 3 is a diagram of the translation of a set of keys into a minimal hash table. The set of keys 303 is translated into indexes using a perfect hash function 305. Perfect hash function 305 is expressed at 325 as s mod 18. Each translation produces an index, the index being used to turn on a bit in the bit string 309. The bit string 309 contains two values: a specification of the value of p used in the perfect hash function and a bit string which has a bit for each of the values in the range of values produced by the hash function. If a key hashes to a given value, the bit for that value is set. InFIG. 3 , the specification of the value of p is at 311, which contains an index into a table 327 of valid values of p. Bits 311 also are used for bits of the range of values produced by the hash function. The value of p specified at 311 is the value of p in the hash function that was used to create string 309. Bit string 311 can hold both types of data because there is a table for translating the index 311 that accounts for the overlapping data. The translation of data takes place by using index 311 in table 327, which here is an array of coprime numbers 327 having values less than 32. The choice of a maximum value less than 32 means that bit string 309 need have only 32 bits. The value referenced by the index is used as p in function 325. As should be clear from array 327, both the index for the value of p and the bits for the range of values produced by s mod p can be stored in 311 because bit 31 is not used and bits 2730 index into the first 16 elements of array 327. The value in 311 is 23, which is the index of the value 18 in array 327. Set bits in the remainder of bit string 309 indicate valid indexes made from the set of keys. Once a valid index in the bit string 309 has been located, function 317 transforms the index in the location of the data in array 319. Function 317 sums all the set bits in bit string 309 that precede the index resulting from the application of function 305 to the current key. Table 319 contains only entries corresponding to set bits in string 309, and consequently table 319 is minimal with regard to the set of keys and the hash function that are used to produce string 309. While transformation 301 assumes a hash function of s mod p for function 325, it should be clear to those skilled in the art that any function ƒ(k,c) can be used where the set of values returned by the function has no more members than there are available bits in string 309, k is a key belonging to a set of keys K, c belongs to a set of values C, and there is at least one value of c in C for which ƒ(k,c) produces no collision for all keys k in K.  [0036]In
FIG. 3 , the perfect hash function is used to map keys onto bitstring 309. However, any technique which results in such a mapping may be used. Another such technique is disclosed in patent application U.S. Ser. No. xx/xxx,xxx, Compressed representations of tries, in which the keys are associated with nodes in a trie of stride 1 and the nodes of the trie are mapped onto a bitstring, with the bit corresponding to a node that has an associated key being set. Additionally, any string of symbols may be used instead of the bitstring, as long as all of the symbols corresponding to the keys are set to a value that indicates that the symbol corresponds to a key. Further, an array or any representation of data that has the characteristics of an ordered set may be used to store the data associated with the keys. There may be any relationship between the positions of the set symbols in the string of symbols and the positions of the corresponding data in the array, as long as the corresponding data in the array can be located from the position of the symbol in the string. Thus, a set of data associated with a set of keys may be represented using the following elements:  [0037]a string of symbols, the value of a symbol in the string indicating whether the symbol corresponds to one of the keys in the set; and
 [0038]an ordered set of the items of data wherein there is an item of data corresponding to each symbol that corresponds to a key and the position of the item of data in the ordered set being such that the item of data may be located using the position of the symbol onto which the key has been mapped.
 [0039]The ordered set need only contain entries for the items of data, so the representation can be as small as the amount of memory required for the items of data plus the amount of memory required for the string of symbols.
 [0040]Methods used to write or read a representation of a set of data associated with a set of keys that has the above form are not dependent on the manner in which the keys are mapped to the string of symbols. A method of making the representation has the following steps:
 [0041]for each key in the set of keys,

 mapping the key onto a symbol of the string of symbols;
 setting the symbol onto which the key has been mapped; and
 placing the item of data associated with the key in an ordered set of the items of data, the position of the item of data in the ordered set being such that the item of data may be located using the position of the symbol onto which the key has been mapped.

 [0045]A method of reading the representation has the following steps:
 [0046]mapping the key to a set symbol in the string of symbols;
 [0047]determining the position of the set symbol relative to other set symbols in the string; and
 [0048]using the position of the set symbol to locate the item of data corresponding to the key in the ordered set.
 [0000]Implementation of a Method of Finding a Perfect Hash Function
 [0049]
FIG. 4 shows C language code for finding a perfect hash function for a given set of keys. First a static array 403 is defined and the array is instantiated with the set of coprime numbers whose values are less than thirtytwo 405. Array 405 is terminated with the value zero, which is not a member of the set of coprime numbers. A block of code 407 defines a hash function key mod p 413 that returns a hash value. The hash function is passed hash key 409 and a value p 411. The value p 411 is a member of the array of coprime numbers 403.  [0050]To find a hash function s mod p that is perfect for a given set of keys, function hashSearch 415 is defined. Function hashSearch 415 is passed a pointer to an array of keys 417 and an integer 419 containing the number of elements in array 417. The function allocates memory 421 to store an index obtained using key mod p for each member of array of keys 417. Block of code 425 iterates through the set of coprime numbers stored in array p 403. Block of code 427 iterates through the set of keys stored in the array pointed to in keys 417 for a current value of p. The current value of p is specified by an index i into array 405 of coprime numbers. The hash values for the current iteration of set of keys 427 and current value of p are stored in memory 423. Block of code 431 compares the hash index 421 for the current iteration of set of keys 427 against all previous hash indexes 421 for the current iteration of the set of keys 427. If any of the previous indexes are equal the current index then a collision has occurred and the iteration 431 for the current key is ended 433. If all keys were iterated through without finding a matching hash index 435, then a perfect hash function has been found for the given set of keys and the iteration is ended 435. If the iteration 425 is complete without locating a perfect hash function, return zero, the last element in the array p 403. If iteration 425 finds a perfect hash function, then return the value of p in s mod p from the array p 403 as indexed by the value of i in iteration 425. In a preferred embodiment there are multiple sets of the array 405, the alternate sets being used when a perfect hash is not found in a first iteration.
 [0000]Implementation of a Method to Produce a Representation of a Perfect Hash Function for a Set of Keys
 [0051]
FIG. 5 shows C language code 501 that produces bit string 309. Function defineHash 505 returns a 32 bit encoded word 309 that represents a perfect hash function for a given set of keys (311) and the hash values that result from applying the perfect hash to the given set of keys. The perfect hash function is represented at 311 by the index in array 503 of the value of p used in the perfect hash function and the hash values are represented by set bits in encoded word 309. Array decode 503 defines an array of possible values of p that can be returned from hashSearch 415. Function defineHash 505 is passed a pointer to an array of keys 507 and number of keys 509. DefineHash 505 calls hashSearch 415, passing the pointer to array of keys 507 and number keys of 509 to find p 511 to be used by hash function 407. Block of code 513 iterates through the array of possible values of p 503 to determine which element of array 503 matches p 511. At 515, the index of the iteration 513 is shifted into the top five bits 311 of encoded word 309. Block of code 517 iterates through array of keys 507 getting the index, which hash function 407 computes using the value of p 511. At 519, a bit corresponding to the index returned from the hash function is set in encoded word 309. Encoded word 309 is returned to the caller at 521. The logic in 501 is shown in 305 transforming set of keys 303 to array of bits 309 combined with a decode value 311. In a preferred embodiment there are multiple sets of the array 503, the alternate sets being used when a perfect hash function is not found in a first iteration.  [0000]Using the Representation of the Perfect Hash Function and the Minimal Hash Table to Find the Address of Data Corresponding to a Given Key
 [0052]
FIG. 6 illustrates how the address of the data corresponding to a given key can be found using bit string 309 and the hash function specified in bit string 309. C code 601 begins by defining an array maskTable 603 that contains values for masking off the most significant bits of code 607, which is the encoded bit string 309 produced by defineHash 505. The function findAddress 605 is passed code 607, a key 609 for which the corresponding data is to be found, and a baseAddress 611 for array 319 which contains the corresponding data. The address of the data corresponding to the key is found using baseAddress 611 and the hashed value produced by applying s mod p with the value of p specified at 311 to the key. The first step is to get the value of p from field 311. (613) The next step 615 is to use the value of p to determine the hashed value for the key. The hashed value is used to locate the bit in string 309 that corresponds to the key. Next, loop 617 iterates through bit string 309, counting every set bit (619) where the index is less than the index returned from the hash function 615. If bit map index for the index returned by the hash function is not set, return −1 623 indicating the key was invalid. Otherwise, compute the location of the data by adding the count of valid bits to baseAddress 525. The logic in 601 is shown at 317 transforming a key form a bit string 309 to an address in array 319.  [0053]The foregoing Detailed Description has disclosed to those skilled in the relevant technologies how to make and use the inventions claimed herein and has also disclosed the best mode presently known to the inventor of making and using the inventions. It will be immediately apparent to those skilled in the relevant technologies that apparatus and methods embodying the inventions may be implemented in many ways other than those disclosed herein and also for many other purposes. For example, as disclosed herein, the invention is used to represent and look up data that is associated with an IP address; it can, however, be used in any situation in which a key is used to locate data.
 [0054]The mapping of keys to symbols in the string of symbols may be done using any available technique and the symbols may have any form from which it may be determined that the symbol corresponds to a key. The data may be contained in an array, but it may have any other representation which has the characteristics of an ordered set and any relationship between set symbols in the string of symbols and the data in the ordered set is possible as long as the data can be located from the position of the symbol associated with the key in the bit string. The method of finding a perfect hash function for a set of keys can be used with any function ƒ(s,p) for which there is a high probability that a set of values P of p can be found which includes at least one value of p that will yield a hash function that is perfect for the set of keys.
 [0055]The manner in which the apparatus and methods embodying the inventions are implemented will further depend on the nature of the keys and the data, the system in which the invention is implemented, and the idiosyncrasies of the implementers. For all of the foregoing reasons, the Detailed Description is to be regarded as being in all respects exemplary and not restrictive, and the breadth of the invention disclosed herein is to be determined not from the Detailed Description, but rather from the claims as interpreted with the full breadth permitted by the patent laws.
Claims (25)
Priority Applications (1)
Application Number  Priority Date  Filing Date  Title 

US11116648 US20060248079A1 (en)  20050428  20050428  Method and apparatus for finding a perfect hash function and making minimal hash table for a given set of keys 
Applications Claiming Priority (1)
Application Number  Priority Date  Filing Date  Title 

US11116648 US20060248079A1 (en)  20050428  20050428  Method and apparatus for finding a perfect hash function and making minimal hash table for a given set of keys 
Publications (1)
Publication Number  Publication Date 

US20060248079A1 true true US20060248079A1 (en)  20061102 
Family
ID=37235674
Family Applications (1)
Application Number  Title  Priority Date  Filing Date 

US11116648 Abandoned US20060248079A1 (en)  20050428  20050428  Method and apparatus for finding a perfect hash function and making minimal hash table for a given set of keys 
Country Status (1)
Country  Link 

US (1)  US20060248079A1 (en) 
Cited By (13)
Publication number  Priority date  Publication date  Assignee  Title 

US20060271539A1 (en) *  20050527  20061130  International Business Machines Corporation  File storage method and apparatus 
US20070061280A1 (en) *  20050908  20070315  International Business Machines Corporation  Fast select for fetch first N rows with order by 
US20070218901A1 (en) *  20060210  20070920  Tenny Nathan E  Obscuring temporary user equipment identities 
US20080275847A1 (en) *  20070501  20081106  Microsoft Corporation  Scalable minimal perfect hashing 
US20090070354A1 (en) *  20070911  20090312  Kumar Hemachandra Chellapilla  Minimal perfect hash functions using double hashing 
US20090196296A1 (en) *  20080131  20090806  Thomas Vachuska  Data verification by challenge 
US20100287288A1 (en) *  20090507  20101111  Microsoft Corporation  Mechanism to Verify Physical Proximity 
US20100325213A1 (en) *  20090617  20101223  Microsoft Corporation  Multitier, multistate lookup 
US20100332471A1 (en) *  20090630  20101230  Cypher Robert E  Bloom Bounders for Improved Computer System Performance 
US20110013639A1 (en) *  20090714  20110120  Broadcom Corporation  Flow based path selection randomization using parallel hash functions 
DE102011078424A1 (en) *  20110630  20130103  Siemens Aktiengesellschaft  Methods and apparatus for creating addresses for nodes in a network 
CN103997558A (en) *  20140610  20140820  宁波大学  Blacklist fast matching method for mobile phone 
US20170339111A1 (en) *  20160523  20171123  Informatica Llc  Method, apparatus, and computerreadable medium for masking data 
Citations (3)
Publication number  Priority date  Publication date  Assignee  Title 

US5842224A (en) *  19890616  19981124  Fenner; Peter R.  Method and apparatus for source filtering data packets between networks of differing media 
US5914938A (en) *  19961119  19990622  Bay Networks, Inc.  MAC address table search unit 
US20020194478A1 (en) *  20010405  20021219  Mackenzie Philip D.  Methods and apparatus for providing efficient passwordauthenticated key exchange 
Patent Citations (3)
Publication number  Priority date  Publication date  Assignee  Title 

US5842224A (en) *  19890616  19981124  Fenner; Peter R.  Method and apparatus for source filtering data packets between networks of differing media 
US5914938A (en) *  19961119  19990622  Bay Networks, Inc.  MAC address table search unit 
US20020194478A1 (en) *  20010405  20021219  Mackenzie Philip D.  Methods and apparatus for providing efficient passwordauthenticated key exchange 
Cited By (28)
Publication number  Priority date  Publication date  Assignee  Title 

US20060271539A1 (en) *  20050527  20061130  International Business Machines Corporation  File storage method and apparatus 
US7370048B2 (en) *  20050527  20080506  International Business Machines Corporation  File storage method and apparatus 
US20080288495A1 (en) *  20050908  20081120  International Business Machines Corporation  Fast select for fetch first n rows with order by 
US20070061280A1 (en) *  20050908  20070315  International Business Machines Corporation  Fast select for fetch first N rows with order by 
US7792825B2 (en) *  20050908  20100907  International Business Machines Corporation  Fast select for fetch first N rows with order by 
US9154464B2 (en) *  20060210  20151006  Qualcomm Incorporated  Obscuring temporary user equipment identities 
US8195943B2 (en)  20060210  20120605  Qualcomm Incorporated  Signaling with opaque UE identities 
US20070218901A1 (en) *  20060210  20070920  Tenny Nathan E  Obscuring temporary user equipment identities 
US20070226502A1 (en) *  20060210  20070927  Tenny Nathan E  Signaling with opaque ue identities 
US20080275847A1 (en) *  20070501  20081106  Microsoft Corporation  Scalable minimal perfect hashing 
US7792877B2 (en)  20070501  20100907  Microsoft Corporation  Scalable minimal perfect hashing 
US8271500B2 (en)  20070911  20120918  Microsoft Corporation  Minimal perfect hash functions using double hashing 
US20090070354A1 (en) *  20070911  20090312  Kumar Hemachandra Chellapilla  Minimal perfect hash functions using double hashing 
US8200969B2 (en) *  20080131  20120612  HewlettPackard Development Company, L.P.  Data verification by challenge 
US20090196296A1 (en) *  20080131  20090806  Thomas Vachuska  Data verification by challenge 
US8224978B2 (en) *  20090507  20120717  Microsoft Corporation  Mechanism to verify physical proximity 
US20100287288A1 (en) *  20090507  20101111  Microsoft Corporation  Mechanism to Verify Physical Proximity 
US8271635B2 (en)  20090617  20120918  Microsoft Corporation  Multitier, multistate lookup 
US20100325213A1 (en) *  20090617  20101223  Microsoft Corporation  Multitier, multistate lookup 
US9037554B2 (en) *  20090630  20150519  Oracle America, Inc.  Bloom bounders for improved computer system performance 
US20100332471A1 (en) *  20090630  20101230  Cypher Robert E  Bloom Bounders for Improved Computer System Performance 
US20110013639A1 (en) *  20090714  20110120  Broadcom Corporation  Flow based path selection randomization using parallel hash functions 
US8503456B2 (en) *  20090714  20130806  Broadcom Corporation  Flow based path selection randomization 
US8665879B2 (en)  20090714  20140304  Broadcom Corporation  Flow based path selection randomization using parallel hash functions 
US20110013627A1 (en) *  20090714  20110120  Broadcom Corporation  Flow based path selection randomization 
DE102011078424A1 (en) *  20110630  20130103  Siemens Aktiengesellschaft  Methods and apparatus for creating addresses for nodes in a network 
CN103997558A (en) *  20140610  20140820  宁波大学  Blacklist fast matching method for mobile phone 
US20170339111A1 (en) *  20160523  20171123  Informatica Llc  Method, apparatus, and computerreadable medium for masking data 
Similar Documents
Publication  Publication Date  Title 

US6678687B2 (en)  Method for creating an index and method for searching an index  
US6014659A (en)  Compressed prefix matching database searching  
US5440482A (en)  Forward and reverse BoyerMoore string searching of multilingual text having a defined collation order  
US6697363B1 (en)  Method and apparatus for longest matching prefix determination in a communication network  
US4495566A (en)  Method and means using digital data processing means for locating representations in a stored textual data base  
US20030212694A1 (en)  Method and mechanism of improving performance of database query language statements  
US6614789B1 (en)  Method of and apparatus for matching strings of different lengths  
US3893070A (en)  Error correction and detection circuit with modular coding unit  
US20070101074A1 (en)  Data storage using identifiers  
US7440304B1 (en)  Multiple string searching using ternary content addressable memory  
Faloutsos  Multiattribute hashing using gray codes  
US7590652B2 (en)  Systems and methods of reverse lookup  
US20020147721A1 (en)  Compact data structures for pipelined message forwarding lookups  
Carter et al.  Universal classes of hash functions  
US6560670B1 (en)  Interrow configurability of content addressable memory  
US20040111439A1 (en)  Method for increasing average storage capacity in a bitmapped treebased storage engine by using remappable prefix representations and a runlength encoding scheme that defines multilength fields to compactly store IP prefixes  
US20030004938A1 (en)  Method of storing and retrieving multidimensional data using the hilbert curve  
US6697797B1 (en)  Method and apparatus for tracking data in a database, employing lastknown location registers  
US20040199533A1 (en)  Associative hash partitioning  
US7019674B2 (en)  Contentbased information retrieval architecture  
US20040254909A1 (en)  Programming routes and access control lists in comparison tree data structures and their use such as in performing lookup operations  
US20070028033A1 (en)  Method for identifying data characteristics for flash memory  
US7783654B1 (en)  Multiple string searching using content addressable memory  
US5671406A (en)  Data structure enhancements for inplace sorting of a singly linked list  
US20070234005A1 (en)  Hash tables 
Legal Events
Date  Code  Title  Description 

AS  Assignment 
Owner name: CITIBANK, N.A. AS COLLATERAL AGENT, NEW YORK Free format text: SECURITY AGREEMENT;ASSIGNORS:FREESCALE SEMICONDUCTOR, INC.;FREESCALE ACQUISITION CORPORATION;FREESCALE ACQUISITION HOLDINGS CORP.;AND OTHERS;REEL/FRAME:018855/0129 Effective date: 20061201 Owner name: CITIBANK, N.A. AS COLLATERAL AGENT,NEW YORK Free format text: SECURITY AGREEMENT;ASSIGNORS:FREESCALE SEMICONDUCTOR, INC.;FREESCALE ACQUISITION CORPORATION;FREESCALE ACQUISITION HOLDINGS CORP.;AND OTHERS;REEL/FRAME:018855/0129 Effective date: 20061201 

AS  Assignment 
Owner name: FREESCALE SEMICONDUCTOR, INC., TEXAS Free format text: PATENT RELEASE;ASSIGNOR:CITIBANK, N.A., AS COLLATERAL AGENT;REEL/FRAME:037354/0225 Effective date: 20151207 

AS  Assignment 
Owner name: MORGAN STANLEY SENIOR FUNDING, INC., MARYLAND Free format text: SECURITY AGREEMENT SUPPLEMENT;ASSIGNOR:NXP B.V.;REEL/FRAME:038017/0058 Effective date: 20160218 

AS  Assignment 
Owner name: MORGAN STANLEY SENIOR FUNDING, INC., MARYLAND Free format text: CORRECTIVE ASSIGNMENT TO CORRECT THE REMOVE APPLICATION 12092129 PREVIOUSLY RECORDED ON REEL 038017 FRAME 0058. ASSIGNOR(S) HEREBY CONFIRMS THE SECURITY AGREEMENT SUPPLEMENT;ASSIGNOR:NXP B.V.;REEL/FRAME:039361/0212 Effective date: 20160218 

AS  Assignment 
Owner name: MORGAN STANLEY SENIOR FUNDING, INC., MARYLAND Free format text: CORRECTIVE ASSIGNMENT TO CORRECT THE REMOVE APPLICATION 12681366 PREVIOUSLY RECORDED ON REEL 039361 FRAME 0212. ASSIGNOR(S) HEREBY CONFIRMS THE SECURITY AGREEMENT SUPPLEMENT;ASSIGNOR:NXP B.V.;REEL/FRAME:042762/0145 Effective date: 20160218 Owner name: MORGAN STANLEY SENIOR FUNDING, INC., MARYLAND Free format text: CORRECTIVE ASSIGNMENT TO CORRECT THE REMOVE APPLICATION 12681366 PREVIOUSLY RECORDED ON REEL 038017 FRAME 0058. ASSIGNOR(S) HEREBY CONFIRMS THE SECURITY AGREEMENT SUPPLEMENT;ASSIGNOR:NXP B.V.;REEL/FRAME:042985/0001 Effective date: 20160218 