Publication number | US8180744 B2 |

Publication type | Grant |

Application number | US 12/243,103 |

Publication date | 15 May 2012 |

Filing date | 1 Oct 2008 |

Priority date | 5 Mar 2008 |

Fee status | Paid |

Also published as | US20100082562 |

Publication number | 12243103, 243103, US 8180744 B2, US 8180744B2, US-B2-8180744, US8180744 B2, US8180744B2 |

Inventors | Vinay Deolalikar, Kave Eshghi |

Original Assignee | Hewlett-Packard Development Company, L.P. |

Export Citation | BiBTeX, EndNote, RefMan |

Patent Citations (26), Non-Patent Citations (4), Classifications (7), Legal Events (4) | |

External Links: USPTO, USPTO Assignment, Espacenet | |

US 8180744 B2

Abstract

A particular data value is represented as a group of segments stored in corresponding entries of a data structure. Additional data values represented by corresponding groups of segments are written into the data structure. A probability of overwriting segments representing the particular data value increases as a number of the additional data values increase. A correct version of the particular data value is retrieved even though one or more segments representing the particular data value has been overwritten.

Claims(23)

1. A method executed by a computer of managing storing of data in a data structure, comprising:

representing a particular data value as a group of segments stored in corresponding entries of the data structure;

writing additional data values represented by corresponding groups of segments into the data structure, wherein a probability of overwriting segments representing the particular data value increases as a number of the additional data values increase; and

retrieving, using error correction, a correct version of the particular data value even though one or more segments representing the particular data value has been overwritten,

wherein the error correction enables retrieval of the particular data value even if up to a predetermined number of the segments representing the particular data value has been overwritten, and

wherein the particular data value becomes non-retrievable if more than the predetermined number of the segments representing the particular data value has been overwritten.

2. The method of claim 1 , further comprising:

causing gradual degradation of the particular data value with the writing of the additional data values written into the data structure, wherein the gradual degradation causes the particular data value to become irretrievable after some number of writes of the additional data items.

3. The method of claim 2 , wherein gradual degradation of the particular data value enables the data structure, which has a fixed size to accept the additional data values without using a mechanism that has to explicitly select a data value in the data structure to eject.

4. The method of claim 1 , further comprising:

storing the data values in the data structure that is a hash table arranged as rows and columns;

hashing a key associated with the particular data value plural times to produce plural hash values;

storing the segments representing the particular data value in respective rows of the hash table according to the corresponding hash values.

5. The method of claim 4 , wherein storing the segments comprises storing the segments representing the particular data value in corresponding columns of the hash table.

6. The method of claim 4 , further comprising:

hashing a key associated with each of the additional data values plural times to produce plural hash values for the corresponding key; and

storing the segments representing each of the additional data values in respective rows of the hash table according to the hash values of the corresponding additional data values.

7. The method of claim 6 , wherein at least one of the segments representing at least one of the additional data values map to the same entry in the hash table as a segment corresponding to the particular data value.

8. The method of claim 1 , further comprising encoding the particular data value to produce the group of segments.

9. The method of claim 8 , wherein encoding the particular data value comprises encoding using an error correction code.

10. The method of claim 1 , further comprising:

in response to receiving a given key to retrieve a corresponding given data value from the data structure, retrieving the segments corresponding to the given data value from the data structure; and

decoding a code constructed from the retrieved segments to determine whether the given data value is retrievable.

11. The method of claim 10 , wherein decoding the code comprises decoding the code using an error correction algorithm.

12. The method of claim 10 , wherein constructing the code comprises concatenating the retrieved segments, and wherein the code is possibly corrupt due to possible overwriting of at least one of the retrieved segments due to insertion of another data value into the data structure.

13. The method of claim 1 , further comprising:

inserting plural copies of the particular data value into the data structure to provide diversity for the particular data value, and to increase an expected lifetime of the particular data value in the data structure compared to some other data values in the data structure.

