JP4939421B2 - System and method for retrieving and storing data - Google Patents

Abstract

A method comprising identifying input data in repository data wherein the repository data comprises repository data chunks and the input data comprise input data chunks and wherein each repository data chunk has a corresponding set of repository data chunk distinguishing characteristics, each distinguishing characteristic being stored with an RDC characteristic location, the method including the steps of, for each input data chunk: determining a set of input data chunk distinguishing characteristics, each distinguishing characteristic having an IDC characteristic location; then comparing the determined set of IDCs to one or more sets of RDCs; identifying a repository data chunk that is similar to the input data chunk as a function of the comparing of the determined set of IDCs to the one or more sets of RDCs, wherein a repository data chunk is identified as similar when a predetermined number of the distinguishing characteristics in the set of IDCs is found to match in a set of RDCs; outputting the IDC and RDC locations of at least one pair of matching IDC and RDC; and computing at least one common section of the input data chunk and the identified similar repository data chunk using the at least one pair of matching IDC and RDC as an anchor to define corresponding intervals in the input data chunk and the identified similar repository data chunk.

Description

  The present invention relates to a system and method for searching for data to identify stored data and efficiently storing new data based on the stored data. These systems and methods are useful for creating and maintaining large data repositories in backup and restore systems as an example.

  Efficient storage of large amounts of data, both in terms of time and space, is of primary concern in backup and restore systems, especially designs that must store large amounts of digital data. For example, a user or group of users periodically (eg, daily or weekly) store all data stored in one (or more) computers as a precaution against possible destruction, alteration or accidental loss of important data. ) May want to back up. Most data does not change more than 99% since the last backup, and thus most of the current data can be detected in the repository as soon as possible with very little change. If this data in the repository, similar to the current backup data, can be located efficiently, then it is not necessary to store the data again, but rather only record the changes. This process of storing common data only once is known as data factoring.

  A large backup and restore system that performs factoring will have more than 1 petabyte (PB) in its repository. For example, banks that record business transactions performed by customers and Internet service providers that store multi-user e-mail typically have repository sizes ranging from hundreds of gigabytes to petabytes. Recall that 1PB = 1024TB (terabyte), 1TB = 1024GB (gigabyte), 1GB = 1024MB (megabyte), 1MB = 1024KB (kilobyte), 1KB = 1024 bytes. In other words, a petabyte (PB) is 250 bytes, or about 1015 bytes.

  In this type of large system, the input (backup) data stream added to the repository is, for example, 100 GB or more at the maximum. This input data is very likely to be similar to existing data in the repository, but is not exactly the same. Furthermore, the backup data stream will not be placed on the same data boundary (eg, block alignment) as the existing data in the repository. In order to make the subsequent factoring step more efficient, the backup and restore system can reconstruct data in the repository that is sufficiently similar to the input stream without resorting to any relative arrangement of the data in the repository and the data in the input stream. It must be possible to detect the position efficiently. The backup and restore system must also efficiently add input streams to the repository and remove deleted or destroyed old input streams from the repository.

  In general, data changes can be assumed to be local. Thus, for example, if 1% of the data changes, then this type of change is concentrated in local areas, and there are probably major changes in these areas, while the vast majority of the data areas remain the same. stay. Normally (but not necessarily), for example, if 1% of the data changes, then if the data is viewed as a 512-byte block stream instead of a byte stream, a little over 1% of the block changes It will be done. However, because there is no predetermined alignment of data in the input stream and the repository, detecting localized data changes is an important task.

Searching for similar data is considered an extension of the classical problem of pattern matching, where text T of length n is searched for the appearance of string P of length m. Usually, the text length n is much larger than the search string length m. Many publications have presented a number of search methods that attempt to solve this problem efficiently, testing each position in the text T to determine if the string P appears there. Faster than. By preprocessing the pattern, some algorithms achieve better computational complexity. For example, see below.
Knud D.M. E. And Morris J. et al. H. And Pratt V. R. "Fast Pattern Matching In Strings", SIAM Computing Technical Report, Vol. 6, pp 323-350, 1977,
Boyer R. S. And Moore J. et al. S. "A Fast String Searching Algorithm", ACM Communication, 20, pp 762-772, 1977,
Karp R.D. And Rabin M. et al. Author, “Efficient Randomized Pattern Matching Algorithms” (IBM, R & D Technical Report 31, pp 249-260, 1987)

  All of these algorithms operate within O (n + m) times, which means that the search time increases linearly with the text size. One problem with these algorithms is that they cannot scale beyond certain constraint limits. For example, if 1 GB text (a copy size of about 300 copies of King James Bible) can be performed in 1 second, a search for 1 petabyte text should require more than 12 days in CPU time. Backup and restore systems of 1 petabyte (PB) or more in the repository cannot use this kind of algorithm. Another drawback of the above algorithms is that they publish only exact matches and are not easily extended to perform approximate matches.

Instead of preprocessing patterns, the text itself can be preprocessed to build a data structure known as a subscript tree. This is described in the following publications:
By Weiner P, “Linear Pattern Matching Algorithm”, Proceedings of the 14th IEEE Symposium on Switching and Automata Theory, pp 1-11, 1973,
Ukkonen E.M. “On-Line Construction Of Suffix Trees”, Algorithmic, 14 (3), pp 249-260, 1995.

  If the preprocessing is done offline, the preprocessing time will not be a problem. In that case, a subscript tree can be used to perform subsequent searches within time O (m) (ie, only according to pattern size, not text size). However, only exact matches can be detected here, and the size of the subscript tree is constrained, albeit linear with the size of the text, because it is up to six times larger than the original text. Because it's waxy.

It is desirable to use an approximate pattern matching algorithm for backup and restore, because it is not an exact duplicate of the input data in the repository, but rather a strictly different copy, but still with some kind of definition. This is because it is usually true that very similar things can be detected according to the similarity criterion. Approximate pattern matching has been extensively studied as described below.
Fischer M.M. J and Paterson M.M. S., "String Matching And Other Products, in Complexity of Computation" (string matching and other products in computational complexity) M.M. Karp (edit), SIAM-AMS Lecture, Volume 7, pp113-125, 1974,
Landau G. M.M. And Vishkin U. Author, “Fast Parallel And Serial Appropriate String Matching}, Algorithm Technique, 10 (2), pp157-169, 1989,
Navarro G. Author, “A Guided Tour To Approximate String Matching”, ACM Computation Survey, 33 (1), pp 31-88, 2001.

One recent algorithm works in time O (n (klogk) 1/2), where n is the size of the text and k is the number of allowed mismatches between the pattern and the text. For example, see below.
Amir A. And Lewstein M.M. And Porat E. “Faster Algorithms For String Matching With K Mismatches”, Algorithm Technique, 50 (2), pp 257-275, 2004.

  However, for large data repositories, O (n (klogk) 1/2) is an unacceptable amount of computation. The input data stream to the backup and restore system can be up to 100 GB or longer, for example. Assuming that most identical copies of this input stream exist in the repository, even if only 1% of the data changes, there will still be about 1 GB of difference, ie k = 230 bytes. This algorithm will spend time proportional to approximately 180,000 times the size of text n to find the approximate match location in the repository. This is unacceptable on the assumption that an algorithm that only has a large text length n and scans the text only once can be too slow.

