A portion of the disclosure of this patent document contains material which is subject to copyright protection. The copyright owner has no objection to the facsimile reproduction by anyone of the patent document of the patent disclosure as it appears in the United States Patent and Trademark Office patent file or records, but otherwise, reserves all copyright rights whatsoever. The following notice applies to the software and data and described below, inclusive of the drawing figures where applicable: Copyright©2000, Avamar Technologies.
The present invention relates, in general, to the field of systems and methods for the unorchestrated determination of data sequences using “sticky byte” factoring to determine breakpoints in digital sequences. More particularly, the present invention relates to an efficient and effective method of dividing a data set into pieces that generally yields near optimal commonality.
Modern computer systems hold vast quantities of data—on the order of a billion, billion bytes in aggregate. Incredibly, this volume tends to quadruple each year and even the most impressive advances in computer mass storage architectures cannot keep pace.
The data maintained in most computer mass storage systems has been observed to have the following interesting characteristics: 1) it is almost never random and is, in fact, highly redundant; 2) the number of unique sequences in this data sums to a very small fraction of the storage space it actually occupies; 3) a considerable amount of effort is required in attempting to manage this volume of data, with much of that being involved in the identification and removal of redundancies (i.e. duplicate files, old versions of files, purging logs, archiving etc.); and 4) large amounts of capital resources are dedicated to making unnecessary copies, saving those copies to local media and the like.
A system that factored redundant copies would reduce the number of storage volumes otherwise needed by orders of magnitude. However, a system that factors large volumes of data into their common sequences must employ a method by which to determine those sequences. Conventional methods that attempt to compare one data sequence to another typically suffer from extreme computational complexity and these methods can, therefore, only be employed to factor relatively small data sets. Factoring larger data sets is generally only done using simplistic methods such as using arbitrary fixed sizes. These methods factor poorly under many circumstances and the efficient factoring of large data sets has long been a persistent and heretofore intractable problem in the field of computer science.
Disclosed herein is a system and method for unorchestrated determination of data sequences using “sticky byte” factoring to determine breakpoints in digital sequences such that common sequences can be identified. Sticky byte factoring provides an efficient method of dividing a data set into pieces that generally yields near optimal commonality. As disclosed herein, this may be effectuated by employing a hash function with periodic reset of the hash value or, in a preferred embodiment, a rolling hashsum. Further, in the particular exemplary embodiment disclosed herein, a threshold function is utilized to deterministically set divisions in a digital or numeric sequence, such as a sequence of data. Both the rolling hash and the threshold function are designed to require minimal computation. This low overhead makes it possible to rapidly partition a data sequence for presentation to a factoring engine or other applications that prefer subsequent synchronization across the entire data set.
Among the significant advantages of the system and method disclosed herein is that its calculation requires neither communication nor comparisons (like conventional factoring systems) to perform well. This is particularly true in a distributed environment where, while conventional systems require communication to compare one sequence to another, the system and method of the present invention can be performed in isolation using only the sequence being then considered.
In operation, the system and method of the present invention provides a fully automated means for dividing a sequence of numbers (e.g. bytes in a file) such that common elements may be found on multiple related and unrelated computer systems without the need for communication between the computers and without regard to the data content of the files. Broadly, what is disclosed herein is a system and method for a data processing system which includes a fully automated means to partition a sequence of numeric elements (i.e. a sequence of bytes) so that common sequences may be found without the need for searching, comparing, communicating or coordinating with other processing elements in the operation of finding those sequences. The system and method of the present invention produces “sticky byte” points that partition numeric sequences with a distribution that produces subsequences of the type and size desired to optimize commonality between partitions.
The aforementioned and other features and objects of the present invention and the manner of attaining them will become more apparent and the invention itself will be best understood by reference to the following description of a preferred embodiment taken in conjunction with the accompanying drawings, wherein:
The present invention is illustrated and described in terms of a distributed computing environment such as an enterprise computing system using public communication channels such as the Internet. However, an important feature of the present invention is that it is readily scaled upwardly and downwardly to meet the needs of a particular application. Accordingly, unless specified to the contrary the present invention is applicable to significantly larger, more complex network environments as well as small network environments such as conventional LAN systems.
With reference now to
A “network” comprises a system of general purpose, usually switched, physical connections that enable logical connections between processes operating on nodes 18. The physical connections implemented by a network are typically independent of the logical connections that are established between processes using the network. In this manner, a heterogeneous set of processes ranging from file transfer, mail transfer, and the like can use the same physical network. Conversely, the network can be formed from a heterogeneous set of physical network technologies that are invisible to the logically connected processes using the network. Because the logical connection between processes implemented by a network is independent of the physical connection, internetworks are readily scaled to a virtually unlimited number of nodes over long distances.
In contrast, internal data pathways such as a system bus, peripheral component interconnect (“PCI”) bus, Intelligent Drive Electronics (“IDE”) bus, small computer system interface (“SCSI”) bus, and the like define physical connections that implement special-purpose connections within a computer system. These connections implement physical connections between physical devices as opposed to logical connections between processes. These physical connections are characterized by limited distance between components, limited number of devices that can be coupled to the connection, and constrained format of devices that can be connected over the connection.
In a particular implementation of the present invention, storage devices may be placed at nodes 18. The storage at any node 18 may comprise a single hard drive, or may comprise a managed storage system such as a conventional RAID device having multiple hard drives configured as a single logical volume. Significantly, the present invention manages redundancy operations across nodes, as opposed to within nodes, so that the specific configuration of the storage within any given node is less relevant. Optionally, one or more of the nodes 18 may implement storage allocation management (“SAM”) processes that manage data storage across nodes 18 in a distributed, collaborative fashion. SAM processes preferably operate with little or no centralized control for the system as whole. SAM processes provide data distribution across nodes 18 and implement recovery in a fault-tolerant fashion across network nodes 18 in a manner similar to paradigms found in RAID storage subsystems.
However, because SAM processes operate across nodes rather than within a single node or within a single computer, they allow for greater fault tolerance and greater levels of storage efficiency than conventional RAID systems. For example, SAM processes can recover even when a network node 18, LAN 16, or WAN 14 becomes unavailable. Moreover, even when a portion of the Internet backbone 12 becomes unavailable through failure or congestion the SAM processes can recover using data distributed on nodes 18 that remain accessible. In this manner, the present invention leverages the robust nature of internetworks to provide unprecedented availability, reliability, fault tolerance and robustness.
With reference additionally now to
Internet-based network 120 comprises a set of logical connections, some of which are made through Internet 118, between a plurality of internal networks 122. Conceptually, Internet-based network 120 is akin to a WAN 14 (
Similarly, internal networks 122 are conceptually akin to LANs 16 (
Each internal network 122 connects one or more redundant arrays of independent nodes (RAIN) elements 124 to implement RAIN nodes 18 (
In a particular exemplary implementation, the RAIN elements 124 may comprise computers using commodity components such as Intel-based microprocessors mounted on a motherboard supporting a PCI bus and 256 megabytes of random access memory (“RAM”) housed in a conventional AT or ATX case. SCSI or IDE controllers may be implemented on the motherboard and/or by expansion cards connected to the PCI bus. Where the controllers are implemented only on the motherboard, a PCI expansion bus may be optionally used. In a particular implementation, the motherboard may implement two mastering EIDE channels and a PCI expansion card which is used to implement two additional mastering EIDE channels so that each RAIN element 124 includes up to four or more EIDE hard disks. In the particular implementation, each hard disk may comprise an 80 gigabyte hard disk for a total storage capacity of 320 gigabytes or more per RAIN element. The hard disk capacity and configuration within RAIN elements 124 can be readily increased or decreased to meet the needs of a particular application. The casing also houses supporting mechanisms such as power supplies and cooling devices (not shown).
Each RAIN element 124 executes an operating system. In a particular implementation, a UNIX or UNIX variant operating system such as Linux may be used. It is contemplated, however, that other operating systems including DOS, Microsoft Windows, Apple Macintosh OS, OS/2, Microsoft Windows NT and the like may be equivalently substituted with predictable changes in performance. The operating system chosen forms a platform for executing application software and processes, and implements a file system for accessing mass storage via the hard disk controller(s). Various application software and processes can be implemented on each RAIN element 124 to provide network connectivity via a network interface using appropriate network protocols such as User Datagram Protocol (“UDP”), Transmission Control Protocol (TCP), Internet Protocol (IP) and the like.
With reference additionally now to
The process 200 begins by entry of a computer file data 202 (e.g. “File A”) into the hash file system (“HFS”) of the present invention upon which a hash function is performed at step 204. The data 206 representing the hash of File A is then compared to the contents of a set containing hash file values at decision step 208. If the data 206 is already in the set, then the file's hash value is added to a hash recipe at step 210. This hash recipe consists of the data and associated structures needed to reconstruct a file, directory, volume, or entire system depending on the class of computer file data entered into the system. The contents of the set 212 comprising hash values and corresponding data is provided in the form of existing hash values 214 for the comparison operation of decision step 208. On the other hand, if the hash value for File A is not currently in the set, the file is broken into hashed pieces (as will be more fully described hereinafter) at step 216.
With reference additionally now to
The file data 302 is divided into pieces based on commonality with other pieces in the system or the likelihood of pieces being found to be in common in the future at step 304. The results of the operation of step 304 upon the file data 302 is, in the representative example shown, the production of five file pieces 306 denominated A1 through A5 inclusively. Each of the file pieces 306 is then operated on at step 308 by placing it through individual hash function operations to assign a probabilistically unique number to each of the pieces 306 A1 through A5. The result of the operation at step 308 is that each of the pieces 306 (A1 through A5) has an associated, probabilistically unique hash value 310 (shown as A1 Hash through A5 Hash respectively). The file division process of step 304 is described in greater detail hereinafter in conjunction with the unique “sticky byte” operation also disclosed herein.
With reference additionally now to
With reference additionally now to
With reference additionally now to
With reference additionally now to
With reference additionally now to
The representation 800 illustrates the tremendous commonality of recipes and data that gets reused at every level. The basic structure of the hash file system of the present invention is essentially that of a “tree” or “bush” wherein the hash values 806 are used instead of conventional pointers. The hash values 806 are used in the recipes to point to the data or another hash value that could also itself be a recipe. In essence then, recipes can point to other recipes that point to still other recipes that ultimately point to some specific data that may, itself, point to other recipes that point to even more data, eventually getting down to nothing but data.
With reference additionally now to
The diagram 900 illustrates how the front portion 904 of the hash value 902 data structure may be used to indicate the hash prefix to stripe identification (“ID”) 908 and how that is, in turn, utilized to map the stripe ID to IP address and the ID class to IP address 910. In this example, the “S2” indicates stripe 2 of index Node 37912. The index stripe 912 of Node 37 then indicates stripe 88 of data Node 73 indicated by the reference numeral 914. In operation then, a portion of the hash value 902 itself may be used to indicate which node in the system contains the relevant data, another portion of the hash value 902 may be used to indicate which stripe of data at that particular node and yet another portion of the hash value 902 to indicate where within that stripe the data resides. Through this three step process, it can rapidly be determined if the data represented by the hash value 902 is already present in the system.
With reference additionally now to
With reference additionally now to
The illustration 1100 shows the details of how a computer file system may be broken into pieces and then listed as a series of recipes on a global data protection network (“gDPN”) to reconstruct the original data from the pieces. This very small computer system is shown in the form of a “snapshot” on “Day 1” and then subsequently on “Day 2”. On “Day 1”, the “program files H5” and “my documents H6” are illustrated by numeral 1106, with the former being represented by a recipe 1108 wherein a first executable file is represented by a hash value H11114 and a second represented by a hash value H21112. The document files are represented by hash value H61110 with the first document being represented by hash value H31118 and the second by hash value H41116. Thereafter on “Day 2”, the “program files H5” and “my documents” H10 indicated by numeral 1120 show that the “program files H5” have not changed, but the “my document H10” have. H10 indicated by numeral 1122 shows the “X.doc” is still represented by hash value H31118 while “Y.doc” is now represented by hash value H8 at number 1124. New document file “Z.doc” is now represented by hash value H9 at numeral 1126.
In this example, it can be seen that on Day 2, some of the files have changed, while others have not. In the files that have changed, some of the pieces of them have not changed while other pieces have. Through the use of the hash file system of the present invention, a “snap shot” of the computer system can be made on Day 1 (producing the necessary recipes for reconstruction of the computer files as they exist then) and then on Day 2 through the reuse of some of the previous day's recipes together with the reformulation of others and the addition of new ones to describe the system at that time. In this manner, the files that together constitute the computer system may be recreated in their entirety at any point in time on Day 1 and Day 2 for which a snapshot was taken, as well as from snapshots taken on any subsequent day. Thus any version of a computer file committed to the hash file system of the current invention can be retrieved from the system at any time after it has been initially committed.
With reference additionally now to
With reference additionally now to
A data object 1304, comprising the contents of an input computer file, is acted upon at step 1306 wherein a character from the input file source is read. At step 1308, the character read at step 1306 is utilized to index an array of 32 bit values (this size array is described for purposes of example only). Thereafter, at step 1310, the indexed 32 bit value found at step 1308 is exclusive OR'd (“XOR'd”) into the current 32 bit hash value.
At decision step 1312, if the predetermined pattern is found (e.g. a selected number of least significant bit “0's”), then the sticky byte is placed in the input file at that point at step 1314. In some embodiments, eleven bits are used for the least significant bits or endmost bits of the predetermined numeric pattern, and in these embodiments, the eleven bits may be “0”. In some cases, the method 1300 includes, as explained below, establishing a second predetermined numeric pattern when the threshold is met. The second predetermined numeric pattern may be a bit pattern which is a subset of the first predetermined pattern. In specific examples of the method 1300, the first numeric pattern may include a consecutive sequence of eleven bits while the second numeric pattern may include ten of the eleven bits of the first numeric pattern. For example, the first numeric pattern may include eleven consecutive “0”'s and the second numeric pattern may include ten consecutive “0”'s. If the predetermined pattern is not found at decision step 1312, then, at decision step 1316, a determination is made as to whether a predetermined threshold number of characters in the input file (having been operated on by the rolling hash function of process 1300, as will be more fully described hereinafter) has been exceeded. If the predetermined threshold number has been exceeded, then the process 1300 proceeds to decision step 1318 to see if some subset number of the predetermined pattern (e.g. a smaller selected number of least significant bit “0's”) being searched for in decision step 1312 has been found. If so, then the sticky byte is placed at step 1314. In some embodiments, the hash function is selected to produce preferential hashsums that do not uniformly cover the range of the possible output values. In other cases, the hash function is selected or modified dynamically during the execution of the hash function. In yet other cases, the hash function includes the relative or absolute value of the current location as an input value in the hash function resulting in hash values that are affected by the relative or absolute value of the current location.
Alternatively, if at decision step 1316 the predetermined threshold has not been exceeded, the process 1300 proceeds to step 1320 wherein the existing 32 bit hash value is shifted over one bit position (either “right” or “left”). At decision step 1322, if there is still another character to be operated upon by the process 1300, a next character in the input file source is read at step 1306. If at decision step 1318, the subset of the predetermined pattern is not found, or at step 1314 the sticky byte has been placed, the process proceeds to step 1320 as previously described.
Data sticky bytes (or “sticky points”) are a unique, fully automated way to sub-divide computer files such that common elements may be found on multiple related and unrelated computers without the need for communication between the computers. The means by which data sticky points are found is completely mathematical in nature and performs equally well regardless of the data content of the files. Through the use of a hash file system, all data objects may be indexed, stored and retrieved using, for example, but not limited to an industry standard checksum such as: MD4, MD5, SHA, or SHA-1. In operation, if two files have the same checksum, it may be considered to be highly likely that they are the same file. Using the system and method disclosed herein, data sticky points may be produced with a standard mathematical distribution and with standard deviations that are a small percentage of the target size.
A data sticky point is a statistically infrequent arrangement of n bytes. In this case, an example is given with 32 bits because of its ease in implementation for current 32-bit oriented microprocessor technology. While the hashing function utilized to implement the hash file system requires a moderately complex computation, it is well within the capability of present day computer systems. Hashing functions are inherently probabilistic and any hashing function can produce the same results for two different data objects. However, the system and method herein disclosed mitigates this problem by using well known and researched hashing functions that reduce the probability of collision down to levels acceptable for reliable use (i.e. one chance in a trillion trillion), far less than the error rates otherwise tolerated in conventional computer hardware operation.
For purposes of more fully explaining the sticky byte factoring system of the present invention, the following definitions pertain:
Rolling Hash:
A rolling hash function preserves the essential nature of a normal hash function but is designed to have limited memory of its input values. Specifically it is a hash function with these properties:
1. It has a fixed or variable length window (sequence length).
2. It produces the same value given the same window of data; that is, it is deterministic. Ideally the hashsums produced uniformly span the entire range of legal values.
3. Its hashsum is unaffected by the data either before or after the window.
In a particular implementation of the present invention, a 32-bit rolling hash function may be used. Its general operation is: 1) shift the existing 32-bit hash value over one bit (either left or right); 2) read a character from the input file source; 3) use that character to index an array of 32-bit values; and 4) XOR the indexed 32-bit value into the current 32-bit hash. The operation then repeats.
The rolling hash value then remains a 32-bit value and all 32 bits are affected by the XOR operation. In the shifting phase, one of the bits is moved out of the rolling hash “window” leaving the remaining 31 bits moved over one place but otherwise unchanged. The effect of this is to move the window over one unit.
It should be noted that a 64-bit (or other size) rolling hashes may be used although the additional computational effort may not be required in the determination of “sticky bytes” since only a small number of bits are generally used by many applications, e.g. some number of the least significant “0”'s. For a 32-bit number, the maximum number of zeros is, of course, 32, which would occur only once every 4 billion characters on average—assuming the function utilized produces well distributed numbers. Four billion characters is approximately four gigabytes of data; a large “chunk”. Using 64-bit hash values would aid in producing even larger chunk sizes, but since the particular implementation of the present invention herein disclosed uses about a 2K chunk size, the full range of a 32-bit rolling hash is seldom required.
Consider the following C language example, wherein: “f” is an array of bytes, “i” is the index into that array, and “hash” is the hashsum being computed. A simple rolling hash might be written as:
hash=(hash<<1)|f[i];
This hash can be improved by including a second array “scramble” indexed by the input byte values (0 through 255) which produces large randomized integer values:
hash=(hash>>1)|scramble[f[i]];
This example of a rolling hash function produces fairly uniform numbers across the range of 32 bit values.
Threshold Function:
A threshold function performs a calculation to determine whether a value is above or below a given level. This action produces discontinuous results, placing some values above and others below the threshold. It may optionally perform some transformation on its input value. As an example:
threshold_value=(hash−1) ^ hash;
or:
threshold_value=((hash−1) ^ hash)+length;
The system and method of the present invention for sticky byte factoring advantageously partitions data sets into sequences that promote commonality. The ensuing example, is illustrative of a preferred implementation utilizing a 32-bit rolling hash together with a threshold function which may be carried out particularly well with modern 32-bit microprocessors.
A rolling hash of 32 bits is generated using the byte array “f” as the input sequence to be partitioned where:
The system and method of the present invention steps sequentially through a sequence of values and calculates a rolling hashsum value. That hashsum value at index “i” is dependent only on the bytes at indexes i-31 through i. In the case of i being less than 31, the hashsum reflects the values for the bytes between 0 and i. Assuming an input text in “f” that uses a large range of byte values and a well chosen set of randomizing values present in “scramble”, the hashsum will produce a well-distributed range of values, that largely and uniformly spans the desired 32-bit numeric range. While it should be noted that some byte sequences do not produce well-distributed numbers, byte sequences having this behavior should be uncommon for typical input texts.
The “sticky_bits” value is calculated using the current hashsum. This value is designed to have a highly non-uniform distribution and to produce numbers that span the entire range of 32-bit values, with larger values being produced in inverse proportion to their magnitude as illustrated in the following Table 1:
Without further modification, this particular example demonstrates the statistical property of having sequence lengths with a standard deviation that are 95% of their mean. In order to compensate for this, the “sticky_bits” value can be combined with the length of the current sequence to produce partitions more evenly spaced. In this regard, “sticky_weighting” is a factor that is used to adjust the weight of the “sticky_bits” value versus the length of the current partition.
sticky_weighting+(i−last_sticky_point)
In this particular embodiment of the system and method of the present invention, an adjustment has been made to produce more consistent partition sizes. This is effectuated by essentially increasing the “pressure” on the threshold to create a partition as the potential partition size increases. It should be noted that any number of a variety of methods for effectuating this end might be employed and the foregoing example is intended to illustrate but one.
As will be appreciated, the system and method of the present invention for unorchestrated determination of data sequences disclosed herein provides an efficient and readily effectuated means to factor large volumes of data into their common sequences using modern computer processors. Unlike conventional factoring techniques, it requires no sequence comparisons, communication, or historical record of previous actions in order to establish commonality. Further, the system and method of the present invention is essentially immune to the type of data being partitioned and it performs consistently on text files, binary files, set images, audio and video clips, still images and the like.
The sticky byte factoring technique disclosed herein also advantageously creates partitions that tend to identify commonality even when that commonality lies in variable locations within a sequence; for example, while the difference between two versions of a particular document file might be only minor, sticky byte factoring nevertheless produces a high commonality between the factored documents despite the insertion or deletion of characters. Moreover, the system and method of the present invention creates partitions, or breakpoints, that tend to identify commonality in data that “slides”, or changes its absolute location.
In essence, the system and method of the present invention effectively solves the problem of how to locate common data sequences quickly and efficiently. Further, it can be used to search for alternative encodings of a sequence of data that would have a higher likelihood of being present in a system designed to store information based on such a partitioning scheme. The sticky byte factoring technique of the present invention performs particularly well when searching for common sequences in typical computer file systems and produces much higher compression ratios for some test suites than even the best known compression algorithms, many of which exploit commonality factoring as their fundamental file size reduction technique.
Although as used herein, the term “Internet infrastructure” encompasses a variety of hardware and software mechanisms, the term primarily refers to routers, router software, and physical links between these routers that function to transport data packets from one network node to another. As also used herein, a “digital sequence” may comprise, without limitation, computer program files, computer applications, data files, network packets, streaming data such as multimedia (including audio and video), telemetry data and any other form of data which can be represented by a digital or numeric sequence.
While there have been described above the principles of the present invention in conjunction with specific exemplary sticky byte factoring techniques and computer systems, it is to be clearly understood that the foregoing description is made only by way of example and not as a limitation to the scope of the invention. Particularly, it is recognized that the teachings of the foregoing disclosure will suggest other modifications to those persons skilled in the relevant art. Such modifications may involve other features which are already known per se and which may be used instead of or in addition to features already described herein. Although claims have been formulated in this application to particular combinations of features, it should be understood that the scope of the disclosure herein also includes any novel feature or any novel combination of features disclosed either explicitly or implicitly or any generalization or modification thereof which would be apparent to persons skilled in the relevant art, whether or not such relates to the same invention as presently claimed in any claim and whether or not it mitigates any or all of the same technical problems as confronted by the present invention. The applicants hereby reserve the right to formulate new claims to such features and/or combinations of such features during the prosecution of the present application or of any further application derived therefrom.
This application is a continuation of U.S. application Ser. No. 09/777,149 now U.S. Pat. No. 6,810,398, filed Feb. 5, 2001, and issued Oct. 26, 2004, which claims priority from U.S. Provisional Application No. 60/245,920, filed Nov. 6, 2000, the disclosures of which are herein specifically incorporated by this reference.
Number | Name | Date | Kind |
---|---|---|---|
3668647 | Evangelisti et al. | Jun 1972 | A |
4215402 | Mitchell et al. | Jul 1980 | A |
4404676 | DeBenedictis | Sep 1983 | A |
4649479 | Advani et al. | Mar 1987 | A |
4761785 | Clark et al. | Aug 1988 | A |
4887204 | Johnson et al. | Dec 1989 | A |
4887235 | Holloway et al. | Dec 1989 | A |
4897781 | Chang et al. | Jan 1990 | A |
4901223 | Rhyne | Feb 1990 | A |
4929946 | O'Brien et al. | May 1990 | A |
4982324 | McConaughy et al. | Jan 1991 | A |
5005122 | Griffin et al. | Apr 1991 | A |
5018060 | Gelb et al. | May 1991 | A |
5089958 | Horton et al. | Feb 1992 | A |
5109515 | Laggis et al. | Apr 1992 | A |
5133065 | Cheffetz et al. | Jul 1992 | A |
5146568 | Flaherty et al. | Sep 1992 | A |
5155835 | Belsan | Oct 1992 | A |
5162986 | Graber et al. | Nov 1992 | A |
5163148 | Walls | Nov 1992 | A |
5210866 | Milligan et al. | May 1993 | A |
5218695 | Noveck et al. | Jun 1993 | A |
5239637 | Davis et al. | Aug 1993 | A |
5239647 | Anglin et al. | Aug 1993 | A |
5239659 | Rudeseal et al. | Aug 1993 | A |
5263154 | Eastridge et al. | Nov 1993 | A |
5276860 | Fortier et al. | Jan 1994 | A |
5276867 | Kenley et al. | Jan 1994 | A |
5278838 | Ng et al. | Jan 1994 | A |
5305389 | Palmer | Apr 1994 | A |
5317728 | Tevis et al. | May 1994 | A |
5325505 | Hoffecker et al. | Jun 1994 | A |
5347653 | Flynn et al. | Sep 1994 | A |
5355453 | Row et al. | Oct 1994 | A |
5367637 | Wei | Nov 1994 | A |
5367698 | Webber et al. | Nov 1994 | A |
5379418 | Shimazaki et al. | Jan 1995 | A |
5403639 | Belsan et al. | Apr 1995 | A |
5404508 | Konrad et al. | Apr 1995 | A |
5404527 | Irwin et al. | Apr 1995 | A |
5448718 | Cohn et al. | Sep 1995 | A |
5452440 | Salsburg | Sep 1995 | A |
5452454 | Basu | Sep 1995 | A |
5454099 | Myers et al. | Sep 1995 | A |
5479654 | Squibb | Dec 1995 | A |
5485474 | Rabin | Jan 1996 | A |
5487160 | Bemis | Jan 1996 | A |
5497483 | Beardsley et al. | Mar 1996 | A |
5513314 | Kandasamy et al. | Apr 1996 | A |
5515502 | Wood | May 1996 | A |
5521597 | Dimitri | May 1996 | A |
5524205 | Lomet et al. | Jun 1996 | A |
5532694 | Mayers et al. | Jul 1996 | A |
5535407 | Yanagawa et al. | Jul 1996 | A |
5544320 | Konrad | Aug 1996 | A |
5559991 | Kanfi | Sep 1996 | A |
5574906 | Morris | Nov 1996 | A |
5586322 | Beck et al. | Dec 1996 | A |
5604862 | Midgely et al. | Feb 1997 | A |
5606719 | Nichols et al. | Feb 1997 | A |
5608801 | Aiello et al. | Mar 1997 | A |
5640561 | Satoh et al. | Jun 1997 | A |
5649196 | Woodhill et al. | Jul 1997 | A |
5659743 | Adams et al. | Aug 1997 | A |
5659747 | Nakajima | Aug 1997 | A |
5696901 | Konrad | Dec 1997 | A |
5742811 | Agrawal et al. | Apr 1998 | A |
5751936 | Larson et al. | May 1998 | A |
5754844 | Fuller | May 1998 | A |
5765173 | Cane et al. | Jun 1998 | A |
5771354 | Crawford | Jun 1998 | A |
5778395 | Whiting et al. | Jul 1998 | A |
5794254 | McClain | Aug 1998 | A |
5802264 | Chen et al. | Sep 1998 | A |
5802297 | Engquist | Sep 1998 | A |
5909677 | Broder et al. | Jun 1999 | A |
5933104 | Kimura | Aug 1999 | A |
5978791 | Farber et al. | Nov 1999 | A |
5990810 | Williams | Nov 1999 | A |
6014676 | McClain | Jan 2000 | A |
6016553 | Schneider et al. | Jan 2000 | A |
6029168 | Frey | Feb 2000 | A |
6044220 | Breternitz, Jr. | Mar 2000 | A |
6085298 | Ohran | Jul 2000 | A |
6122754 | Litwin et al. | Sep 2000 | A |
6141421 | Takaragi et al. | Oct 2000 | A |
6230155 | Broder et al. | May 2001 | B1 |
6268809 | Saito | Jul 2001 | B1 |
6307487 | Luby | Oct 2001 | B1 |
6320520 | Luby | Nov 2001 | B1 |
6374250 | Ajtai et al. | Apr 2002 | B2 |
6611213 | Bentley et al. | Aug 2003 | B1 |
6667700 | McCanne et al. | Dec 2003 | B1 |
6704730 | Moulton et al. | Mar 2004 | B2 |
6810398 | Moulton | Oct 2004 | B2 |
6828925 | McCanne et al. | Dec 2004 | B2 |
6961009 | McCanne et al. | Nov 2005 | B2 |
7116249 | McCanne et al. | Oct 2006 | B2 |
20010037323 | Moulton et al. | Nov 2001 | A1 |
20020010797 | Moulton | Jan 2002 | A1 |
20020152218 | Moulton | Oct 2002 | A1 |
20040148306 | Moulton et al. | Jul 2004 | A1 |
20050091234 | Hsu et al. | Apr 2005 | A1 |
Number | Date | Country |
---|---|---|
PCTAU9600081 | Aug 1996 | WO |
Number | Date | Country | |
---|---|---|---|
20040225655 A1 | Nov 2004 | US |
Number | Date | Country | |
---|---|---|---|
60245920 | Nov 2000 | US |
Number | Date | Country | |
---|---|---|---|
Parent | 09777149 | Feb 2001 | US |
Child | 10861796 | US |