14. The method of claim 13 , wherein inserting the plural copies of the particular data value comprises inserting plural corresponding groups of segments into the data structure, where each of the plural groups represents a respective one of the plural copies of the particular data value.

15. The method of claim 1 , further comprising:

dividing a second data value to be stored in the data structure into a plurality of parts;

encoding each of the plurality of parts to produce a corresponding set of segments; and

storing the sets of segments that represent the corresponding plurality of parts in the data structure.

16. A method executed by a computer of managing storing of data in a data structure, comprising:

representing a particular data value as a group of segments stored in corresponding entries of the data structure;

writing additional data values represented by corresponding groups of segments into the data structure, wherein a probability of overwriting segments representing the particular data value increases as a number of the additional data values increase;

retrieving a correct version of the particular data value even though one or more segments representing the particular data value has been overwritten;

inserting plural copies of the particular data value into the data structure to provide diversity for the particular data value, and to increase an expected lifetime of the particular data value in the data structure compared to some other data values in the data structure, wherein inserting the plural copies of the particular data value comprises inserting plural corresponding groups of segments into the data structure, where each of the plural groups represents a respective one of the plural copies of the particular data value;

defining plural families of hash functions for the particular data value, where each of the plural families includes respective hash functions; and

for each of the plural groups of the segments, hashing a key associated with the particular data value with a respective one of the plural families of hash functions.

17. The method of claim 16 , wherein hashing the key with the respective family of hash functions comprises hashing the key multiple times with corresponding hash functions in the family to produce plural hash values that point to respective entries of the data structure into which corresponding segments of a respective copy of the particular data value are to be stored.

18. A method executed by a computer, comprising:

receiving a first pair of a key and data value to be stored in a hash table;

applying plural functions on the key to produce plural pointer values that point to different entries of the hash table;

encoding the data value to produce segments;

storing the segments representing the data value into entries of the hash table identified by the pointer values, wherein a first of the segments is stored in a first of the entries identified by a first of the pointer values, and a second of the segments is stored in a second of the entries identified by a second of the pointer values; and

retrieving, using error correction, a correct version of the data value even though one or more segments representing the data value has been overwritten, wherein the error correction enables retrieval of the data value even if up to a predetermined number of the segments representing the data value has been overwritten, and

wherein the data value becomes non-retrievable if more than the predetermined number of the segments representing the data value has been overwritten.

19. The method of claim 18 , further comprising:

receiving additional pairs of keys and data values;

storing the additional pairs of keys and data values into the hash table,

wherein storing the additional pairs of keys and data values causes gradual degradation of the data value of the first pair.

20. The method of claim 18 , wherein applying the plural functions comprises applying plural hash functions on the key.

21. An article comprising at least one computer-readable storage medium containing instructions that when executed cause a computer to:

store plural representations of a first data value in a data structure:

store additional data values in the data structure after storing the plural representations of the first data value, wherein storing the additional data values causes gradual degradation of at least one of the plural representations of the first data value;

in response to a request to retrieve the first data value, retrieve the plural representations of the first data value; and

decode the retrieved plural representations to determine whether the first data value is retrievable, wherein the decoding includes using error correction to recover the first data value, where the error correction enables recovery of the first data value even if up to a predetermined number of segments of a particular one of the plural representations has been overwritten, and

wherein the first data value becomes non-retrievable from the particular representation if more than the predetermined number of the segments of the particular representation has been overwritten.

22. The article of claim 21 , wherein storing the plural representations comprises storing the plural representations that represent plural copies of the first data value.

23. The article of claim 21 , wherein storing the plural representations comprises storing the plural representations that represent different parts of the first data value.

Description

This application claims the benefit under 35 U.S.C. §119(e) of U.S. Provisional Application Ser. No. 61/033,811, entitled “MANAGING STORAGE OF DATA IN A DATA STRUCTURE,” filed Mar. 5, 2008.

In computers, storage devices (such as memory devices) are used to store various data involved in the execution of software or to perform other tasks, such as communications tasks, management tasks, and so forth. Data structures, such as tables, stored in storage devices often have fixed sizes. Examples of fixed-size data structures include lookup tables used in cache memory subsystems, lookup tables used for database applications, and so forth.