Another algorithm system is based on a hash function. These are known as CAS (Content Addressed Storage) in the storage industry, as described below.
Multon G. H. And Whitehill S. US Pat. No. 6,704,730 by B, “Hash File System And Method For Use In A Commonality Factoring System (Hash File System and Method Used in Commonality Factoring System)”

  The general theoretical framework is as follows. That is, repository data is divided into blocks, and a hash value called a fingerprint or signature is generated for each block. All these hash values are stored in the index. To place some kind of given data called a version, the given input data is also divided into blocks and the same hash function (applied to the repository block) is applied to each version block. If the hash value of the version block is found in the index, a match is published.

  The advantage of CAS over the previous method is that if the search for similar data is now performed on the index rather than on the repository text itself and the index is stored using the appropriate data structure, the search time is significantly reduced. be able to. For example, if the index is stored as a binary tree or a more general B-tree, the search time is only O (log (n / s)), where n is the text size and s is the block size. is there. When the index is stored in the rearrangement list, the interpolated search of the rearrangement list has an expected time of O (log (log (n / s))). If the index is stored in a hash table, the expected time can be reduced to O (1), meaning that the search for the index can be accomplished with a certain expected time, especially within the time independent of the size of the repository text. .

  However, this method has drawbacks. As before, only exact matches are detected, i.e., as long as the block of input data is identical to the block of repository data, a match is published. One of the requirements for a good hash function is that the corresponding hash values will be quite different even if the two blocks differ only slightly, which is necessary to guarantee a good distribution of hash values. It is said. However, in backup and restore applications, this means that if two blocks only approximately match, the hashing scheme will not detect their degree of approximation. A search in the vicinity of the detected hash value does not reveal an approximate match. Furthermore, a published match does not necessarily correspond to an actual match between two blocks. In general, the hash function h is not one-to-one, and thus the normal blocks X and Y may be detected as X ≠ Y and h (X) = h (Y).

  Furthermore, the bandwidth requirements necessary for repository updates and data transmission over the network also present opportunities for improvement.

  These problems create the challenge of how to select the block size s. Choosing a large block size gives a smaller index (because the index needs to store n / s elements), reducing the possibility of mismatches, but detecting matching blocks at the same time The possibility is reduced, which ultimately reduces the compression ratio (assuming that the compression method uses a hash function that stores only non-matching blocks and pointers to matching ones). On the other hand, choosing a small block size may increase overall compression efficiency, but it also increases the possibility of mismatches, requiring a larger index for the larger number of blocks, and the index itself is storage. May be a problem.

  In short, many clever methods have been suggested to deal with these problems, but they all have the disadvantage of not being able to scale in a reasonable amount of time and space for the amount of data in a large data repository. is there.

  The present invention relates to systems and methods for efficient data retrieval and storage and / or reduction. Furthermore, the amount of data transmitted between systems is reduced by performing error-resistant remote differential processing.

  A system and method consistent with an embodiment of the present invention can search a repository of binary untransformed data for data locations similar to input data using a defined similarity measure, and what is the size of the repository? Irrespective of the size of the input data, this can be done in a space that is proportional to a small fraction of the repository size within a linear time.

  The system and method consistent with other embodiments of the present invention further analyzes similar data segments and input data of the repository and determines their common (identical) portions regardless of the order or position of the common data in the repository and input. Efficiently identify and do so in a time that is linear with the segment size and in a constant space.

  The systems and methods according to some embodiments result in a reduction in the amount of network bandwidth used to store data. This system / method eliminates the need to transmit data that already exists at the destination over the network. In one embodiment, the data repository is located at the first location. The second location has new data that it wishes to store in the repository. Compare new data with data already in the repository. Conveniently, not all new data is sent to the repository for comparison, and the data already stored in the repository is sent, possibly without wasting bandwidth, and comparing the repository data with the new data is the entire new data By sending a representation of new data that is much smaller in size, a comparison of the new data to the repository data is achieved with sufficient information that can be used as a basis for identifying similarities or differences.

  In one embodiment, one method includes identification of input data within the repository data, the repository data includes repository data chunks, the input data includes input data chunks, and each repository data chunk identifies one or more repository data chunks. Having a corresponding set of characteristics (RCD), the method specifying, for each input data chunk, one or more input data chunk identification characteristic (IDC) sets; and specifying one or more specified IDC sets Comparing to the RDC set and identifying a repository data chunk similar to the input data chunk as a function of comparing the specified IDC set to one or more RDC sets.

  In one embodiment, the input data is located at a first location, the repository data is located at a remote location, and the method further includes identifying an IDC set for the first location, and identifying the identified IDC set to the first location. Transmitting from one location to a remote location and comparing the identified IDC set with one or more RDC sets at the remote location.

  In another embodiment, the first location is a first computer, the remote location is a remote computer different from the first computer, the first computer and the remote computer are in networked communication with each other, and the repository The data is stored in a data repository that is accessed via a remote computer.

  Identification of the IDC set's similarity to the RDC set is a function of the similarity threshold, which matches when a predetermined number of identification characteristics in the IDC set are detected in the RDC set.

  The identification characteristic set identification includes identifying one or more data portions within the individual data chunk and calculating an arithmetic hash value for each of the one or more data portions of the individual data chunk.

  According to another embodiment of the present invention, a method for searching in repository data for data similar to input data includes splitting repository data into one or more repository chunks and, for each repository chunk, a repository identification characteristic. Calculating a corresponding set of (RDC), wherein each RDC set includes at least one identification characteristic, holding an index associated with each RDC set and a corresponding repository chunk, Dividing the input chunks and calculating a corresponding set of input identification characteristics (IDC) for each input chunk, wherein the IDC set includes at least one identification characteristic, and the IDC set is stored in the index Comparing with one or more RDC sets and identification within the IDC set If sexual similarity threshold j is detected in the RDC set stored in the index, including determining that the similarity exists between the input chunk and the corresponding repository chunk.

  Each of the RDC set and the IDC set is a step of dividing an individual data chunk into a plurality of seeds, a step of arranging each seed in a seed sequence as a small part of the individual data chunk, and applying a hash function to each seed. Generating a plurality of hash values, wherein each seed yields a hash value, selecting a subset of the plurality of hash values, and in a seed sequence corresponding to the selected subset of hash values Specifying the seed position in step, applying the function to the specified position, specifying the corresponding other position in the seed sequence, and defining the identification characteristic set as a hash value of the seed of the specified other position And obtaining a step.

  Another embodiment is a system for identifying input data within repository data, where the repository data includes a repository data chunk, the input data includes an input data chunk, and each repository data chunk has one or more repository data chunk identification characteristics ( RDC) corresponding set, the system specifying one or more input data chunk identification characteristic (IDC) sets for each input data chunk, and a specific IDC set for each input data chunk For each input data chunk, and for each input data chunk, means for identifying a repository data chunk that is similar to the input data chunk as a function that compares the specified IDC set against one or more RDC sets. Prepare.

  In one embodiment, the system further includes means for identifying one or more differences between the input data chunk and the identified similar repository data chunk by comparing all data of the individual chunks for each input data chunk. Including.

  In one embodiment, the identification characteristic set identifying means includes means for identifying one or more data portions in the individual data chunk, and means for calculating an arithmetic hash value for each of the one or more data portions of the individual data chunk. Is provided.

  In another embodiment, the system further comprises means for identifying k maximum arithmetic hash values in the set, said means wherein k is a predetermined number, and a separate data portion for each of the k maximum hash values. And means for identifying an identification characteristic set as an arithmetic hash value of the next sequence data portion for each data portion corresponding to each of the k maximum arithmetic hash values.

  The identification characteristic is specified by one of a hash function and a rolling hash function, and the modular hash function and the RDC set are stored in the index as at least one of a binary tree, a B-tree, a sorted list, and a hash table. .

  A system for searching repository data for data similar to input data, the system having means for dividing the repository data into one or more repository chunks and a corresponding set of repository identification characteristics (RDC) for each repository chunk. Means for calculating said means wherein each RDC set includes at least one identification characteristic; means for holding an index associated with each RDC set and a corresponding repository chunk; and dividing input data into one or more input chunks Means for each input chunk to calculate a corresponding set of input identification characteristics (IDC), the IDC set has at least one identification characteristic, and the IDC set is compared with one or more RDC sets stored in an index RD in which the similarity threshold j of the identification characteristic in the IDC set is stored in the index If it is detected in the set, and a said means for identifying a similarity exists between the input chunk and the corresponding repository chunk.

  Each RDC set and IDC set partition an individual data chunk into a plurality of seeds, arrange each seed as a small part of the individual data chunk in a permutation sequence, and apply a hash function to each seed to generate a plurality of hash values. Each seed yields a hash value, selects a subset of hash values, identifies a seed position within the seed sequence corresponding to the selected subset of hash values, and moves to the specified position. The function is applied to identify the corresponding other position in the seed sequence, and the discriminant characteristic set is obtained by defining the hash value of the seed at the other specified position.

  A subset of hash values is selected by identifying the k largest hash values, and the function applied to locate the corresponding other position is to identify the next seed in the seed sequence.

  In yet another embodiment, a method for identifying input data within repository data, wherein the repository data includes a repository data chunk, the input data includes an input data chunk, and each repository data chunk corresponds to one or more data chunk identifications. A computer-readable medium encoded with computer-executable instructions for causing a computer to execute a method having a characteristic (RDC) set, the method comprising, for each input data chunk, one or more input data chunk identification characteristic (IDC) sets Identifying a specified IDC set with one or more RDC sets, and identifying a repository data chunk similar to the input data chunk as a function that compares the specified IDC set with the one or more RDC sets. Steps.

  In addition, the computer-readable medium encodes with computer-executable instructions that cause the computer to perform a method for retrieving data similar to the input data in the repository data, the method dividing the repository data into one or more repository chunks. Calculating a corresponding set of repository identification characteristics (RDC) for each repository chunk, wherein each RDC set comprises at least one identification characteristic, an index associated with each set of RDCs, and Holding a corresponding repository chunk, dividing the input data into one or more input chunks, calculating a corresponding set of input identification characteristics (IDC) for each input chunk, wherein the IDC set has at least one identification characteristic IDC set in the index Similarity between the input chunk and the corresponding repository chunk if the similarity threshold j of the identification characteristic in the IDC set is detected in the RDC set stored in the index compared to one or more stored RDC sets Identifying that sex is present.

  Furthermore, the computer-readable medium further includes computer-executable instructions for performing the steps of obtaining each of the RDC set and the IDC set according to the following, i.e. partitioning the individual data chunks into a plurality of seeds, each seed of the individual data chunks. Permutation is arranged as a small part in a seed sequence, a hash function is applied to each seed to generate multiple hash values, each seed yields a single hash value, a subset of multiple hash values is selected, and a hash Identifies the seed position in the seed sequence corresponding to the selected subset of values, applies the function to the specified position to identify other positions corresponding to the seed sequence, and identifies the identification characteristic set It is specified as the hash value of the seed at the position of.

  A subset of hash values is selected by identifying the k largest hash values, and the function applied to identify the corresponding other position is to identify the next seed in the seed sequence.

  The accompanying drawings, which are incorporated in and constitute a part of this specification, illustrate various embodiments and aspects of the invention and, together with the description, serve to explain some principles of the invention.

  As used in the following embodiments, a repository is a collection of digital data stored in memory and / or storage for computer reference. The size is not limited and can be on the order of 1 PB or more. For specific applications, the data is stored as binary non-converted data. The input data can be the same or different from the repository data. Input data is also called a version. For specific uses, split the version and repository into chunks. The chunk size m is a parameter such as 32 MB, for example. The term seed refers to a continuous data element such as a byte. The seed size s is also a parameter of eg 512 bytes or (in other non-limiting examples) 4 KB or even 8 KB. In general, the seed size s is much smaller than the chunk size m.

  According to some embodiments of the invention, a hash function is used. The hash function maps a certain kind of large space element to a certain kind of small space element by assigning a numerical value called a hash value to the first space element. A hash function is typically an arithmetic function that uses as input a certain numerical transformation of the basic elements of the first space. A “good” hash function produces a hash value that is almost always statistically unrelated to even the slightest change in the elements of the first space.

  In the following embodiment, a modular hash function is used. However, this use is a non-limiting example. As is well known, a modular hash function is used in a stream that starts after one basic element (and thus overlaps the previous sequence of basic elements) if the hash value of s consecutive basic elements in a stream is known. The hash value of the s basic elements is calculated by O (1) calculation. Thus, all hash values of all seeds in the chunk can be calculated by O (m) calculation instead of O (m · s). Because of this property, the hash function is called a rolling hash function. It should be noted that the present invention is not bound to the use of a specific rolling hash function or a general hash function.

  An index is a data structure that facilitates efficient searching. It must be space efficient. In some applications (such as this embodiment), efficient dynamic operations such as interpolation and erasure must be supported. One index is implemented with a hash table, thus supporting search, interpolation and erasure for each O (1) operation. According to some embodiments of the invention described below, the index is indexed by a key that is a hash value of a seed, and each key value is the seed (or seeds) from which it was generated. Identify

  In FIG. 1, a general purpose storage system architecture according to an embodiment of the present invention is illustrated. Of course, the present invention is not bound to this particular system architecture. In FIG. 1, a storage area network SAN (12) connects four backup servers (11) to a server (13). The server (13) includes a virtual tape interface (14) and a RAM memory (15). The index is stored in the RAM (15). The server (13) is connected to a repository stored in one or more (possibly external) secondary storage devices.

  It should be noted that the present invention is not limited to a storage area network (SAN) and its specific technical features such as Fiber Channel. Those skilled in the art will appreciate that any network technology can be used to facilitate networked communication between servers, including but not limited to Internet Protocol (IP) and TCP / IP. The description following FIG. 1 refers to a SAN, but this is for illustrative purposes only and should not limit any embodiment of the present invention unless explicitly stated in the claims. .

  In FIG. 2, flowchart (20) illustrates the steps of the system life cycle according to one embodiment of the present invention. As shown, processing begins with an empty index (21). The contents and purpose of the index are detailed below. The system then enters a wait state until it receives the version (22), after which it processes (23) the version in the manner described in more detail below. After processing the version, the system returns to the wait state (22) until another version is received. Procedure (22, 23) continues as long as more input versions are received. The input version may or may not update the repository and / or index. In one factoring application described here, if an input version is recognized as new (not sufficiently similar to the data in the repository), it is incorporated directly into the repository. On the other hand, if it is recognized that the input version is sufficiently similar to existing data in the repository, it is factored with the repository data and only the mismatched versions are stored. As is apparent from the above, the longer the system operates, the larger the repository size. For some applications, repository sizes range from hundreds of gigabytes to several petabytes. Thus, there is a need to locate or identify repository data that is sufficiently similar to the input data in an efficient manner. Otherwise, the processing time is too long and the system cannot be implemented economically or commercially.

  By analogy, although not intended to be limited as an alternative method of explanation, consider a scenario for two documents A and B that are very different from each other. In an initialized system, ie, an empty repository, according to one embodiment of the invention, each document A and B is stored in chunks or sections (chunks are described in more detail below). In order to simplify the description of the scenario, the chunks are sized so that each document A and B has a length of four chunks having two chunks for each half. Therefore, 8 chunks are stored in the repository. Note that according to this embodiment, these chunks are not stored based on file names. These chunks are stored so that the repository can replay documents from the chunks.

  Next, a new document C is generated (to document C) by cutting and pasting the first half of document A, and then the remaining half of document B is cut and pasted without adding other additional data (document C). F) shall be generated. Although it can be understood that the document C has a substantial similarity to each of the document A and the document B, the document C also has a substantial difference from each document.

  In this embodiment, the document C is divided into the four chunks, and the repository is searched for similar chunks. Similar chunks are identified between the first two chunks of document C and the first two chunks of document A, and between the last two chunks of document C and the last two chunks of document B And Since the system only identifies similar chunks and not exact chunks, the system will then specify any differences between similar chunks. Here, similar chunks are the same. Thus, in this scenario, document C is already already stored (as A and B chunks), and the space needed to store it, i.e. to play and retrieve it, is much more than storing the entire document C. A small amount. In a file name compliant system, four chunks of document C will be stored again (as document C) and it will be redundant because these chunks are already stored in the system.

  In order to reproduce the document C, the system according to the present embodiment searches the two chunks stored for the first half of the document A and the two chunks stored for the next half of the document B.

  In another scenario, a new document D is generated by cutting and pasting the first half of document A (to document D) and subsequently generated by cutting and pasting the other half of document B (to document D). As a result, the title of the document is changed from "The Life of John Adams" to "The Loan to Jobs Apple" without any other changes. . Again, not only can there be substantial similarity between documents A and D and between documents B and D, but also substantial differences can be understood.

  The system divides document D into four chunks and then detects similar chunks that are already stored. In this case, the system detects the first two chunks from document A, and detects the latter two chunks from document B as being similar to the chunk of document D. The system will then determine that there is a difference between the first chunk of document D and its individual similar chunk. The difference, i.e. the change location in the title, will be identified. Thus, document D will be represented in the repository as the first two chunks from document A and the second two chunks from document B, except that the first chunk of document D is identified as an identified similar chunk. That is, in the case of this example, the delta, that is, the difference between the first chunk associated with the document A and the contents thereof are accompanied. Thus, the amount of space required to represent document D is much smaller than storing all documents D in the repository there.

  Although the simple scenario described above has been described with reference to file names, ie documents, the various embodiments of the present invention are glazed for any file system, since the comparison is a function of chunks and properties described in more detail below. Because it becomes. By using this system, documents A, B, C, and D are not associated with the same user as in a file-compliant or file-name compliant system, but identify similarities and still achieve efficient storage. Can do. Attempts to detect similarities based on a backup system or file system should not be able to identify similarities between parts of Document A, Document B, Document C, and Document D in the scenario. Conveniently, the present invention is glazed for the best known file systems.

  FIG. 3 shows in detail one method of version processing (step 23 in FIG. 2) according to an embodiment of the present invention. When a version is received (31), it is divided into smaller chunks (32), ie 32MB per chunk. A first input chunk is selected (33) and the input chunk is processed to find (34) a substantially similar chunk and its position in the repository. This step (34) is described in more detail below with reference to FIG. By detecting similar repository chunks, the version chunks are further processed (35), which inevitably involves factoring the repository and version chunks according to this embodiment. This process repeats (34-37) for additional chunks of the input version until there are no more chunks in the version and the process ends (38).