With a fixed-size data structure, an algorithm conventionally has to be provided to explicitly select a data item in the data structure to remove (to eject the data item) so that space is freed up to enable addition of a new data item to the data structure. An example of such an algorithm is a least recently used (LRU) replacement algorithm. However, having to provide an algorithm to explicitly eject (remove) a data item from a data structure adds complexity to a system.

Some embodiments of the invention are described, by way of example, with respect to the following figures:

In accordance with some embodiments, a technique is provided to enable storage of data items into a fixed-size data structure without having to provide an explicit eject mechanism for selecting data items in the data structure to remove such that new data can be inserted into the data structure. A technique according to some embodiments, gradually degrades data items stored in the data structure by probabilistically overwriting different portions of existing data items in the data structure as new data items are inserted into the data structure. As more data items are inserted into the data structure, the degradation of earlier data items (data items written into the data structure at an earlier time) is increased until, at some point, the earlier data items are considered lost and cannot be retrieved. A data item that has been degraded to a point that it is no longer retrievable is considered to have “exit” the data structure, even though no explicit eject mechanism has been provided to remove this data item.

A “data item” (or interchangeably, “data value”) refers generally to a unit of data that can be stored into a data structure. In accordance with some embodiments, the data item or data value is first encoded, and it is the encoded version of the data item or data value that is stored in the data structure. Thus, storing a data item or data value in a data structure can refer to storing an encoded version of the data item or data value in the data structure. A “data structure” refers to some predefined arrangement that provides entries for accepting data.

More specifically, it is desired to store p key-data value pairs (K_{i},V_{i}), i=1 to n (where [[n·**1**]]n≧1), in r arrays (named A_{1}, . . . , A_{r}) each of size q×1, where [[p·1]] p≧1, [[r·1]]r≧2, and [[q·**2**]]q≧2.

Each key K_{i }is formed of s bits, and each data value V_{i }is formed of t bits, where [[s·1]]s≧1, [[·1]]t≧1. The r arrays, each of size q×1, are depicted as A_{1}, A_{2}, . . . A_{r }in _{1}, A_{2}, . . . A_{r }together form a data structure **102**, as depicted in FIG. 1. In the example data structure **102** of _{j}, j=1 to r, makes up a corresponding column of the data structure **102**. Thus, in **102** has r columns, each corresponding to respective array A_{j}. The data structure **102** has q rows, which corresponds to the length of each array A_{j}. In a different implementation, the arrays A_{j}, j=1 to r, can be arranged as rows in the data structure **102**, with the columns defined by the q entries in each array A_{j}.

As depicted in **102** is stored in a storage **104** of a computer **100**, where the storage **104** can be implemented with storage devices such as dynamic random access memories (DRAMs), synchronous DRAMs, disk media, and so forth. The computer **100** can be a personal computer, server computer, a communications device, a storage controller, and so forth.

As further depicted in _{i}, V_{i}) are input or inserted into the data structure **102**. Note that in some embodiments, the data values V_{i }(and more specifically, representations of the data values V_{i}) are stored in the data structure **102**, and the keys K_{i }point to where the data values V_{i }are to be stored (in other words, the keys K_{i }are actually not stored in the data structure **102**). The representations of V_{i }stored in the data structure **102** can be encoded versions of V_{i}, as explained further below. In other implementations, other forms of representations of V_{i }can be stored in the data structure **102**.

In accordance with some embodiments, a “time arrow” feature is associated with the data structure **102**. The time arrow feature of the data structure **102** causes key-data value pairs inserted later to be more likely to be retrievable than those inserted earlier. Key-data value pairs inserted into the data structure **102** are degraded with time (or more precisely, with the number of insertions that occur after a certain key-data value pair has been inserted). Degradation of a particular key-data value pair is caused by portion(s) representing the particular data value being overwritten by subsequent insertions of key-data value pairs. The time arrow feature offers a deterministic and probabilistic behavior on the retrievability of a particular key-data value pair as a function of the number of pairs that are inserted after the key-data value pair.