According to different embodiments of the present invention, when an input chunk matches a given repository data, the subsequent input chunk is first tested for matches with the repository data following the matching repository chunk, and thus its application specific processing (35 Go directly to). On the other hand, if the following input chunk fails this test, it is fully processed to detect (34,35) its similar repository data.
Synchronization algorithms and factoring

  FIG. 4 shows one procedure of efficiently detecting the location of sufficiently similar chunks in the repository and the subsequent factoring step according to one embodiment of the present invention. The algorithm used to detect similar repository chunks for input (version) chunks is referred to herein as a synchronization algorithm, because its output contains something in common with the repository and version, which has so far This is useful for post-processing that effectively aligns (on the same data boundary) what was an unaligned data segment.

The input chunk size m, ie 32 MB, is processed (41) in the following manner. First, k identification characteristic sets (42) of version chunks are calculated, where k is a parameter (usually several tens) of this algorithm described below, and k << m (chunk size). According to one embodiment (as described further below for a particular example), k distinctive feature sets are calculated as follows (not shown in FIG. 4).
(1) Hash data is calculated for each seed of the input data chunk. The seed can be any size s substantially smaller than the string length m, ie 4 KB. According to this non-limiting embodiment, the hash value for each seed is calculated using a rolling hash function that moves forward by 1 byte in each iteration. A hash value is calculated for each iteration for a 4 KB seed size contained within this range. According to this example, when the input chunk size is m = 32 MB and the seed size is s = 4 KB, 33,550,337 (32 MB-4 KB + 1) hash values are obtained for each chunk, At each possible byte offset. Once the hash value for a seed of s bytes is known, the rolling hash function calculates the hash function for the next s bytes (ie, shifts 1 byte relative to the previous s bytes, thus having s-1 duplicate bytes. s bytes) can be performed by O (1) operation instead of O (s). The present invention is not constrained to the use of a hash function or to a rolling hash function.
(2) Next, the k maximum hash values, that is, the maximum hash values in the descending order of the k individual seeds are selected from the calculated hash values of (33, 550, 337). These k seeds constitute k maximum seeds. Thereafter, k hash values of k individual seeds, which are followed by 1 byte (overlapping by s-1 bytes) after the k maximum seeds, are respectively selected. These k seeds constitute k identification seeds, and their corresponding hash values constitute k input identification characteristics. Note that the maximum value itself has a non-uniform probability distribution. However, when a good hash function is used, the probability distribution of the following k values is very uniform and is therefore substantially better for the intended use. The uniform distribution means that k identification characteristics are distributed almost uniformly as numbers over a certain range of numbers.

  It should be noted that the present invention is not constrained by calculating the identification characteristics in the manner described above. Any option that is repeatable for a given chunk that produces error tolerance over a wider area and is well spread can be used in this embodiment of the invention.

  Definition

  Error resilience: The characteristics assigned to a chunk remain fairly constant (eg, up to 25% of its seed) as long as the chunk undergoes a modest change.

  Good diffusion: The characteristic position is well spread (almost uniformly) throughout the chunk (topographically spread).

  Repeatable: A certain type of chunk is almost always assigned the same characteristics.

  This type of method would only consider a subset of chunk seeds. For example, the property selection can be chunk spacing, the distance being defined arithmetically or geometrically according to the appropriate embodiment. The other method considers all chunk seeds such as those described above.

  According to this embodiment, a minimum geographical (positional) spread between characteristics is enforced, thus improving the coverage. In general, any repeatable option is applicable based on the arithmetic characteristics of the calculated seed value.

  For example, the k minimum hash values, i.e., the minimum hash value, i.e., the k hash values closest to the median value of all hash values calculated in the chunk, or the k hash values closest to a given constant You can even choose a value. Another example is to select k characteristics as the sum of pairs, so that the first pair constitutes the minimum and maximum values, the second pair constitutes the second minimum and second maximum values, etc. be able to. Other variations are applicable depending on the specific application.

  Also, instead of using a 1-byte shift of the seed corresponding to the minimum value, some other predetermined constant shift or even a different shift can be used depending on the position and / or the calculated hash value. The use of the maximum hash value and 1 byte shift is thus the only possible embodiment.

  A specific example of this one procedure for calculating the identification characteristic is shown below.

  In this embodiment, an index is associated with the repository, and this index stores n, but n ≦ k, identification characteristics for each repository chunk. The n identification characteristics are n hash values of seed size s bytes each followed by 1 byte (overlapping s-1 bytes), each of which is the n largest hash among the seeds in the repository chunk. Has a value. The reason why the k identification characteristics are calculated for each input chunk but the index contains only n identification characteristics for each repository chunk will be described below. The index further stores the location in the repository for each identifying characteristic. The present invention is not bound by any particular index structure and content described above.

  To better understand the index structure, FIG. 5 is substantially similar to the index (44) and the set of discriminating features (55i-59i) in the input chunk (51), according to one embodiment of the present invention. FIG. 6 illustrates the correspondence between the (5) corresponding identification characteristic sets (55r to 59r) in the repository chunk (52) to be displayed. The repository chunk 52 forms a part of the repository (53), and a huge number of chunks 50 are stored here. The discriminating characteristic is a set of selected hash values generated from the well spread seeds indicated by the five triangles (55i) to (59i) in the input chunk (51) as described above. The same five identification characteristics (55r-59r) are illustrated in a substantially similar repository chunk (52). This index (44) holds the identification characteristics of the location data (eg, the relative location of the chunk (52) in the repository) associated with the repository chunk (5 of the chunks (52)). Thus, during the similarity search period, when the value of the repository chunk (52) is detected to match that of the input chunk (51), the location of the detected chunk (52) in the repository extracts the relevant location data. It will be easily known. The index (44) grows continuously as new versions are introduced into the repository and hash values (calculated in the manner described above) associated with each version of the chunk are added to the index.

  Referring to FIG. 4, the index (44) searches for hash values of identification characteristics until a maximum of n matches are detected (step 43). More specifically, the index search is performed to detect matching of each of the k identification characteristics of the input chunk set, and this is continued until a maximum of n identification characteristics match. Here, j (j ≦ n) indicates the number of identification characteristics that match. Obviously, if n matches are detected before the entire set of k discriminating characteristics of the input chunk is examined (ie, only i of the k values are examined), the rest (ie In this example, the necessity to inspect k-i) is not necessary.

  The calculation amount of the calculation process for detecting these j matches is low because it requires a maximum of k index (hash value in this example) search, and each time the calculation amount is O (1). is there.

  In one embodiment, a version chunk with a match identification characteristic of j> 2 is considered to match one or more repository chunks. On the other hand, a version chunk with a match identification characteristic of j <2 is considered not to match any in the repository chunk. A single match (j = 1) is not considered statistically meaningful because its occurrence will not be a rare event for very large repositories.

  Note that the identification characteristics of the version chunk can match multiple identification characteristics of the repository chunk. It is possible that two version identification characteristics coincide with two repository identification characteristics that are well separated from each other and belong to two separate repository chunks. Thus, the possibility arises that a version chunk matches a plurality of repository chunks. For each repository chunk i of this kind, let hi be the number of coincidence identification characteristics of this kind. In one embodiment, the similarity level between repository chunk i and version chunk is measured by the ratio between hi and n, where if this ratio is above a threshold, the repository chunk is substantially similar to the version chunk. Can be considered (step 45 in FIG. 4).

  For example, consider a version that has undergone some changes compared to the previous version of binary data stored in the repository. Typically, this type of change is reflected in a small percentage of the seed that undergoes some local changes. The net effect is that most of a given chunk remains intact. Chunk discriminant locations are chosen to spread properly (topically across the chunks), so that local changes have little or no effect on discriminating features and the rest remain unchanged become. In other words, this representation method is error tolerant because it leaves many discriminating features untouched even for the majority of one (or more) local changes. Statistically, in an appropriate embodiment, if the search finds a repository chunk that has at least two matches (meaning the latter example, ie j ≧ 2), then the repository and version chunk are sufficiently similar Would deserve further comparison.

  In selected embodiments, the chunk is further divided into u sub-chunks to improve the uniform spread of discriminating characteristics on the version chunk (which eventually becomes part of the repository). For each sub-chunk, k / u identification characteristics are calculated, which together form k identification characteristics.

  In selected embodiments, a highly circular discriminant list is maintained to improve the importance of each match of discriminant features. When the identification characteristic is calculated for a certain number of version chunks that exceed a certain threshold, it is considered to belong to some systematic pattern in the data, thus resulting in reduced identification information. So add it to the circular list and eliminate its use when it occurs for the following chunks. When calculating an identification characteristic, its value is checked for each occurrence in the list, and if it exists, it is discarded and another identification characteristic is calculated on the spot.

  In the described embodiment, perhaps more than n to k identification characteristics are searched in the index, during which only n are stored in the index for each repository chunk. According to this embodiment, there are probably two effects on the maximum hash value caused by changes to the version chunk on the repository. That is, 1) Since the data constituting the corresponding seed is modified, the maximum hash value can appear. 2) The modified data can introduce higher order maxima and displace the maxima still present. In the case involving the second effect, the search for more discriminating characteristics provides more stability because the previous maximum does not disappear, it is only replaced. These two effects are the reason for choosing the maximum value for descending order and / or for k> n selection.

  FIG. 6 shows an example of how to substantially preserve the identification characteristics despite changes to the data. In this example, the data is mp3 data, the repository size is 20 GB, the version size is tens of thousands of chunks, the chunk size is 32 MB, and the number of identification characteristics calculated for each chunk is eight. In the illustrated three-dimensional representation of the search result, the horizontal axis (width) represents the number of detected keys (identification characteristics) and the number searched. The left margin axis (depth) represents the percentage of the data seed that changed within the version. The axis (height) of the right margin represents the number of chunks detected by searching for the key. Thus, each row (in depth) will show an effect on some discriminating characteristics when given a percentage of the changed seed.

  For example, in line 5, 10% of the data has changed, and the average of about 5,000 chunks still has 7 of their 8 discriminating characteristics untouched, More than 95% still have 4 or more of these 8 distinguishing characteristics. In the fourth row to the first row, 5%, 3%, 2%, and 1% of the data change, respectively, and the storage of the identification characteristics gradually increases. As the percentage of data change increases, more similar data can be detected by setting a lower threshold (the minimum number of matches of discriminating characteristics in the repository and input). In the case of this example, the peak relating to 25% data change (line 8) is centered on about 4 detected keys, and the threshold is set to 4 (out of k input identification characteristics). At that time, the similarity search will return to almost all repository locations where the data changes up to 25%. If the threshold is higher for the same 25% data change, eg, set to 6, then the search will return to a much lower percentage of similar repository locations. Thus, the graph of FIG. 6 etc. can assist the user in selecting values for j, k, m, n in a particular example.

  Returning again to FIG. 4, if one or more substantially similar repository chunks are detected, the location of each matching repository chunk is extracted from the index (45, 46). Recall that the location of repository chunk location data (related to j detected hash values) can be easily retrieved from the index. Subsequent steps can use one or more matched repository chunks, and rank the repository chunks according to their similarity. In this embodiment, a factoring step (47) involving the version chunk and its matching repository chunk follows, which leads to efficient storage of the version chunk in the repository. In this type of backup and restore system, further steps are to identify common (identical) and non-common (non-identical) data in the version and repository, and store only the non-common data of the version (using appropriate pointers). To keep the stream consistent), including storage savings. For example, in a typical backup and restore system, data may change by 1% between backups. Add a second backup to the repository by adding only 1% of that data to the repository, maintaining a pointer to where the remaining data is found, and effectively saving 99% of the required space be able to.

  In the next step (48) of this embodiment, the identification grade of the matching part of the repository is removed from the index. This step is performed to remove any reference from the index to the "old" part that is currently replaced with a more updated version of the new input chunk. In the next step (49), the n most important identification characteristics of the new chunk are added to the index. In the present embodiment, when the hash value of A's maximum seed exceeds that of B, the identification characteristic A is more meaningful than another identification characteristic B. This is done at almost no cost, because n is small and removal and insertion of n values into each hash table can be done by O (1) operations. Version chunk processing is performed here (404).

  In FIG. 4, if no match is found (ie, j less than a match threshold is found) (401, 402), the new version chunk is processed by some alternative process, because similar repository data is This is because it was not detected (403). In one example, version chunks can be stored in a repository without factoring. According to the index update strategy of the present embodiment, version chunk identification characteristics are added to the index (49). Processing (404) ends there (in either the above-mentioned matching success or matching failure path) and leads to processing of a new version chunk.

  It should be noted that the present invention is not bound by the example index update strategy described above. In other applications, it may be appropriate to store all of the identifying characteristics of both a version chunk and all its matching repository parts. Otherwise, it eliminates the addition of version chunk identification characteristics, or perhaps updates the index with some sort of version and repository chunk identification characteristics.

  In particular, in this embodiment, if the identification characteristics of a version chunk replace all of the features of the matching repository part, all the identification characteristics associated with the valid repository part (possibly partly version chunks) using another index called the reverse index. Discriminating characteristics). Inverse indexes are typed by locations in the repository and map these locations to their associated distinguishing characteristics. This reverse index also facilitates maintaining the integrity of the primary index in some missing cases of the repository.

  It should also be noted that the present invention is not bound to this embodiment where the index starts from empty. In other examples, splitting the repository into chunks, calculating their identifying characteristics, and building the index based on this information, loading the index based on the existing body of repository data May be appropriate. In this kind of case, the index may or may not be further updated with incoming version chunks according to some kind of update strategy of the kind described above.

  It should be emphasized that the calculation amount of the calculation process for searching the repository for data similar to the version data is proportional to the version size, that is, O (version), and is designed regardless of the repository size. This search requires at most k O (1) hash tape searches for each version chunk, according to the non-limiting embodiment described above. Since k <m (where m is the size of the version chunk), the computational complexity of detecting similar chunks in the repository according to a particular embodiment exceeds O (version), ie, the computational complexity of identifying characteristics There may not be, and this is true regardless of the repository size. The search procedure for similar data is thus very efficient even for very large repositories.

  Furthermore, it should be emphasized that the space required for the index is proportional to the ratio between the number of identification characteristics stored for each chunk of the repository and the chunk size, ie the ratio between n and m. . In one embodiment, if n is 8 and m is 32 MB, the space required to store each identification characteristic is 16 bytes, for a total of 128 bytes stored in each 32 MB repository in the index, 250 , A ratio exceeding 1,000: 1. In other words, a 4GB ad hoc read / write memory (RAM) can hold the index needed for a 1PB repository in that memory, facilitating quick search of the index, and thus similar in a very large repository for any input chunk Facilitates the rapid detection of data.

  It should be noted that if similar chunks are detected based on the identity of the matching identification characteristic in the manner described above, it will be of interest to identify exact differences between similar chunks. In this type of case, a more detailed comparison (or supplement) algorithm can be applied to compare all the individual chunk data (not just n identification characteristics). In general, but not exclusively, examples of this type of algorithm are binary difference and byte-wise factoring type algorithms. An improved binary difference algorithm that can be conveniently used in selected embodiments is described below.

  The replenishment algorithm will be less efficient (in terms of computational resources) than the synchronization (similarity search) algorithm just described. The degraded efficiency is due to the fact that all data for a given repository chunk in the replenishment algorithm is processed, but the similarity search algorithm only processes some data related to the chunk (ie, data that contains discriminating characteristics). May be derived. However, the replenishment algorithm applies only to a single repository chunk of size m, or perhaps to a small number of such repository chunks that have already been detected as sufficiently similar to the input chunk, so the degradation performance is comparable within the selected application. It will be meaningless. This is particularly true in contrast to alternative implementations of the replenishment algorithm, especially for entire repositories of 1 PB or more.

  The foregoing embodiment of the similarity search algorithm illustrates the use of an index that solves the nearest neighbor query type that searches the majority of similar repository chunks against the input version chunk. This embodiment does not limit the invention in any way. The index can be used to solve other types of queries such as range queries. The specific type of query depends on the specific application.

To better understand the similarity search described above, the description that illustrates several embodiments of the present invention continues below. The present invention is not limited to this example. For convenience of explanation, the repository includes a single chunk, and this example will illustrate how to classify an input chunk as sufficiently similar to the repository chunk.
Example 1
Step 1: Build an index for each repository.

This example uses the following repository string: That is, “Begin-at-the-beginning-and-go-on-till-you-come-to-the-end; -then-stop.”. This step is a byproduct of the previous algorithm iteration. It is explicitly included here for ease of understanding of this example.
Step 1a: A hash is calculated.

In this example, a hash value is calculated for each byte offset using a rolling hash function. It uses a modular hash function, which uses the prime number 8388593 for illustration purposes. The hash function used is h (X) = Xmod8388593. In this example, the seed size is 8 bytes.
Input string: “Begin-at-the-beginning-and-go-on-till-you-come-to-the-end; -then-stop.”
Calculated hash value

Step 1b: The maximum value is calculated.

  Find n text positions with maximum hash value. In this example, for n = 4, these are as follows:

Step 1c: Move one character to the right.

  As described above, the maximum hash value itself does not have a sufficiently uniform probability distribution. Thus, for each seed corresponding to one of the maximum hash values, here the hash value of the seed having one character is used. These hash values are used as identification characteristics for the purpose of this example, and together with these parts they constitute the index of this example.