To enable the retrieval of a correct version of data values from the data structure **102** even though portions representing the data values may have been overwritten, error correction codes can also be provided when storing data values into the data structure **102**. A data value that has been more recently inserted into the data structure **102** is more likely to be retrievable, since such more recently inserted data value would be less likely to have portions of the data value overwritten. Stated differently, data values inserted earlier are more likely to have collisions on them (where a collision can result in one or more portions being overwritten), resulting in higher likelihood of irretrievability. The more insertions that follow a particular data value, the more are the chances that the portions used to represent the data value are overwritten, and the higher the chance of it becoming irretrievable. On the other hand, items inserted recently are less likely to have any collisions, resulting in more certain retrievability. By using a multidimensional array representation of the data structure **102**, the representations of the key-data value pairs are made more robust, and the lifetime before an inserted key-data value pair is degraded is quite high.

An error correction code can be used to recover the original data value (produce a correct version of the original data value), assuming that some portion(s) of the data value has been overwritten. Adding error correction codes when storing data values into the data structure **102** enhances retrievability (or stated another way, enhances the lifetime for which data values remain retrievable). Furthermore, the error correction codes provide a threshold below which overwritten portions do not render a key-data value pair irretrievable. However, data values that have been inserted earlier are less likely to be retrievable, since more portions of such data values are likely to have been overwritten. More data portions being overwritten reduces the likelihood that an error correction code can be used to recover the data value.

In some embodiments, the data structure **102** is a hash table. A hash table refers to a table having entries pointed to (or addressed) by hash values, which are produced by hashing a key (by applying a hash function on the key). In one example, the hash table is a hash table version of a Bloom filter.

In some examples, the data structure **102** can be used as a lookup table, such as a lookup table used in a cache memory system or an index table used in a database management system. Lookup tables or index tables are accessed to allow quicker access of a larger data structure, such as a cache or database table.

As further depicted in **106** and a Retrieve software module **108** are provided in the computer **100** to enable storing and retrieval of data in the data structure **102** using techniques according to some embodiments. The software modules **106** and **108** are executable on one or more central processing units (CPUs) **110**, which is (are) connected to the storage **104**.

The Store software module **106** stores data (e.g., key-data value pairs) into the data structure **102**. The Retrieve software module **108** is able to retrieve-data from the data structure **102** for output (**112**), where the output (**112**) can be presented in a display device, communicated over a network to a remote computer, or input to another software (not shown).

A process performed by the Store software module **106** is depicted in

An input key-data value pair (K_{i}, V_{i}) is received (at **202**) to be inserted into the data structure **102**. To insert the input key-data value pair into the data structure **102**, r independent hash functions {h_{j}}_{{j=1, . . . , r}} are defined, each of which converts key K_{i }to h_{j}(K_{i}). In other words, the r hash functions are each applied (at **204**) independently r times to produce r hash values h_{j}(K_{i}), j=1 to r. These hash values are q-valued, namely they take values from {1, . . . , q}. The hash values between 1 and q are used to point to the q rows of the data structure **102**; in other words, a hash value of 1 points to row **1**, a hash value of q points to row q, and so forth. In a different embodiment, instead of using hash functions applied on the key to produce hash values, different functions can be used instead, where such functions are applied to the key to produce pointer values that point to entries of the data structure **102**.

Each data value V_{i }is encoded (at **206**) to produce r segments. In one embodiment, the encoding uses a (r, t, d) error correction code C such that encoding of V_{i }produces encoded value C_{i}=[c_{i1}, . . . , c_{ir}]. Note that the error control code is represented by calligraphed C, while the encoded version of the data value is represented by C_{i}. The (r, t, d) error correcting code refers to the type of code used to perform the encoding; for example, a (6, 4, d) code refers to an error correction code that converts a 4-byte input into a 6-byte output, where the two extra bastes are code values for performing error correction (note that d is based on the r and t values and represents how much error the error correction code can tolerate before error correction can no longer be performed). The encoded value C_{i }has r segments C_{i}=[c_{i1}, c_{i2}, . . . , c_{ir}], where each segment c_{ij }(j=1 to r) is stored in a corresponding column of the data structure **102**. The r segments c_{i1 }to c_{ir }together represent the data value V_{i}.