Step 2: Match version.
The repository has been modified as "Start-at-the-beginning-and-continue-to-the-end;-then-cease." This modified repository is considered a version (according to this example with only one chunk).
Step 2a: A hash is calculated.

Input string: “Start-at-the-beginning-and-continue-to-the-end; -then-cease.”
Calculated hash value:

Step 2b: The maximum value is calculated.
Find k text positions with maximum hash value. In this example, for k = 8, these are as shown in the table below.

Step 2c: Move one character to the right.
As described above, the maximum hash value itself does not have a sufficiently uniform probability distribution. Thus, here, a hash value of a seed having one character that follows is used. These positions are used as identification positions, and these eight hash values are used for index search.

Step 2d: Take a match.
Version hash values 5615355 (version position 18), 6310941 (version position 35), and 614663 (version position 6) were detected in the index. They correspond to positions in the repositories 18, 46, 6 respectively. One match is declared, i.e. the algorithm reads "start-at-the-beginning-and-continue-to-the-end;-then-cease.","Begin-at-the-beginning-and-go-".-On-till-you-come-to-the-end; -then-stop. ", The corresponding position is detected.

  It should be noted that according to this example, the similarity threshold (the minimum number of coincidence of identification characteristics) is j ≧ 2. If this threshold is set to 4, the chunks are not considered sufficiently similar because only three matches are detected. In this example, n is set to 4, meaning that the number of identification characteristics of the repository chunk is 4, k is set to 8, and the number of identification characteristics calculated for the version chunk is 8 Also note that By setting k> n, the search returns to the repository location of number 77335648, which has moved from the fourth maximum value in the repository to the fifth maximum value in the input, thus k is set to 4. If set (k = n), it should not have been detected.

This example illustrates a method for detecting similar chunks in a degenerate case of a repository that holds only one chunk. However, even for an index that stores the identification characteristics of a large number of chunks, the search process is still very efficient because the search in the index (eg, stored here as a hash table) is very efficient even for large indexes. Because it is done in a natural way. Also, the data stored for each index input is small (in this case, hash value and position), so in many applications the index is stored in the computer's internal high-speed memory (RAM) for slow input / output operations Can be eliminated, thereby prompting a search in the index.
Computational complexity (of the synchronization algorithm)

  The time required to calculate the version chunk seed hash is linear in chunk size, because a rolling hash is used. The time required to calculate the k maximum values is O (m · log (k)), which is reasonable because k is small. If the index is a binary tree, the time required to search the index for k identification characteristics is O (k · log (r)), where r = (R · k) / m is the index Where R is the repository size (up to about 250), k is small (usually 23), m is the chunk size (usually 225), and thus r is usually 228, log (r) = 28. Since k is small, the search time for the entire index is acceptable. If the index is represented by a hash table, the time required to search the index for k identification characteristics is k · O (1). Therefore, the chunk search time is determined by the time it takes to calculate and the order of the maximum value, ie O (m · log (k)), thus equivalent to a linear scan of a small number of version chunks. Since k is small, the overall search time is acceptable. Note that this result forms part of the computational effort of the brute force attack algorithm and is O (R · m), the product of repository size R and chunk size m.

  The amount of time required to insert a version chunk into the index is the same as that required to search the index. No extra time is required to calculate the n identification characteristics because they have already been calculated.

  The spatial requirements for this algorithm are what the index needs. Each input has a 16-byte parameter for each given example, which includes the key (identification characteristics) and position data, and there are those 228 (the value of r calculated above) in 1PB Thus, a 4 GB index is required for managing 1 PB of repository data.

The system according to this embodiment can be executed by an appropriately programmed computer. Similarly, the present invention contemplates a computer program readable by a computer executing the method of the present invention. The present invention further contemplates a machine readable memory that implements as a tangible program a program of instructions executable by a machine executing the method of the present invention.
Binary difference algorithm

  A novel binary difference algorithm that efficiently calculates the intersection of two data intervals will now be described. In the described embodiment, the algorithm uses the output of the similarity search (synchronization) algorithm described above, which locates several pairs of matching identification characteristics in the version and repository data for a given version chunk. A pair of matching identification characteristic locations (one in the repository and one in the version) are described here as anchors. Anchors are used for pruning from alignments and further processing repository intervals that are unlikely to contain a match in the version, thus narrowing down the repository interval that is most similar to the version chunk. This reduces the algorithm processing time.

  Based on the anchor, the corresponding interval is defined as a version and repository interval pair that includes the matching part (same data). A binary difference process is used for each of these interval pairs. Instead of placing the repository and version windows within matching offsets, they are now placed according to anchors (perhaps at non-matching offsets) by using analogs with sliding windows.

  One advantage of the present algorithm is the use of a seed step size for one interval of the interval pair. The known binary difference or delta algorithm moves in increments of bytes for both intervals, but the algorithm moves only in increments of bytes for one interval (version interval), for example, and the seed size (for example, the repository interval) , Multiple bytes) move in increments. This technique increases processing speed and reduces spatial requirements without reducing the match processing rate (because match processing is extended in both the reverse and forward directions). Another advantage of the present algorithm is that the known binary delta algorithm can generate both add and copy commands, while using this algorithm can generate only copy commands in a sort order. The additional directives can then be implicitly derived from the copy directives as needed, thus reducing the storage required for the algorithm output.

  The following table defines the symbols used in this embodiment, and FIGS. 7 and 8 illustrate the elements graphically.

FIG. 9 is a high-level (overview) flowchart illustrating the steps of one embodiment of binary difference processing that operates on an anchor set. FIG. 10 is a more detailed flowchart illustrating an algorithm that operates within an anchor set. 11 to 14 show calculation examples of the version interval and the repository interval according to this embodiment.

  The inputs in the described embodiment are a set of anchors linking the version chunk, a hash value sequence of byte offsets associated with the version chunk, and the version chunk and repository data. The latter two inputs are generated by a synchronization (similarity search) algorithm. The output of the binary difference algorithm is a matched (ie, identical) interval pair set in the version chunk and repository data. A pair of coincidence intervals is expressed as a copy interval. Each copy interval can be encoded as a copy directive that includes the version, the starting offset of the associated interval in the repository, and the interval size. This copy instruction indicates an individual (non-overlapping) version interval and is generated by an algorithm rearranged in descending version offset order.

  In FIG. 9, a flowchart (80) illustrates the steps of performing one embodiment of a binary difference algorithm. As shown in the figure, the process starts by receiving (81) the hash value of the version chunk of the anchor and byte offset from the similarity search as input. Next, an anchor set is calculated (82). This can be accomplished as described in step 1 below. Therefore, the binary difference algorithm is executed on another anchor set using the first anchor set (83). This can be accomplished as described for FIG. The process repeats for additional anchor sets (84-86) until the anchor set no longer exists in the version and processing is achieved (87).

  A more detailed description will now be described with respect to FIGS. In FIG. 10, a flowchart (90) shows an embodiment of a binary difference algorithm operation (step 84 in FIG. 9) performed on an anchor set. FIGS. 11 to 14 show calculation procedures for one interval between the version chunk 120 and the corresponding repository data 118. This interval is denoted as the current anchor set 122 and includes multiple locations of the identification characteristics 124 of the version chunk 120, some of which have a matching identification characteristic 125 in the repository data 118.

Step 1-Calculate the anchor set (82 in FIG. 9). Sort anchors in ascending order of their version offsets. The permuted anchors are traversed and associated with them as follows. A pair of consecutive anchors Ai and Ai + 1 are in the same anchor set if they have the same repository offset estimator, for example | [O (Ai + 1V) -O (AiV)]-[O (Ai + 1R)- O (AiR)] | ≦ C
Where C is a constant selected to meet the desired behavioral characteristics (further described below in relation to computational complexity). As long as consecutive anchor pairs belong to the same set, they are added to the current set. If consecutive pairs do not belong to the same set, close the current set, open a new set, and add the latest anchor in the new set. The output of this step is described as {ASj} 1m, where m is the number of identified unjoined anchors. FIG. 7 shows an anchor set ASj including two anchors Ai and Ai + 1 connecting the version 120 and the repository 118. FIGS. 11-14 show the version 120 and the current anchor set 122 in the repository 118. Steps 2 to 6 (step 84 in FIG. 9) described below are executed for each anchor set in {ASj} 1m. Assume that ASj is the current anchor set (step 91 in FIG. 10).

  Step 2-Calculate the version interval (92 in FIG. 10). The version interval IjV is related to the current anchor set ASj (see FIG. 7). The interval IjV is one byte after the right offset of the latest copy command generated by execution of the binary difference process on the previous version interval Ij-1V, or the beginning of the chunk (the previous anchor set ASj-1 is completely Starts if not present) and ends one byte before the leftmost anchor in ASj + 1, or ends at the end of the chunk (if ASj + 1 is not present at all).

  Step 3—Repository interval is calculated (step 93 in FIG. 10). The repository interval IjR is associated with the current anchor set ASj. AlR (l is 124b in FIG. 11) is the leftmost anchor ASj, and ArR (r is 124g in FIG. 11) is the rightmost anchor ASj. Therefore, IjR = [O (AlR) − (O (AlV) −LO (IjV)), O (ArR) + (RO (IjV) −O (ArV))]. Here, the interval pair IjV, IjR is called a corresponding interval. FIG. 8 shows four pairs of corresponding intervals (connected by dashed lines between version 120 and repository 118), each associated with an individual anchor set AD. A binary difference process (steps 4, 5, and 6), which will be described in detail below, is performed on the corresponding interval of each pair and IjV and IjR calculated in this step.

  This algorithm is part of the factoring application, and the corresponding repository interval IjR is read from the repository into memory (step 94 in FIG. 10), allowing the data in IjV to be compared with the data in IjR.

  Step 4 (see FIG. 12) —Expand the matching anchor (step 95 in FIG. 10). The matching process is expanded around the anchors of the current anchor set ASj in the forward and reverse directions, and these matches are coded as a copy command. These matches shown in FIG. 12 by region 128 in version 120 and region 129 in repository 118 are called match anchors. These copy commands are stored in a temporary command buffer. The output of this step is represented by a set {CiR} 1n, {CiV} 1n, where n is the number of anchors in the anchor set.

  Step 5 (see FIG. 13) —Load repository interval hash value into hash table (step 96 in FIG. 10). Except for the repository anchor (129) extension in IjR, the hash values of all consecutive non-redundant seeds in IjR (area 130 in FIG. 13) are calculated and stored in a hash table called RHashT.

Step 6 (see FIG. 14) —Search for a match (steps 97-105 in FIG. 10). For each successive seed (with byte offset) in Ij + 1V, the extension of the anchor present in IjR (region 128 in FIG. 14) is eliminated. Search for that hash value (remember that these hash values were received as input from the product of the synchronization algorithm) and search for it in RHashT (step 98 of FIG. 10). If a match is detected, expand it forward and backward to the largest extension (regions 134 and 136 in FIG. 14) that does not overlap the previous copy command or the next match anchor or IjV start and end in the version. (Step 99 in FIG. 10), and encodes it as a copy command and outputs it (Step 100 in FIG. 10). When the matching anchor is reached within the version (step 101 in FIG. 10), the corresponding copy command stored in the temporary command buffer is output (step 102 in FIG. 10), and the next seed to be processed (FIG. 10). 10 step 104) is the first seed to be placed after the matching anchor in that version. If the coincidence anchor is not reached at all and the end of IjV is not reached (step 103 in FIG. 10), then the next seed that is the processing target in IjV (step 104 in FIG. 10) is defined below. Next unmatched seed. If the current seed does not match, then the next unmatched seed begins one byte after the first byte of the current seed. On the other hand, if the current seed matches and is expanded, then the next unmatched seed will start one byte after the last byte of the last seed contained in the extension. When the end of IjV is reached (step 103 in FIG. 10), the corresponding interval associated with this anchor set ASj is processed (step 105 in FIG. 10). If there is no next anchor set (step 85 in FIG. 9), the binary difference processing of the version chunk is completed (step 87 in FIG. 9). Otherwise, processing continues from step 2 detailed above to the next anchor set ASj + 1 (step 86 in FIG. 9).
Calculation amount (binary difference)

  Storage: The binary difference algorithm embodiment described herein uses a fixed size hash table (RHashT), the size of which is proportional to the chunk size divided by the seed size, because the chunk size is a repository. This is because it is the upper limit of the interval size. Thus, the table size is quasi-linear to the chunk size. In addition, it is necessary to temporarily store a copy command indicating a matching anchor. This is proportional to the number of anchors in the chunk, i.e. the number of its distinguishing characteristics, which is small. Therefore, the total storage requirement of the algorithm is quasi-linear with the length of the chunk.

  Time: The phase of the extension of the match anchor (step 95) and the loading of the repository hash value into the RHashT (step 96) requires one linear path over the corresponding interval. The search phase of version hash values in RHashT (step 98) and the extended phase of their detection match (step 99) are similar to the Greedy algorithm, whose worst case time is a quadratic expression of the corresponding interval length. . However, by limiting the length of the hash table chain to a fixed size, the required average time for this phase is between 1 and the hash chain linear path length on the corresponding interval. Note that uptime is also a function of the degree of similarity (identical data) between version and repository interval (the more similar, the less time it takes). There is extra time taken to process the overlap of consecutive corresponding intervals. Following this, the required average total time is two linear passes over the corresponding interval.

  The systems and methods disclosed herein can be implemented in a variety of forms including, for example, a data processor such as a computer. Furthermore, the above features and other aspects and principles of the present invention can be implemented in a variety of environments. This kind of environment and related applications can be specially configured to perform the various processes and operations according to the present invention, or general purpose computers and computations that are selectively activated or reconfigured by code that provides the necessary functionality for them. A platform can be included. The processing disclosed herein is not inherently related to any particular computer or other device, but can be performed by an appropriate combination of hardware and software and / or firmware. For example, it can be used with various general purpose machines with programs written in accordance with the teachings of the present invention, or it can be more convenient in configuring specialized devices or systems to perform the required methods and techniques.

  Systems and methods consistent with the present invention can also include computer-readable media containing program instructions or code for performing various computer-executable processes based on the methods and processes of the present invention. The media and program instructions may be specially designed and constructed for the purposes of the present invention, or may be of a type well known and available to those skilled in the computer software art. Further, the computer readable medium may take the form of a signal on a carrier wave or may take the form of a storage medium such as a disk. Examples of program instructions include files containing high-level code that can be executed by a computer using, for example, machine code or a converter, such as generated by a compiler.

  As shown in FIG. 15, data processor 300 receives input 305 and may include a central processing unit 320 and a storage module 350 and / or an input / output (I / O) module 330. Input / output module 330 may include one or more input / output devices including display 335, keyboard, mouse, input storage device, printer 336, and network interface 338. The network interface allows the data processor to communicate over a network such as a communication channel. The central processing unit can include, for example, one or more of the following. A central processing unit, a coprocessor, a memory, a register, and other suitable processing devices and systems.

  The storage device can be implemented with various components or sub-systems that can provide storage including, for example, hard drives, optical drives, general purpose storage devices, removable storage devices and / or memory.

  The various embodiments of the method and system of the present invention described herein are useful for identifying data in an input stream that already exists in the repository. Products that use this type of system and method include anti-disk backup products that save disk storage space by not repeatedly storing backup data that has not changed since the previous backup. This saves end user disk space when storing multiple backups in the same repository.

  The system and method of the present invention can be included in storage devices, switches with artificial intelligence, servers and software applications. The method and system can be combined with derivative products that include other components. Service providers can use the system and method to provide the described capabilities as a service. This system and method would be particularly useful in the data protection market, for example for backup, restoration, replication, jumping and media management. Other implementations can include use in main storage.

  The systems and methods described herein relate to managed storage media and data representations in managed repositories. This includes disks, tapes and other types of storage media that can survive in the market over time. The present invention is not limited to a disk or a fixed medium, but can also be applied to a removable medium. For example, a removable disk can be used as a target output device. It can be managed for the tape as well, and both become removable media.

  One approach to the design of systems that include removable media such as tape is to operate the disk as a storage location for the largest reference chunk or element and move the smallest reference chunk onto the tape medium. . This can be balanced by a management system that takes into account the freshness of all chunks. The system can also move related repository chunks to tape as a whole set that is stored and reclaimed from the archive as a set. This should double the advantages of the present invention. For example, if the use of 100 pieces of media is required without using the present invention, then for example, only 10 pieces of media are required after use of the present invention. This medium can consist of a virtual medium that is itself described as a repository.

  Various embodiments of the synchronization algorithm and binary difference processing algorithm described herein have a linear execution time and a fixed space (depending on the size of the chunk and anchor set) for the version size. Reusing calculated values between algorithms saves computation time.

  The described embodiment also illustrates the use of two memory hierarchies. The synchronization algorithm computes and temporarily stores a set of representative (eg, hash) values for the input data, derives a set of identifying characteristics from it to identify similar data regions in the repository, and temporarily stores the input data in the repository This identification characteristic is stored in the index if stored in the index. The representation value of the input data in temporary storage can then be used in a binary difference processing algorithm that identifies the exact data that matches the repository data. The binary difference algorithm calculates a set of representative (eg, hash) values for the data area in question in the repository and temporarily stores this type of value in memory for comparison with the representative value of the input data. By processing the corresponding interval between repository data and input data, a relatively small amount of memory can be used to store representative values. Also, the matched data segments are generated in the input data position order, which saves reordering time and storage requirements.

  Furthermore, the embodiments described herein consisting of a synchronization algorithm and a binary difference algorithm scale to a petabyte size repository. In various embodiments, the ratio of repository size to index size is up to 250,000 to 1, and a 4 GB index can be represented to represent a 1 PB repository, and this index fits into the memory of a commercial product type computer. Can do. When the hash table is used as an index, the index search is a fixed time and constant space O (1) operation, and the search process is independent of the repository size for repositories up to 1 PB. If the repository is not limited to 1 PB, then a binary tree or B-tree can be used for the index. The size of the index is still 250,000 to 1 smaller than the repository, and the index search is an operation using O (log (m / 250,000)), where m is the repository size. In a 1 PB repository, m is 250, thus log (m / 250,000) is 32.