The r segments are stored (at **208**) in corresponding columns of the data structure **102**; in other words, segment c_{i1 }is stored in column **1** (or array A_{1 }in _{i2 }is stored in column **2** (or array A_{2}), and so forth. Note that the segments c_{i1 }to c_{ir }are not all necessarily stored in the same row; in fact, each segment c_{i1 }is stored in a row of the data structure **102** according to a hash value produced by a corresponding hash function h_{j}(K_{i}). In other words, segment c_{i1 }is stored in row h_{1}(K_{i}), segment c_{i2 }is stored in row h_{2}(K_{i}), and so forth.

For example, in **102** is depicted as an array of q rows and r columns. Segment c_{i1 }is stored in row **2** in column **1** (assuming that h_{1}(K_{i}) produces a hash value of 2); segment c_{i2 }is stored in row q in column **2** (assuming that h_{2}(K_{i}) produces a hash value of q); and c_{ir }is stored in row **1** of column r (assuming that h_{r}(K_{i}) produces a hash value of 1).

The process of _{i+1}, V_{i+1}) to be inserted into the data structure and so forth. As more subsequent key-data value pairs are inserted after (K_{i}, V_{i}), the likelihood of segments of such subsequent key-data value pairs colliding (and therefore overwriting) segments of (K_{i}, V_{i}) is increased.

**108** of **302**) a key K_{i }to retrieve a corresponding data value (V_{i}) from the data structure **102**. Note, that due to possible overwriting, data value V_{i }may or may not be retrievable from the data structure **102**.

Next, the key K_{i }is hashed (at **304**) r times using the same r hash functions used by the Store software module **106**. Segments corresponding to the r hash values are retrieved (at **306**) from the corresponding entries of the data structure **102**. For example, segment c_{i1 }is retrieved from row h_{1}(K_{i}) in column **1** (array A_{1}), segment c_{i2 }is retrieved from row h_{2}(K_{i}) in column **2** (array A_{2}), and so forth. From the retrieved segments, the possibly corrupted version (code) C•_{i }of the encoded value C_{i}=[c_{i1}, . . . , c_{ir}] is constructed (at **308**). This possibly corrupted version (code) C•_{i }is represented as C•_{i}=[c•_{i1}, . . . , c•_{ir}]. The version C•_{i}=[c•_{i1}, . . . , c•_{ir}] is decoded (at **310**) using standard decoding algorithms for the error correction code C. If the code C is chosen to be cyclic, then additional structure can be used to allow the decoding to be performed more efficiently.

If the original data value V_{i }is recoverable based on the decoding, then the result that is output (at **312**) is data value V_{i}, which was decoded successfully from C•_{i}. However, if corruption of C_{i }prevents recovery of V_{i }using the error correction code, then the result output (at **312**) is an error indication to indicate that the data value V_{i }is irretrievable (indicating that V_{i }is no longer in the data structure **102**).

In the foregoing, it was assumed that all key-data value pairs stored in the data structure **102** have equal importance, and therefore the algorithm discussed above causes each key-data value pair to have equal expected life in the data structure **102**. In some embodiments, it may be desirable to assign higher importance to some key-data value pairs, with such key-data value pairs of higher importance assigned a greater expected life.

The expected life of a key-data value pair (K, V) is the value of n (n insertions after (K,V) has been inserted) for which the probability of correct retrieval of (K, V) falls to below 0.5. It may be desirable that the expected life be longer for more important key-value pairs.