The systems and methods described herein provide a data storage system that performs data reduction without large-scale loss of input data for the repository by partitioning the input data into portions that are in the repository and those that are not. can do. The partition process is performed by a two-stage process. That is,
(1) For each chunk of input data, detect all areas in the repository that contain similar data,
Here, this detection process also results in a rough similarity estimate and provides a similarity level grading capability.
Even if the repository is very large, you can use the index and memory to perform the discovery process,
The ratio of repository size to index size is up to 250,000: 1,
If detected within each region, the search detects one or more corresponding actual locations,
(2) For all detected areas, the most similar area in the repository and the binary difference are
Read that part of the repository into memory, compare the input chunk with the part in the repository to detect strict changes, while using the actual corresponding location as a guide,
The output is selected by setting it as the identified section. Data in the input data detected in the repository need not be stored again. The characteristics of the input data can be added to the index.

  Each embodiment of the binary difference processing algorithm described herein has several advantages. Match identification characteristics are derived from a reference frame for a binary difference processing step, as well as (index) similarity searches as well as from logical partitions (eg, anchors) within this frame. The binary difference processing algorithm requires only one hash table, which is small because it stores only one value for each seed of the repository data segment in question. The representation value of the input data at each subseed step (eg, byte) is known because they are calculated during the index search period. The cost increment of the binary difference processing step is small, which is linear in the size of the input data. Since the repository hash table is searched at each lower seed interval (eg, byte), binary difference processing detects misaligned arrangement data.

  In various embodiments, a binary difference processing method can be used to perform linear time and constant space O (1) processing that compares input data with similar identified repository regions. This processing uses the result of the similarity search previously calculated and only one repository hash table that is smaller than the identified area in the repository by the seed size coefficient. The binary difference process detects the same data even if it is exchanged or misaligned. It detects all the same data that is at least the length of the seed size, where the hash table is large enough. This process derives a list of subregions in the input data detected in the order of their appearance in the input data.

  In another embodiment of the present invention, version data or new data can be located on one system or computer, while the repository can be located on a different system or computer than the first system. In this type of scenario, delta information must be identified via communication between the first system and the second or remote system. As mentioned above, a large amount of data must be managed and thus the bandwidth used for the system should be minimized as much as possible. According to one aspect of the present invention, updating a repository located remotely from new or version data is accomplished using a minimum amount of bandwidth.

  As shown in FIG. 16, a system (1600) similar to that shown in FIG. 1 includes a network (1601), which is a SAN or TCP / IP compliant network as described above, and server A (1602) and server B (1604). ), Server C (1606), and server D (1608). For illustrative purposes only, server B (1604) has repository B (17) coupled to it, while server D (1608) has repository D (17) coupled to it. Repository D (17) can be all or part of the mirror image, backup or copy of repository B (17), thus storing the same information on it. Server A (1602) and server C (1606) do not have individual repositories.

  In one example scenario, server A (1602) has new data and version data, and repository B (17) has repository data and repository chunks stored therein as described above.

  In the illustrated context, server A (1602) has new data that needs to be stored in repository B (17). From the above description, the discriminant characteristic or identification characteristic set of the new data is calculated and transferred to the server B (1604) so as to detect the position of the repository data similar to the new data, that is, the version data, used for index search. It should be understood that old data or similar data is retrieved from B (17) and the new data and old data are compared to identify the delta or difference.

  Since server A (1602) contains new data, it may now be determined that similar data from repository B (17) should be sent via server A (1602) to identify the delta. However, this transmission can occupy most of the bandwidth of the network (1601). Once server A (1602) identifies the delta, in order to update repository B (17), delta information is sent from server A (1602) to server B (1604) via network (1601) to provide repository B ( 17) must be used for the update.

  According to one aspect of one embodiment of the present invention, the bandwidth required to update repository B (17) is reduced. Conveniently, similar data from repository B (17) is not sent to server A (1602) to identify delta information.

  The processing method for updating repository B (17) with minimum bandwidth usage in accordance with one embodiment of the present invention will now be described for method (1700) shown in FIG. In step (1702), a characteristic set relating to the version, that is, new data on server A (1602) is locally calculated by server A (1602). Server A (1602) transmits the characteristic calculation set to server B (1604) in step (1704). The remote server, in this case server B (1604), searches for a match with the received characteristics and identifies one or more similar data chunks held by repository B (17) in step (1706). If a match is detected in step (1708), control proceeds to step (1710) where server B (1604) retrieves a similar data chunk from repository B (17).

  In order to identify the difference between the new data detected in repository B (17) and the discriminatively similar remote data, step (1712) uses a modified version of the low communication cost remote difference process, for example the rsync utility. By using a modified existing remote difference process such as rsync, the amount of network bandwidth used to identify delta information is significantly reduced.

  The modified remote difference process does not have to have all new data and all identified similar data on the same system, but identifies the differences between the new data and the identified similar remote data. As a result of the modified processing, the amount of data that must be transmitted over the network is reduced. In operation, any one of several different remote difference processes can be modified for this application.

  Thus, in one embodiment of the modified remote differencing process, the hash of new data and identified similar remote data is determined by the local system, server A (1602), remote system (17), and server B using the same algorithm. Use to calculate. These hashes are compared there and different hashes represent representative portions of different individual data. Data relating to the different parts is then transported from server A to server B and stored in repository B. Hash generation and comparison reduces the amount of data bandwidth required to identify differences in the data.

  Following step (1712), if delta data is identified and step (1714) specifies that its repository B (17) should be updated, control proceeds to step (1716) where remote repository B (17 ) Is updated according to the above description.

  Returning to step (1708), if no match is detected, control proceeds to step (1714) where a decision is made to update repository B (17), and if no update is made, then control passes to step (1). Go to 1718).

  In another scenario, there may be situations where server A (1602) has new data or version data that needs to be conveyed to server C (1602). As shown in the system (1600), neither server A (1602) nor server C (1606) includes a repository. If the amount of new data is very large, one embodiment of the present invention minimizes the amount of data bandwidth required to carry new data from server A (1602) to server C (1606).

  A method (1800) of transmitting new data from the server A (1602) to the server C (1606) using the minimum amount of bandwidth of the network (1601) will be described with reference to FIG. Steps (1702 to 1712) are the same as already described above with respect to FIG. Subsequent to step (1712), in step (1802), server A (1602) transmits delta information and identifier information of similar data to the second system, that is, server C (1606). The identifier information of the similar data is similar to the location of the repository where the repository data is arranged, in this case, information about the repository B (17) and the address of the repository B (17) that is the IP address of the server B (1604). Information related to one or more chunks of a particular repository identified as, for example, a reference level, and a time stamp identifier that is synchronized to the state of repository B (17) from which the difference or delta information was generated in step (1712) Will be included. This timestamp information will be needed to ensure that subsequent operations by server C (1606) are done for repository B (17) with the same state identifying the difference in step (1712).

  In step (1804), the second system, that is, server C (1606) retrieves the identified similar data chunk from repository B (17) using the information received from server A (1602). In one embodiment, server C (1606) can request the entire identified repository chunk and replace the change with the delta information received from server A (1602), or server C (1606) can change. Only a part of the repository data that has not been requested can be requested from the repository B (17), and the delta information from the server A (1602) can be combined to arrive at new data of the server A (1602).

  Conveniently, server A (1602) conveys new data to server C (1606) using a minimum amount of bandwidth by simply transmitting delta information along with identifier information relating to similar data stored in repository B (17). can do.

  An alternative embodiment of the method 1600 will now be described with reference to FIG. In this alternative scenario, receiving server C (1606) accesses repository D (17) instead of accessing repository B (17) in step (1804) to reproduce the data transmitted from server A (1602). To do. Server C (1606) knows that Repository D (17) has the same data as Repository B (17), and obtaining similar data from Repository D (17) is a better option for several reasons. Is determined. These reasons may include one or more of system load characteristics, system availability, system response time, and system quality service level agreements. The adjustment between the server C (1606), the system D (1608), and the repository D (17) is the same as the adjustment between the server C (1606), the server B (1604), and the repository B (17). It is a spear. Once server C (1606) retrieves information from repository D (17), repository D (17) is updated to reflect the current data received from server A (1602) via server C (1606). Can do.

  In yet another embodiment, once server B (1604) and repository B (17) are updated with the difference data from server A (1602), repository D (17) is server B (1604) and repository B. It can be updated by a transaction with (17).

  Of course, those skilled in the art will appreciate that server C (1606) and server D (1608) can be configured on the same computer for reasons of system simplicity and efficiency.

  Other embodiments of the invention will be apparent to those skilled in the art from consideration of the specification and illustrations of the invention disclosed herein. The scope of the invention is indicated by the appended claims, and the specification and examples are intended to be considered exemplary only.

FIG. 2 illustrates a general system architecture of an exemplary backup and restore system useful for some described embodiments of the present invention. 6 is a flowchart illustrating exemplary steps for processing an input version data stream according to an embodiment of the present invention. FIG. 6 illustrates more detailed procedural steps for processing a data chunk of input version data according to one embodiment. FIG. 4 illustrates more detailed procedural steps for detecting the location of a version chunk in a repository according to one embodiment. FIG. 6 schematically illustrates the correspondence between seeds in version chunks and seeds in repository chunks according to one embodiment. It is a figure showing the three-dimensional graph which shows the result of the similarity search of the specific example which shows how the identification characteristic can be substantially maintained despite the data change. FIG. 6 is a schematic diagram representing versions that define symbols used in one embodiment of a binary difference algorithm and corresponding intervals in the repository. It is the schematic showing the correspondence interval of the version which shows an anchor set, and a repository. It is a flowchart which shows the example step which calculates an anchor set by one Embodiment of this invention, and performs a binary difference process with respect to each anchor set. It is a figure which shows the more detailed procedure of the step which processes the anchor set which becomes one Embodiment. FIG. 2 is a schematic diagram representing a version and repository showing anchors in an anchor set according to an embodiment of the present invention. FIG. 12 is a schematic diagram representing the same version and repository of FIG. 11 showing the expansion step of matching around the anchor. FIG. 12 is a schematic diagram representing the same version and repository of FIG. 11 showing the steps of calculating the hash value between the expanded anchors in the repository. FIG. 12 is a schematic diagram of the same version and repository of FIG. 11 showing the steps for extending the version and the corresponding and corresponding matches in the repository. FIG. 2 illustrates an example system environment. FIG. 2 illustrates an alternative general purpose system architecture. FIG. 6 is a flowchart illustrating exemplary steps for updating a remote repository using a minimum bandwidth. 6 is a flowchart illustrating exemplary transfer steps of version data from one system to another.

Explanation of symbols

17 Data Repository 44 Index 50 Repository Chunk 51 Input Data Chunk 52 Repository Data Chunk 53 Repository 55i-59i, 55r-59r Identification Characteristic 1602 First Location (Server A)
1604 Remote location (Server B)

Claims (27)

In the system of dividing the input data supplied to the repository (53) searches the repository data in the repository for similar data to the input data, the input data to one or more input chunks (51),
Means for calculating a corresponding set of input identification characteristics (IDC) for each input chunk, each IDC set including a plurality of identification characteristics (55i-59i), wherein the means assigns each input chunk to a plurality of seeds ( s), arranging each seed as a small part of each input chunk in a seed sequence, applying a hash function to each seed to generate a plurality of hash values, Said system comprising said means for providing a hash value,
It said means for calculating is operative to select a subset of the plurality of hash values,
Identifying the position of the seed in the seed sequence corresponding to the selected subset of hash values;
By applying a function to the identified said position to identify the corresponding other positions within the seed sequence,
The system defining the IDC set as a hash value of the seed at the specified other position. The system according to claim 1, comprising means for transmitting the IDC set calculated by the calculating means to a remote location where the repository is located. A system that searches repository data for data similar to input data and divides the repository data into one or more repository chunks (50),
Means for calculating a corresponding set of repository identification characteristics (RDC) for each repository chunk, each RDC set including a plurality of identification characteristics (55r-59r), wherein the means assigns each repository chunk to a plurality of seeds ( s), arranging each seed as a small part of each repository chunk in a seed sequence, applying a hash function to each seed to generate a plurality of hash values, Comprises the means for providing a hash value;
Means for maintaining an index (44) associated with each RDC set and the corresponding repository chunk;
Comparing the set of input identification characteristics (55i-59i) of the input chunk (51) of the input data with one or more RDC sets stored in the index, and similar between the input chunk and the corresponding repository chunk Means for determining whether a sex exists,
The means for determining operates to determine that similarity exists if the similarity threshold j of the input discriminant feature set is detected in the RDC set stored in the index;
Operated such that the means for calculating to select a subset (k) of the plurality of hash values,
Locating the seed within the seed sequence corresponding to the selected subset of the hash values;
Applying a function to the identified position to identify a corresponding other position in the seed sequence;
Defining the RDC set as a hash value of the seed at the identified other location. The hash value set (k) is selected by identifying k maximum hash values;
4. A system according to any one of the preceding claims, wherein a function applied to determine the corresponding other position identifies the next seed in the seed (s) sequence. The means further comprising: determining means for comparing one or more differences between the input chunk (51) and the repository chunk (52) determined to be similar by comparing all data of the input chunk. 3. The system according to 3. The system of claim 5, further comprising means for storing the identified differences in the same repository (53) that stores the repository data. The system according to claim 3, wherein the system is used for at least one of data factoring and data backup.   A network-connected computer system, wherein the first computer providing the system of claim 1 at a first computer at a first location and the system of claim 3 at a second computer at a remote location And storing the repository data in a data repository (17) accessed via the second computer, wherein the first and second computers are in network communication with each other. A network-connected computer system characterized by the above. Determines that the entire input chunk without transmitting to the remote location and without transmitting the determined repository chunk and the similarity is present to all the first position, said similarity exists between the input chunk Means for identifying one or more differences between the selected repository chunks , wherein the means for identifying identifies the input data and at least one common data section or non-common data section of the repository data. A pair of identification characteristic positions that define the corresponding intervals in the repository data and the input data that are determined to be similar to the input chunk are defined as anchors. Using at least one of the common data section and the non-common data section. Deployment calculate the network connection computer system of claim 8. A recording medium storing a program for causing a computer to execute a method of searching repository data for data similar to input data and dividing the repository data into one or more repository chunks (50) ,
Calculating a corresponding set of repository identification characteristics (RDC) (55r-59r) for each repository chunk, wherein the RDC set includes a plurality (n) of identification characteristics (55r-59r);
Maintaining an index (44) associated with each RDC group and the corresponding repository chunk;
Calculating an input identification characteristic (55i-59i) (IDC) for an input chunk (51) of the input data;
The comparison with the IDC 1 or more RDC set the (55I～59i) stored in said index (44) (55R～59r), similarity exists between the input chunk and the corresponding repository chunk In the step of determining whether the RDC and the IDC are
Partitioning each of the input chunk (51) and the repository chunk ( 52 ) into a plurality of seeds (s), and arranging each seed in a seed sequence as a small part of the input chunk and the repository chunk;
Applying a hash function to each seed to generate a plurality of hash values, and causing each seed to obtain a hash value by performing the steps of:
Calculating an IDC set for each input chunk, the IDC set comprising a plurality (k) of identification characteristics, and comparing the IDC set with the RDC set;
If a similarity threshold (j) of the identification characteristic of the IDC set is detected in the RDC set stored in the index, determine that there is similarity;
Selecting each of the RDC set and the IDC set as further steps, i.e. selecting a subset (k) of the plurality of hash values;
Identifying a seed position in the seed sequence corresponding to the selected subset of hash values;
Applying a function to the identified seed locations to identify other corresponding locations in the seed sequence;
A recording medium obtained by executing the step of defining the IDC set and the RDC set as a hash value of the seed at the other specified position. Selecting a subset of the hash values by identifying k largest hash values;
The recording medium of claim 10, wherein the function applied to identify the corresponding other location identifies a next seed in the seed sequence. The program further to execute a step of specifying by comparing all data of the input chunk 1 or more the difference between the repository chunk is determined that the input chunk and similarity exists, it claims 10 The recording medium described. The repository data further to execute a step of storing the difference that has been identified in the same repository (53) in which to store the claim 12 recording medium according. The input data is located at a first location, the repository data and the index are located at a remote location, and the program further comprises:
Identifying the IDC set (55i-59i) at the first location (1602);
Transmitting the calculated IDC set from the first location to the remote location (1604);
Comparing the identified IDC set to one or more RDC sets at the remote location;
Determines that the entire input chunk without transmitting to the remote location and without transmitting the determined repository chunk and the similarity is present to all the first position, said similarity exists between the input chunk comprising the steps of: identifying one or more differences between the repository chunks, the input data and the repository data for at least one common data section or non-common data section for use in identifying Defining a corresponding interval in the input data and the repository data, using as a anchor a pair of discriminating characteristic positions where the discriminating characteristics of the repository chunks determined to be similar to the input chunk are used as anchors; Calculate the two common data sections and the non-common data sections That to execute the steps, the recording medium according to claim 13, wherein a. 15. The recording medium according to claim 14 , wherein the program further executes a step of storing the difference specified in the remote location (1604). The program, Ru is used in at least one of the data factoring and data backup, recording medium according to any one of claims 10 to 15. The recording medium according to any one of claims 10 to 16, wherein the similarity threshold matches when a predetermined number of identification characteristics in the IDC set are detected in the RDC set. The subset (k) of the plurality of hash values is k maximum arithmetic hash values in the set, and the function applied to the identified seed position is applied to each of the k maximum arithmetic hash values. The recording medium according to claim 10, wherein the following sequential seed is adopted for each corresponding seed. The recording medium according to claim 10, wherein the hash function is selected from a rolling hash function and a modular hash function. The recording medium according to claim 10, wherein the RDC set is stored in the index as at least one of a binary tree, a B-tree, a rearrangement list, and a hash table. The recording medium according to claim 10, wherein each seed is a continuous series of basic elements and has the same seed size s. The recording medium according to claim 21, wherein the seed includes an overlapping seed. Whether determining whether the similarity in comparison with one or more RDC set the IDC is present, run in the running time for the input data which is proportional to the size of independent the input data of the size of the repository is the recording medium according to any one of claims 10 to 22. In a way to find repository data for data similar to the input data, a recording medium storing therein a program for executing the method on a computer for dividing the repository data into one or more repository chunks (52), said program But,
Calculating a corresponding set of repository identification characteristics for each repository chunk (52), wherein each RDC set includes a plurality of identification characteristics (55r-59r), and each repository chunk is divided into a plurality of seeds (s); Each seed is permuted in a seed sequence as a small part of each repository chunk, and a hash function is applied to each seed to generate a plurality of hash values. Said step yielding two hash values;
A step of holding the index (44) associated with the corresponding repository chunk with each RDC set,
Wherein comparing an input signature (55i~59i) set of input chunks of the input data with one or more RDC set stored within the index, there is a similarity between the corresponding repository chunk to the input chunk A step of determining whether or not to perform ,
If the similarity threshold signature of said input distinguishing characteristics in the set (j) is detected in the RDC set stored in the index, the similarity between the repository chunks said corresponding with the input chunk Determine that it exists,
The RDC set is
Selecting a subset (k) of the plurality of hash values;
Identifying a seed position within the seed sequence corresponding to the selected subset of the hash values;
Applying a function to the identified seed locations to identify other corresponding locations in the seed sequence;
A recording medium that causes the computer to execute the step of acquiring the IDC set as a hash value of the seed at the other specified position. A recording medium storing a program for supplying input data to a repository (53) and causing a computer to execute a method for searching repository data in the repository for data similar to the input data, the program comprising:
Dividing the input data into one or more input chunks (51);
Calculating an input identification characteristic (IDC) set for each of the input chunks, the input identification characteristic set including a plurality of characteristics (55i-59i); and
Partitioning each input chunk into a plurality of seeds (s), and arranging each seed in a permutation in a seed sequence forming a small portion of each input chunk;
Applying a hash function to each seed to generate a plurality of hash values, each seed yielding a hash value;
Selecting a subset (k) of the plurality of hash values;
Identifying a seed position in the seed sequence corresponding to the selected subset of hash values;
Applying a function to the identified seed location to identify a corresponding other location in the seed sequence;
A recording medium that causes the computer to execute the step of acquiring the IDC set by defining the IDC set as a hash value of the seed at the other specified position. In a method for identifying input data within repository data, the repository data includes a repository data chunk (50), the input data includes an input data chunk (51), and each repository data chunk has a repository data chunk identification characteristic ( RDC) is a recording medium having a corresponding set, storing each identification characteristic (55r to 59r) together with a characteristic position , and a program for causing a computer to execute the method of spreading the characteristic position over the entire chunk. The program for each input data chunk,
Identifying a set of input data chunk identification characteristics (IDC), wherein each of the identification characteristics (55i-59i) has a characteristic position, and the characteristic position is spread throughout the chunk;
Comparing the IDC in the identified IDC set to one or more RDC sets;
To execute and identifying as a function of comparing the identified IDC set repository chunk that is similar to one or more of RDC set to the input data to the computer, a recording medium. In a method that includes identification of input data within repository data, the repository data includes repository data chunks, the input data includes input data chunks, and each repository data chunk has a corresponding set of repository data chunk identification characteristics. A recording medium storing a program for causing a computer to execute the method of storing each identification characteristic together with an RDC characteristic position, wherein the program is, for each input data chunk,
Identifying an input data chunk identification characteristic (IDC) set, wherein each identification characteristic has an IDC characteristic position;
Subsequently comparing the identified IDC set to one or more RDC sets;
Identifying a repository chunk similar to the input data as a function of comparing the identified IDC set against the one or more RDC sets, wherein a predetermined number of identification characteristics in the IDC set match in the RDC set Identifying the repository chunks as similar when detected; and
A recording medium that causes the computer to execute at least a pair of matching IDCs and outputting the IDC and RDC positions of an RDC.