To counteract the degradation of a data value stored in the data structure **102** due to subsequent data value insertions the concept of diversity can be employed in some embodiments. Applying diversity causes multiple copies (rather than just one copy) of a data value to be stored in the data structure **102**. Diversity is denoted by l, where l>1 indicates the number of copies of the higher importance key-data value pairs to be stored in the data structure **102**.

Multiple families H_{i}, i=1 . . . l of independent hash functions (one family per data value copy) are provided for each higher importance key-data value pair. With this embodiment, the corresponding key K is hashed with multiple families of hash functions (instead of with just one set of hash functions as described above). In other words, the key K is hashed r times with a first family of hash functions; the key K is hashed r times with a second family of hash functions, and so forth. The number of families used depends on how valuable the key-data value pair is. Thus, l can be set differently for different key-data value pairs.

For each such family, a corresponding group of r segments representing the respective data value V is stored into the data structure **102** in the manner described above. The storing algorithm that takes into account multiple families of hash functions is a straightforward extension of the storing algorithm discussed in connection with

The following describes the algorithm used for retrieving a key-data value pair that is associated with multiple families of hash functions. It is desired to retrieve a pair (K_{i}, V_{i}) after several insertions have occurred after (K_{i}, V_{i}) was inserted into the data structure **102**. Also, diversity l was used for storing (K_{i}, V_{i}). As depicted in **502**) K_{i }for retrieving (K_{i}, V_{i}), K_{i }is hashed (at **504**) with the multiple (l) families of hash functions. Thus, K_{i }is hashed r times with a first family of hash functions; K_{i }is hashed r times with a second family of hash functions; and so forth (depending on the value of l).

For each family of hash functions, a respective set of r segments is retrieved (at **506**) from the data structure **102**, and this set is used to construct a corresponding version C′_{i,m(m=1 to l) }of the encoded value C_{i}. In other words, l (l·2) versions (possibly corrupt) of the encoded value C_{i }are created.

The multiple versions C′_{i,m(m=1 to l) }of the encoded value of V_{i }are decoded (at **508**). If it is determined (at **510**) that even one of these versions produces a valid output, then the process is complete and the result is output (at **512**), where the result is V_{i}. But if none of the versions C′_{i,m(m=1 to l) }can be successfully decoded to provide V_{i}, then a list decoding algorithm is performed (at **514**). A list decoding algorithm outputs a list of possible data values for a given input, in this case C′_{i,m}. For l inputs (C′_{i,m(m=1 to l)}), l lists are created, with each list containing possible data values. If the corrupted versions C′_{i,m(m=1 to l) }are list decodable, then the output V_{i }would be at the intersection of the l lists. In other words, a common element of the l lists is identified, where the common element is output V_{i}. In an alternative embodiment, instead of applying l families of hash functions to the entire input data value V_{i}, a different form of diversity can be performed, as discussed below. In this alternative diversity embodiment, an input data value V_{i }is divided into u parts [v_{i1}, V_{i2}, . . . , v_{iu}], [[u·**2**]]u≧2, where each part has length t/u. Each of the smaller parts v_{i1}, V_{i}, . . . can be encoded by an [r, t/s, d′] error correction code, where d′>d because the dimension of the code has decreased.

Effectively each of the u parts v_{i1}, v_{i2}, . . . , v_{iu }of input data value V_{i }is encoded to produce r segments for each part v_{iz}, z=1 to u. The r segments for each part v_{iz}, z=1 to u, is then stored into the data structure **102** using the store algorithm described in connection with

In storing the r segments for each part v_{iz}, a corresponding family of hash functions is used to produce r hash values from the key K_{i}. In other words, u families of hash functions are defined, with each family corresponding to part v_{iz}. The same key K_{i }is hashed using the u hash families. Each such hash yields a q-ary r-tuple (a tuple of r hash values that vary between 1 and q). The q-ary r-tuple is used to store the r segments corresponding to the respective input part v_{iz},

The above process is depicted in _{i1 }is encoded (**602**) to produce a first set of r segments representing v_{i1}. Also, a first family of hash functions is applied (**604**) on K_{i }to produce r hash values that are used to point to rows in the data structure **102** that the first set of r segments are to be stored in. This is repeated for each of the other parts v_{iz}, with the last part v_{iu }encoded (**606**) to produce the u^{th }set of r segments. Also, the u^{th }family of hash functions is applied on K_{i }to produce r hash values that are used to point to rows in the data structure **102** that the u^{th }set of r segments are to be stored in.

Instructions of software described above (including the Store module **106** and Retrieve module **108** of **110** in

Data and instructions (of the software) are stored in respective storage devices, which are implemented as one or more computer-readable or computer-usable storage media. The storage media include different forms of memory including semiconductor memory devices such as dynamic or static random access memories (DRAMs or SRAMs), erasable and programmable read-only memories (EPROMs), electrically erasable and programmable read-only memories (EEPROMs) and flash memories; magnetic disks such as fixed, floppy and removable disks; other magnetic media including tape; and optical media such as compact disks (CDs) or digital video disks (DVDs). Note that the instructions of the software discussed above can be provided on one computer-readable or computer-usable storage medium, or alternatively, can be provided on multiple computer-readable or computer-usable storage media distributed in a large system having possibly plural nodes. Such computer-readable or computer-usable storage medium or media is (are) considered to be part of an article (or article of manufacture). An article or article of manufacture can refer to any manufactured single component or multiple components.

In the foregoing description, numerous details are set forth to provide an understanding of the present invention. However, it will be understood by those skilled in the art that the present invention may be practiced without these details. While the invention has been disclosed with respect to a limited number of embodiments, those skilled in the art will appreciate numerous modifications and variations therefrom. It is intended that the appended claims cover such modifications and variations as fall within the true spirit and scope of the invention.

Patent Citations

Cited Patent | Filing date | Publication date | Applicant | Title |
---|---|---|---|---|

US5339398 * | 14 Jul 1992 | 16 Aug 1994 | North American Philips Corporation | Memory architecture and method of data organization optimized for hashing |

US5963909 * | 25 Nov 1997 | 5 Oct 1999 | Solana Technology Development Corporation | Multi-media copy management system |

US6154747 * | 26 Aug 1998 | 28 Nov 2000 | Hunt; Rolf G. | Hash table implementation of an object repository |

US6199178 * | 15 Jul 1999 | 6 Mar 2001 | Wild File, Inc. | Method, software and apparatus for saving, using and recovering data |

US6275919 * | 15 Oct 1998 | 14 Aug 2001 | Creative Technology Ltd. | Memory storage and retrieval with multiple hashing functions |

US6330557 * | 30 Jun 1998 | 11 Dec 2001 | Sun Microsystems, Inc. | Method and system for storing data in a hash table that eliminates the necessity of key storage |

US6366987 * | 13 Aug 1998 | 2 Apr 2002 | Emc Corporation | Computer data storage physical backup and logical restore |

US6442553 * | 28 Aug 1995 | 27 Aug 2002 | Fujitsu Limited | Hash system and hash method for transforming records to be hashed |

US6529995 * | 18 Jun 1999 | 4 Mar 2003 | Storage Technology Corporation | Method and apparatus for maintaining and restoring mapping table entries and data in a raid system |

US7080072 * | 14 Nov 2001 | 18 Jul 2006 | Ncr Corp. | Row hash match scan in a partitioned database system |

US7761458 | 20 Jul 2010 | Hewlett-Packard Development Company, L.P. | Segmentation of a data sequence | |

US7797323 | 14 Sep 2010 | Hewlett-Packard Development Company, L.P. | Producing representative hashes for segments of a file | |

US7814078 | 20 Jun 2005 | 12 Oct 2010 | Hewlett-Packard Development Company, L.P. | Identification of files with similar content |

US7856437 | 31 Jul 2007 | 21 Dec 2010 | Hewlett-Packard Development Company, L.P. | Storing nodes representing respective chunks of files in a data store |

US7895666 | 22 Feb 2011 | Hewlett-Packard Development Company, L.P. | Data structure representation using hash-based directed acyclic graphs and related method | |

US20030026020 * | 31 Jul 2001 | 6 Feb 2003 | Buckingham Jonathan Peter | Data storage |

US20030066010 * | 28 Sep 2001 | 3 Apr 2003 | Acton John D. | Xor processing incorporating error correction code data protection |

US20030074341 * | 11 Oct 2001 | 17 Apr 2003 | International Business Machines Corporation | Method and system for dynamically managing hash pool data structures |

US20060023596 * | 28 Jul 2005 | 2 Feb 2006 | Akihito Ogawa | Information recording medium, information recording/reproducing apparatus and information management method |

US20060106857 | 12 Nov 2004 | 18 May 2006 | Lillibridge Mark D | Method and system for assured document retention |

US20060116989 * | 17 Jun 2005 | 1 Jun 2006 | Srikanth Bellamkonda | Efficient data aggregation operations using hash tables |

US20060152636 * | 20 Oct 2004 | 13 Jul 2006 | Matsushita Electric Industrial Co | Multimedia data recording apparatus, monitor system, and multimedia data recording method |

US20060235903 * | 20 Jan 2006 | 19 Oct 2006 | Rajesh Kapur | Method and system for retrieving deleted and overwritten documents |

US20070005627 * | 9 Jun 2006 | 4 Jan 2007 | Dan Dodge | File system having transaction record coalescing |

US20070286194 * | 9 Jun 2006 | 13 Dec 2007 | Yuval Shavitt | Method and Device for Processing Data Packets |

US20080016576 * | 30 Aug 2005 | 17 Jan 2008 | Sony Corporation | Information Processing Apparatus, Information Storage Medium, Content Management System, Data Processing Method, And Computer Program |

Non-Patent Citations

Reference | ||
---|---|---|

1 | A.Z. Broder et al., "Min-Wise Independent Permutations," pp. 1-36 (1998). | |

2 | Eshghi et al., HP, A Framework for Analyzing and Improving Content-Based Chunking Algorithms, 2005 (11 pages). | |

3 | Little et al., The Computer Journal, vol. 45, No. 6, 2002, Using Bloom Filters to Speed-up Name Lookup in Distributed Systems (8 pages). | |

4 | Wikipedia, Hash Function, Jul. 2006 (4 pages). |

Classifications

U.S. Classification | 707/695, 711/216, 707/825 |

International Classification | G06F7/00, G06F17/00 |

Cooperative Classification | G06F17/3033 |

European Classification | G06F17/30S2P5 |

Legal Events

Date | Code | Event | Description |
---|---|---|---|

29 Jul 2009 | AS | Assignment | Owner name: HEWLETT-PACKARD DEVELOPMENT COMPANY, L.P.,TEXAS Free format text: ASSIGNMENT OF ASSIGNORS INTEREST;ASSIGNORS:DEOLALIKAR, VINAY;ESHGHI, KAVE;SIGNING DATES FROM 20080228 TO 20080304;REEL/FRAME:023025/0016 Owner name: HEWLETT-PACKARD DEVELOPMENT COMPANY, L.P., TEXAS Free format text: ASSIGNMENT OF ASSIGNORS INTEREST;ASSIGNORS:DEOLALIKAR, VINAY;ESHGHI, KAVE;SIGNING DATES FROM 20080228 TO 20080304;REEL/FRAME:023025/0016 |

18 Jun 2013 | CC | Certificate of correction | |

27 Oct 2015 | FPAY | Fee payment | Year of fee payment: 4 |

9 Nov 2015 | AS | Assignment | Owner name: HEWLETT PACKARD ENTERPRISE DEVELOPMENT LP, TEXAS Free format text: ASSIGNMENT OF ASSIGNORS INTEREST;ASSIGNOR:HEWLETT-PACKARD DEVELOPMENT COMPANY, L.P.;REEL/FRAME:037079/0001 Effective date: 20151027 |

Rotate