CN105579980A - Deduplication of parity data in ssd based raid systems - Google Patents

Abstract

The present disclosure describes various techniques related to maintaining parity data in a redundant array of independent disks (RAID).

Description

Deduplication of parity data in RAID system based on SSD

Background technique

In some computing applications, multiple storage devices (eg, mechanical storage devices, solid-state drive (SSD) devices, etc.) may be configured to act as a single logical storage device. This configuration may be referred to as a Redundant Array of Independent Disks (RAID). Various RAID configurations can utilize an error protection scheme called "parity" to provide some level of fault tolerance. In general, a RAID configuration using parity may generate parity data corresponding to data stored in the RAID and store the parity data in the parity portion of the RAID. The parity data can then be used to recover from errors (eg, data corruption, drive failure, etc.) affecting the data stored in the RAID. However, in order to maintain fault tolerance, whenever new data is written into the RAID, the parity data needs to be regenerated and rewritten into the parity part of the RAID. In the case of a RAID configuration in which the parity data is stored on the SSD device, continuously rewriting the parity data into the RAID will result in increased wear of the SSD and/or increased power consumption of the RAID.

Summary of the invention

Detailed herein are various exemplary methods of maintaining parity data in a RAID, which may be embodied as any of a variety of methods, apparatus, systems, and/or computer program products.

Some example methods may include, at a RAID control module, receiving a request to write a data unit to a data store of the RAID, wherein the RAID has a current data unit stored in the data store and has a current data unit stored in the current parity data in a parity data storage portion of the RAID; determining temporary data based at least in part on an exclusive OR (XOR) between the data unit and the current data unit in response to a request to write the data unit; determining new parity data based at least in part on an XOR operation between the temporary data and the current parity data; deduplicating the new parity data to determine whether any portion of the new parity data is part of the current parity data and repeating; and writing the part of the new verification data that is determined not to be a duplicate of the part of the current verification data into the verification data storage unit of the RAID.

The present disclosure also describes various example machine-readable non-transitory storage media having stored therein various examples of instructions operable, in response to being executed by one or more processors, to cause a RAID Redundant Array of Independent Disks (RAID ) control module is capable of determining temporary data based at least in part on an exclusive OR (XOR) operation between a particular data unit and a first data unit in response to a request to write a particular data unit to the RAID, which may have a a data store associated with the data unit, and the RAID has a check data store associated with the first check data; determining a second check based at least in part on an XOR operation between the temporary data and the first check data data; deduplicating the second verification data to determine whether any part of the second verification data is a repetition of a part of the first verification data; and determining that the second verification data is not the first verification data The overlapping portion of the data portion is written into the parity data storage unit of the RAID.

This disclosure additionally describes example systems that may include a Redundant Array of Independent Disks (RAID) having a current data unit stored in a data store and having a current parity stored in a parity data store of the RAID data; and a RAID control module communicatively coupled to the RAID. In an example, the RAID control module includes a data input/output module, which is operable to receive a request to write a data unit into a data storage part of the RAID, and the RAID module may also include a check and hold module, a check and hold module It is configured to: compare the data unit with the current parity data in response to a request to write the data unit to determine the temporary parity data; compare the temporary parity data with the current parity data to determine the new parity data; The verification data is split into a plurality of new verification data blocks; a hash table is constructed, and the hash table associates each of the plurality of first hash values with different blocks in the new verification data blocks, and associating each of the plurality of second hash values with a different block of the current check data; and determining a new check data based on a comparison of the plurality of first hash values and the plurality of second hash values A non-repeating block comprising at least a portion of a data unit.

Description of drawings

The subject matter that is claimed is particularly pointed out and distinctly claimed in the specification and claims. The foregoing and other features of the present disclosure will become more fully apparent from the following description and appended claims, given below in conjunction with the accompanying drawings. It should be understood that the drawings depict only embodiments in accordance with the disclosure and are therefore not to be considered limiting of its scope. The present disclosure will be described with additional specificity and detail, by use of the accompanying drawings.

In the attached picture:

Figure 1a shows a block diagram of a system including an example of RAID;

Fig. 1 b shows a block diagram of example current parity data and blocks of current parity data;

Figure 1c shows a block diagram of an exemplary hash table;

Figure 2a shows a block diagram of an example system including RAID;

Figure 2b shows a block diagram of exemplary new parity data and blocks of new parity data;

Figure 2c shows a block diagram corresponding to an example hash value of a block of new check data;

Figure 2d shows a block diagram of an exemplary check data deduplication;

Figure 2e shows a block diagram of an example of a hash table updated based on deduplication data;

Figure 3 shows a flow chart of an example method for maintaining parity data for RAID;

Figure 4 shows an exemplary computer program product;

5 illustrates a block diagram of an example computing device, all arranged in accordance with at least some embodiments of the present disclosure.

Detailed description of the invention

The following description sets forth various examples and specific details to provide a thorough understanding of claimed subject matter. Claimed subject matter may be practiced without some or more of the specific details disclosed herein. Furthermore, in some instances, well known methods, procedures, systems, components and/or circuits have not been described in detail so as not to unnecessarily obscure the claims. In the following detailed description, reference is made to the accompanying drawings, which form a part hereof. In the drawings, similar symbols typically identify similar components, unless context dictates otherwise. The exemplary embodiments described in the detailed description, drawings, and claims are not meant to be limiting. Other embodiments may be utilized, and other changes may be made, without departing from the spirit or scope of the subject matter presented herein. As generally described herein and illustrated in the drawings, the disclosed aspects can be arranged, substituted, combined and designed in various different configurations, all of which are expressly conceived herein and form part of this disclosure.

In particular, the present disclosure relates to methods, apparatus, systems and/or computer program products related to maintaining parity data for RAID.

Generally, a RAID device may include multiple storage devices configured to act as a single logical unit of storage. Generally, a RAID device may consist of two or more individual storage devices and be organized in various configurations (eg, RAID1, RAID2, RAID3, RAID4, RAID5, RAID6, RAID10, etc.). Various RAID configurations can provide some level of fault tolerance. For example, the parity error protection scheme described above can be implemented in some RAID configurations (eg, RAID2, RAID3, RAID4, RAID5, RAID6, RAID10, etc.).

In general, parity error protection schemes can provide fault tolerance by determining parity data based on data stored in the RAID. The parity data can then be used to recover from errors (eg, data corruption, drive failure, etc.) affecting the data stored in the RAID. As an example, a RAID device may include first, second and third individual storage devices. The RAID device may be configured to store data on first and second individual storage devices, and to store parity data on a third individual storage device. The RAID device may generate parity data based on an exclusive OR (XOR) operation between data stored on the first single storage device and data stored on the second single storage device. The RAID device can store the determined verification data in a third single storage device. The RAID device can then use the parity data stored on the third individual storage device to "recover" the data stored on the first individual storage device or the second individual storage device. For example, assume a first single storage device fails. The data stored on the first single storage device may be restored based on an XOR operation between the data stored on the second single storage device and the check data stored on the third single storage device.

In order to maintain fault tolerance, parity data needs to be continuously regenerated and stored in the RAID device. More specifically, when new data is written (or changes are made to existing data) in the RAID device, parity data may need to be regenerated. For example, using the RAID configuration described above, if the data stored on the first individual storage device changes, the parity data stored on the third individual storage device may no longer be used to recover data stored on the first individual storage device or the third individual storage device. Two data on a single storage device. Therefore, new parity data needs to be determined (eg, based on an XOR operation between the changed data stored on the first single storage device and the data stored on the second single storage device). This new parity data can be written to a third individual storage device, as described above.

For a RAID device that uses a solid-state storage device (SSD) to store its parity data, writing new parity data to the RAID device multiple times continuously or in other ways will lead to increased wear and tear in the SSD used to store the parity data. Additionally, the amount of power used to operate a RAID device can increase due to the need to erase data on the SSD before writing new data (or existing data changes) and due to the frequent manner in which large amounts of parity data are written to the SSD.

Various embodiments of the present disclosure may provide for maintaining parity data in a RAID device. In particular, some embodiments of the present disclosure may facilitate maintaining parity data in which at least some data sets need not be rewritten to the RAID device whenever changes to data stored in the RAID device occur.

Using the configuration described above, the following non-limiting examples are provided to further illustrate some embodiments of the present disclosure. As mentioned above, the first and second individual storage devices may be used to store data, while the third single storage device may be used to store check data. As part of storing the parity data in the RAID device, the parity data can be split into smaller pieces (blocks) and a hash of each block can be generated.

In an example, data in the first and second individual storage devices may be organized into pages. Pages can have specific dimensions. The blocks of parity data may be split into various sizes, for example one or more blocks may be of a first size which may be substantially similar to a page of data in the first and second single storage devices. In an example, one or more blocks may have a second size that is less than or equal to the first size, such as, for example, 4 kilobytes. A hash table may be used to store the hashes and record where the data corresponding to each block is stored on the third single storage device (eg, memory location, etc.).

When new data is written into the RAID device, the new parity data can be determined by: determining the temporary data based on the XOR operation between the new data and the current data; and based on the XOR operation between the temporary data and the current parity data to determine the new calibration data. For example, assume that new data is written to a first single storage device. Temporary data may be determined based on an XOR operation between new data (eg, data now stored on the first single storage device) and current data (eg, data stored on the second single storage device). Then, new check data may be determined based on an XOR operation between the temporary data and the current check data (for example, check data stored on the third single storage device).

Portions of the new parity data may be "deduplicated" to determine portions of the new parity data that are different from portions of the current parity data. The portion of the new parity data determined to be different from the current parity data may be written to the third single storage device. However, the same portion of the new parity data as that of the current parity data need not be rewritten to the third single storage device. An example deduplication process may include breaking new parity data into chunks (eg, as described above in connection with current parity data). A hash may be generated for each block of new check data and compared to the hash of the current check data stored in the hash table. Based on this comparison, any block of new parity data that is found to correspond to a block of current parity data need not be written to the third single storage device. Based on this comparison, blocks of new parity data that are found not to correspond to any blocks of current parity data may be written to the third individual storage device. The hash table may also be updated accordingly (eg, update hash, update location, etc.).

Accordingly, the parity data in the RAID device can be maintained (e.g., kept up to date based on the most recently stored data in the RAID device), wherein portions (e.g., blocks) of new parity data may not need to be checked every time new parity data is generated. Both are rewritten to the third single storage device. This results in a reduction in the amount of parity data written to the RAID device each time new parity data is determined. Therefore, a substantial reduction in the wear and tear of the SSD for storing parity data can be achieved. Furthermore, a substantial reduction in the amount of power consumed by the RAID device can be achieved.

The above examples are given for illustration purposes only and are not intended to be limiting. In particular, the above example can be applied to RAID configurations comprising more than three individual storage devices. Furthermore, the above examples can be applied to RAID configurations that mirror data between storage devices, write data to storage devices based on striping, and/or a combination of both and/or other configurations. Additionally, various examples of the present disclosure may refer to solid-state storage, solid-state storage devices as well as SSDs and/or other types of storage devices. At least some embodiments described herein may use various types of solid state technologies (eg, Flash memory (Flash), DRAM, phase change memory, resistive RAM, ferroelectric RAM, nanoRAM, etc.). Additionally, at least some embodiments are applicable to multi-element storage arrays in which one or more elements may be non-SSD type storage devices. For example, with some embodiments, a RAID array may consist of a combination of spinning disk storage and SSD storage.

Figure 1a shows a block diagram of an example system 100 arranged in accordance with at least some embodiments of the present disclosure. As can be seen in FIG. 1 a , system 100 may include computing device 110 and RAID device 120 , which are communicatively coupled via connection 130 . In some examples, connection 130 may be an Internet connection, an optical connection, a LAN connection, a wireless connection, a PCIe connection, an eSATA connection, a USB connection, connection, or any other suitable connection for transferring data between computing device 110 and RAID device 120 . In some examples, RAID device 120 and computing device 110 may be housed in the same housing (eg, housing, box, rack, etc.), including integrated within or as a common electronic device. In some examples, RAID device 120 and computing device 110 may be housed in separate enclosures.

RAID device 120 may include a RAID controller 140 and a storage drive array 150 operably coupled to RAID controller 140 . In general, storage drive array 150 may be comprised of any number of individual storage devices configured to act as a single logical storage device. In practice, storage drive array 150 may consist of at least three individual storage drives. For example, in the above solution, the storage drive array includes two data drives (for example, a first single storage device and a second single storage device) and one check drive (for example, a third single storage device). As another example, storage drive array 150 may consist of four data drives and one parity drive. Various other exemplary RAID configurations and methods of writing data to the data drives in the storage drive array 150 are described above. Any practical number of example RAID configurations may be provided. Therefore, the remainder of this disclosure assumes that storage drive array 150 includes data storage 151 and parity data storage 152 . There is no intention to further differentiate the locations of the data storage section 151 and the check data storage section 152 on a single storage device. Actually, however, the data storage section 151 may be implemented between a plurality of individual storage devices (for example, the first and second individual storage devices as described above). Similarly, parity data storage may be implemented between more than one single storage device.

In general, RAID controller 140 may be configured to provide read/write access to RAID device 120 . As shown, RAID controller 140 may include a data input/output (I/O) module 141 configured to provide read and/or write access to data storage 151 of storage drive array 150 . For example, RAID controller 140 may receive data from computing device 110 to be stored on RAID device 120 and may utilize data I/O module 141 to cause the data to be stored in data store 151 . As another example, RAID controller 140 may receive a request from computing device 110 to read data from the RAID device and may utilize data I/O module 141 to provide the data to computing device 110 . In some examples, the data may be documents, images, videos, archive files, or generally any digital file and/or data that may be stored on storage drive array 150 . For example, a data store 151 comprising current data 153 and old data 154 is shown in Figure Ia in a state prior to receipt of new data as shown and described in Figure 2a and prior to updating of the check data.

RAID controller 140 may also include a parity data maintenance (maint.) module 142 . In general, the parity data retention module 142 may be configured to implement an error protection scheme (eg, the parity scheme described above). More specifically, the verification data holding module 142 may be configured to generate verification data based on data stored in the data storage unit 151 . For example, the check data holding module 142 may be configured to determine the current check data 155 based on an XOR operation between the current data 153 and the old data 154 . Parity data retention module 142 may also be configured to read parity data (e.g., current parity data 155) and/or write parity data (e.g., current parity data 155) to parity data of storage drive array 150 Section 152. The parity data retention module 142 may also be configured to rebuild the data store 151 in the event of an error (eg, data corruption, drive failure, etc.). For example, the parity data retention module 142 may be configured to restore the current data 153 based on an XOR operation between the current parity data 155 and the old data 154 . Similarly, the parity data retention module 142 may be configured to restore the old data 154 based on an XOR operation between the current parity data 155 and the current data 153 . In an example, the data I/O module 141 and/or the parity data holding module 142 may be implemented by hardware, software, one or more executable code blocks, a combination of hardware and software, etc., or any combination thereof. species to achieve.

As part of generating the current parity data 155, the parity data retention module 142 may be configured to break the current parity data 155 into smaller pieces (eg, blocks). For example, FIG. 1 b shows current parity data 155 split into four blocks 156 a , 156 b , 156 c , and 156 d , arranged in accordance with at least some embodiments of the present disclosure. The check data holding module 142 can be further configured to generate a hash corresponding to each block 156 (for example, such as Berkeley Software Distribution (BSD) checksum, Message-DigestAlgorithm2 (MD2), Message-DigestAlgorithm4 (MD4), Message-DigestAlgorithm5 (MD5) , Message-DigestAlgorithm6 (MD6), etc.). For example, Figure 1c shows blocks 156a, 156b, 156c, and 156d and corresponding hash values 157a, 157b, 157c, and 157d, arranged in accordance with at least some embodiments of the present disclosure. Figure 1c further shows pointers 158a, 158b, 158c and 158d corresponding to blocks 156a, 156b, 156c and 156d, respectively. Generally, the pointers 158a-158d may include the location (eg, address value, etc.) of the corresponding block 156a-156d within the current parity data store 152 of the storage drive array 150. For example, pointer 158a may include an address value corresponding to the location of block 156a of current parity data 155 stored in parity data store 152 . Checksum data holding module 142 may be configured to store data including hash values 157a-157d and pointers 158a-158d in hash table 143. For example, FIG. 1 a shows a hash table 143 . In some examples, hash table 143 may be stored at a memory location in RAID controller 140 like that shown in FIG. 1a. In other examples, hash table 143 may be stored in storage drive array 150, for example, in data store 151 and/or parity data store 152, in computing device 110, in a separate stand-alone device , stored on different RAID devices and/or similar devices or a combination thereof.

As mentioned, RAID controller 140 may receive new data from computing device 110 that is to be stored in RAID device 120 . Accordingly, data stored in data storage 151 of storage drive array 150 may change (eg, as new and/or updated data is received from computing device 110 ). For example, FIG. 2a shows system 100 of FIG. 1a in which current data 153 and new data 201 are stored in data store 151 of storage drive array 150, arranged in accordance with at least some embodiments of the present disclosure. Therefore, the current parity data 155 may not be sufficient to provide fault tolerance of the data storage 151 . More specifically, parity data retention module 142 may not be able to restore current data 153 and/or new data 201 based on current parity data 155 . The verification data holding module 142 may be configured to update the verification data storage unit 152 and the hash table 143 in response to changes in the data stored in the data storage unit 151 .

Generally, the verification data holding module 142 can be configured to determine new verification data based on the current data 153 , the new data 201 and the current verification data 155 . The verification data holding module 142 may also be configured to update the verification data storage unit 152 and the hash table 143 to correspond to the new verification data as described above (eg, to deduplicate the new verification data). For example, in some embodiments, the verification data retention module 142 can determine the new verification data as follows: the temporary verification data can be determined based on the XOR operation between the current data 153 and the new data 201; the temporary verification data can be determined based on the current verification data 155 XOR operation with the determined temporary check data to determine new check data. Figure 2b illustrates new parity data 205 that may be generated by parity data retention module 142 as described above, arranged in accordance with at least some embodiments of the present disclosure. The parity data retention module 142 may also be configured to split the new parity data 205 into blocks. For example, FIG. 2b also shows new parity data 205 split into blocks 207a, 207b, 207c, and 207d. Checksum data retention module 142 may also be configured to determine a hash based on blocks 207a-207d. For example, Figure 2c shows blocks 207a, 207b, 207c, and 207d and corresponding hash values 209a, 209b, 209c, and 209d, respectively, arranged in accordance with at least some embodiments of the present disclosure. The verification data holding module 142 may also be configured to store the hash values corresponding to the new verification data 205 (for example, hash values 209a-209d) and the hash values corresponding to the current verification data 155 (for example, in the hash The hash values 157a-157d) in the list 143 are compared. For example, Figure 2d illustrates hash values 209a-209d compared to hash values 157a-157d, arranged in accordance with at least some embodiments of the present disclosure. As shown, hash value 209a may be similar to hash value 157d. Additionally, as shown, hash value 209c may be similar to hash value 157a.

Hash values identified as similar may indicate that corresponding blocks contain the same data. For example, blocks 207a and 207c may contain the same data as blocks 156d and 156a corresponding to hash values 157d and 157a, respectively. Accordingly, portions (eg, blocks) of current parity data 155 corresponding to portions (eg, blocks) of new parity data 205 need not be rewritten into parity data storage 152 . For example, blocks 207a and 207c need not be written to parity data store 152 because they are already represented by blocks 156d and 156a corresponding to hash values 157d and 157a, respectively. Instead, parity data retention module 142 may be configured to write one or more of blocks 207a-207d from new parity data 205 not yet stored in parity data store 152, such as blocks 207b and 207d, thereby forming The updated verification data 203 .

In addition to identifying blocks 207a-207d of new parity data 205 that are duplicates of one or more blocks 156a-156d of current parity data 155, parity data retention module 142 may be configured to determine that new parity data 205 has Blocks 207a-207d of the same hash value 209a-209d. The parity data retention module 142 may be configured to write one of two or more blocks 207a-207d that are identified as being duplicates of each other. For example, Figure 2c shows that hash values 209b and 209d may be identical to each other. Therefore, blocks 207b and 207d duplicate each other. Therefore, the parity data holding module 142 may be configured to write the block 207b or 207d into the parity data storage 152 .

The verification data holding module 142 can also be configured to update the hash table 143 . For example, Figure 2e illustrates an updated hash table 143 corresponding to new check data 205, arranged in accordance with at least some embodiments of the present disclosure. For example, FIG. 2e shows blocks 207a-207d of new parity data 205. FIG. Additionally, hash values 209 a - 209 d are shown in hash table 143 . Additionally, the hash table shows pointers 158a, 158d and 211a. More particularly, using FIG. 2e as an example, blocks 207a and 207c from new parity data 205 are represented in updated parity data 203 by blocks 156d and 156a, respectively. Accordingly, pointers corresponding to blocks 207a and 207c may be updated to correspond to pointers from blocks 156d and 156a, respectively (eg, 158d and 158a). Since both blocks 207b and 207d can be represented by the same block (eg, 207b or 207d) in the updated parity data 203, their pointers (eg, 211a) can be the same. In some examples, parity data retention module 142 may overwrite one or more of blocks 156a-156d of current parity data 155 (e.g., if blocks 156a-156d are not duplicates of blocks 207a-207d, etc.) One or more of the blocks 207 a - 207 d of the new verification data 205 are written into the verification data storage unit 152 to generate the updated verification data 203 . In some examples, parity data retention module 142 may write one or more of blocks 207 a - 207 d to unused space in parity data store 152 to generate updated parity data 203 .

3 illustrates a flowchart of an example method of maintaining parity data for RAID, arranged in accordance with at least some embodiments of the present disclosure. In some portions of the description, exemplary embodiments of the method shown in FIG. 3 and elsewhere herein may be described with reference to elements of system 100 depicted in FIGS. Method to realize. However, the described embodiments are not limited to this depiction. More specifically, some of the elements depicted in Figures 1a, 1b, 1c, 2a, 2b, 2c, 2d, and/or 2e may be omitted from some implementations of the methods detailed herein. Additionally, other elements not shown in Figures 1a, 1b, 1c, 2a, 2b, 2c, 2d, and/or 2e may be used to implement the methods of the examples detailed herein.

Additionally, FIG. 3 employs a block diagram to illustrate the example methodology detailed therein. These block diagrams may set forth various functional blocks or actions described as processing steps, functional operations, events and/or behaviors, etc., and may be implemented by hardware, software and/or firmware. Several alternatives to the functional blocks detailed can be practiced in various implementations. For example, intermediate acts not shown in the figure and/or additional acts not shown in the figure may be sampled and/or some acts implemented in the figure may be removed, modified or split into multiple acts. In some examples, actions shown in one figure may be performed using techniques discussed with respect to another figure. Additionally, in some examples, the acts illustrated in these figures may operate using parallel processing techniques. The above-described and other non-described rearrangements, substitutions, changes, modifications, etc. may be made without departing from the scope of the claimed subject matter.

FIG. 3 illustrates an example method 300 of maintaining parity data for a RAID device, arranged in accordance with various embodiments of the present disclosure. Method 300 may begin at block 310 "Receive a request to write a data unit into a data store of a RAID," a RAID controller may include logic and/or features configured to receive data to be written to a RAID device. For example, RAID controller 140 may receive data from computing device 110 to be written to RAID device 120 . Generally, in block 310 RAID controller 140 may receive data from computing device 110 (eg, via connection 130 ).

Processing may continue from block 310 to block 320 "determine temporary data based at least in part on an exclusive OR (XOR) operation between the data unit and the current data unit", the RAID controller may include a XOR operation between them to determine the logic and/or characteristics of the temporary data. For example, the parity data retention module 142 of the RAID controller 140 may determine the temporary data based on an XOR operation between the current data 153 and the new data 201 .

Processing may continue from block 320 to block 330, "determine new parity data based at least in part on an XOR operation between the temporary data and the current parity data", the RAID controller may include a The XOR operation between the data is used to determine the logic and/or characteristics of the new check data. For example, the parity data retention module 142 of the RAID controller 140 may determine the new parity data 205 based on an XOR between the temporary data and the current parity data 155 .

Processing may continue from block 330 to block 340, "Deduplicate the new parity data to determine whether any portion of the new parity data is a duplicate of a portion of the current parity data", the RAID controller may include Check data deduplication to determine whether the part of the new check data is a duplicate logic and/or feature of the part of the current check data. For example, the verification data retention module 142 of the RAID controller 140 may deduplicate the new verification data 205 . Generally, in block 340, the parity data retention module 142 may split the new parity data 205 into chunks 207a-207d and generate a hash value 209a-209d for each chunk 207a-207d. The parity data retention module 142 of the RAID controller 140 may then compare the hash values 209a-209d with the hash values 157a-157d stored in the hash table 143 to determine any blocks 207a-207d of the new parity data 205 Is it a repeat of blocks 156a-156d. In some examples, the hash values 209a-209d may also be processed to determine whether any block of 207a-207d is a repeat of another block of 207a-207d.

Processing may continue from block 340 to block 350, "write the duplicate portion of the new parity data that is determined not to be part of the current parity data into the parity storage of the RAID", the RAID controller may include a The logic and/or features of writing the portion of the new parity data that is determined not to be a duplicate of one or more portions of the current parity data into the parity data storage of the RAID. For example, the parity data retention module 142 of the RAID controller 140 may write the one or more blocks 207a-207d determined not to be duplicates of the one or more blocks 156a-156d into the parity data storage unit 152.

Additionally, in block 340 and/or block 350 , the RAID controller may include logic and/or features configured to update the hash table based in part on the deduplication of block 340 . For example, the parity data retention module 142 may update the hash table 143 based on deduplication of the new parity data 205 .

In one embodiment, the methods described with respect to FIG. 3 and elsewhere herein may be implemented as a computer program product executable on any suitable computing system, or the like. An exemplary computer program product may be depicted in FIG. 4 in color, as well as elsewhere herein.

FIG. 4 illustrates an example computer program product 400 arranged in accordance with at least some embodiments of the present disclosure. Computer program product 400 may include a machine-readable, non-transitory medium having instructions stored therein that, in response to execution (e.g., by a processor), cause the RAID controller module to maintain parity data in the RAID, as discussed herein . Computer program product 400 may include signal bearing medium 402 . Signal-bearing medium 402 may include one or more machine-readable instructions 404 that, in response to being executed by one or more processors, may be operable to enable a computing device to provide the features described herein. In various examples, some or all of the machine-readable instructions may be used by an apparatus as discussed herein.

In some examples, the machine-readable instructions 404 may include detecting a request to write a data unit to a data store of a RAID having the current data unit stored in the data store and having a parity data store stored in the RAID's parity data store. The current checksum data. In some examples, machine-readable instructions 404 may include determining temporary data based at least in part on an exclusive OR (XOR) operation between the data unit and the current data unit in response to a request to write the data unit. In some examples, machine readable instructions 404 may include determining new parity data based at least in part on an XOR operation between the temporary data and the current parity data. In some examples, the machine-readable instructions 404 may include deduplicating the new parity data to determine whether any portion of the new parity data is a duplication of part of the current parity data. In some examples, the machine-readable instructions 404 may include writing a portion of the new parity data that is determined not to be a duplicate of a portion of the current parity data into the parity data store of the RAID.

In some implementations, signal bearing media 402 may comprise computer-readable media 406 such as, but not limited to, a hard drive, compact disc (CD), digital versatile disc (DVD), digital tape, memory, and the like. In some implementations, signal bearing media 402 may include recordable media 608 such as, but not limited to, memory, read/write (R/W) CDs, R/W DVDs, and the like. In some implementations, signal bearing media 402 may include communication media 410 such as, but not limited to, digital and/or analog communication media (eg, fiber optic cables, waveguides, wired communication links, wireless communication links, etc.). In some examples, signal bearing media 402 may comprise machine-readable non-transitory media.

In general, the methods described in connection with FIG. 3 and elsewhere herein may be implemented in any suitable server and/or computing system and/or other electronic device. An example system is described in connection with FIG. 5 and elsewhere herein. In some examples, a RAID device or other system as discussed herein may be configured to maintain parity data for the RAID.

5 is a block diagram illustrating an example computing device 700 arranged in accordance with at least some embodiments of the present disclosure. In various examples, computing device 500 may be configured to maintain parity data for RAID, as discussed herein. In one example of basic configuration 501 , computing device 500 may include more than one processor 510 and system memory 520 . A memory bus 530 can be used for communication between the one or more processors 510 and the system memory 520 .

Depending on the desired configuration, one or more processors 510 may be of any type including, but not limited to, microprocessors (μP), microcontrollers (μC), digital signal processors (DSP), or any combination thereof. One or more processors 510 may include one or more levels of cache such as level 1 cache 511 and level 2 cache 512 , processor core 513 , etc., and registers 514 . The processor core 513 may include an arithmetic logic unit (ALU), a floating point unit (FPU), a digital signal processing core (DSPCore), or any combination thereof. Memory controller 515 can also be used with one or more processors 510 , or in some implementations, memory controller 515 may be an internal component of processor 510 .

Depending on the desired configuration, system memory 520 may be of any type including, but not limited to, volatile memory (such as RAM), non-volatile memory (such as ROM, flash memory, etc.), or any combination thereof. System memory 520 may include an operating system 521 , one or more applications 522 , and program data 524 . The one or more applications 522 may include a parity data retention application 523, which may be arranged to perform functions, actions, and/or operations as described herein, including the functional blocks, actions, and operations as described with reference to FIGS. 1-4 herein. / or any of the operations. Program data 524 may include checksum and/or hash data 525 for use with checksum data holding application 523 . In some exemplary embodiments, one or more applications 522 may be arranged to operate on program data 524 on operating system 521 . This depicted basic configuration 501 is illustrated in Figure 5 by those components within the inner dashed box.

Computing device 500 may have additional features or functionality and additional interfaces to facilitate communication between basic configuration 501 and any desired devices and interfaces. For example, bus/interface controller 540 may be used to facilitate communication between base configuration 501 and one or more data storage devices 550 via storage interface bus 541 . One or more data storage devices 550 may be removable storage devices 551, non-removable storage devices 552, or a combination thereof. Examples of removable and non-removable storage devices include magnetic disk devices such as floppy disk drives and hard disk drives (HDD), optical disk drives such as compact disk (CD) drives or digital versatile disk (DVD) drives, solid state drives (SSD) and tape drives, just to name a few. Exemplary computer storage media may include volatile and nonvolatile media implemented in any method or technology for storage of information such as computer readable instructions, data structures, program modules, or other data, as well as removable and Non-removable media.

System memory 520, removable storage 551 and non-removable storage 552 are examples of computer storage media. Computer storage media including, but not limited to, RAM, ROM, EEPROM, flash memory or other memory technology, CD-ROM, digital versatile disk (DVD) or other optical storage device, magnetic cartridge, tape, magnetic disk storage device or other magnetic storage device, or any other medium that can be used to store the desired information and that can be accessed by computing device 500 . Any such computer storage media may be part of computing device 500 .

Computing device 500 may also include interface bus 542 for facilitating communication from various interface devices (eg, output devices, peripheral device interfaces, and communication devices) to base configuration 501 via bus/interface controller 540 . Exemplary output devices 560 include a graphics processing unit 561 and an audio processing unit 562 , which may be configured to communicate with various external devices such as a display or speakers via one or more A/V ports 563 . Exemplary peripherals interface 570 may include a serial interface controller 571 or a parallel interface controller 572, which may be configured to interface with input devices such as (e.g., keyboard, mouse, pen, voice input, etc.) via one or more I/O ports 573. devices, touch input devices, etc.) or other peripherals (eg, printers, scanners, etc.) An example communication interface 580 includes a network controller 581 , which may be arranged to enable communication with one or more computing devices 583 via network communication via one or more communication ports 582 . A communication connection may be one example of a communication medium. Communication media typically can embody computer readable instructions, data structures, program modules or other data in a modulated data signal such as a carrier wave or other transport mechanism and can include any information delivery media. A "modulated data signal" may be a signal such that one or more of its characteristics are set or changed in such a manner as to encode information in the signal. By way of example, and not limitation, communication media may include wired media such as a wired network or direct-wired connection, and wireless media such as acoustic, radio frequency (RF), infrared (IR) and other wireless media. The term computer readable media as used herein may include both storage media and communication media.

Computing device 500 may be implemented as a cellular phone, mobile phone, tablet device, laptop computer, personal data assistant (PDA), personal media player device, wireless web-watch device (wireless web-watch device), personal headset device, etc. Part of a small form factor portable (or mobile) electronic device, a dedicated device, or a hybrid device that includes any of the above functions. Computing device 500 may also be implemented as a personal computer including both laptop and non-laptop configurations. Additionally, computing device 500 may be implemented as part of a wireless base station or other wireless system or device.

Some portions of the foregoing detailed description have been presented in terms of algorithms or symbolic representations of operations on data bits or binary digital signals stored within a computing system memory, such as computer memory. These algorithmic descriptions or representations are examples of techniques used by those skilled in the data processing arts to convey the substance of their work to others skilled in the art. An algorithm is here, and generally, considered to be a self-contained sequence of operations or similar processes leading to a desired result. In this context, operations or processing involve physical manipulation of physical quantities. Typically, though not necessarily, these quantities may take the form of electrical or magnetic signals capable of being stored, transferred, combined, compared, or otherwise manipulated. It has proven convenient at times, principally for reasons of common usage, to refer to these signals as bits, data, values, elements, loads, characters, terms, numbers, values, or the like. It should be understood, however, that all of these and similar terms are to be associated with the appropriate physical quantities and are merely labels of convenience. Unless specifically stated otherwise, as will be apparent from the following discussion, it is recognized that the use of terms such as "processing," "computing," "operating," "determining," etc. throughout this specification refers to the manipulation or manipulation of a computing device. The act or process of transforming data represented as physical electronic or magnetic quantities within a memory, register, or other information storage device, transmission device, or display device of a computing device.

The scope of the claimed subject matter is not limited to the specific implementations described herein. For example, some implementations may be by hardware, such as for operation on eg a device or combination of devices, while other implementations may be by software and/or firmware. Also, although claimed subject matter is not limited in scope in this respect, implementations may include one or more items, such as signal bearing media, storage media, and/or storage media. A storage medium such as, for example, a CD-ROM, a computer disk, flash memory, etc. may have stored thereon instructions which, when executed by a computing device such as, for example, a computing system, computing platform or other system, may implement the claimed subject matter. Execution of a processor, such as, for example, one of the aforementioned implementations. As one possibility, a computing device may include one or more processing units or processors, one or more input/output devices, such as a display, keyboard and/or mouse, and one or more memories, such as static random access memory, DRAM, flash memory, and/or hard drives.

Minimal distinction is reserved between hardware and software implementations of system schemes; the use of hardware or software is usually (but not always, since in some contexts the choice between hardware and software can become important) denote Design choices for cost versus efficiency trade-offs. There are various vehicles that can implement (e.g., hardware, software, and/or firmware) the processes and/or systems described herein and/or other technologies, and preferred vehicles will be deployed as the process and/or system and/or or other technical backgrounds. For example, if the implementer decides that speed and precision are important, the implementer may select a primarily hardware and/or firmware medium; if flexibility is important, the implementer may select a primarily software implementation; or, alternatively, the implementer may select Some combination of hardware, software and/or firmware.

The foregoing detailed description has set forth various embodiments of devices and/or processes by way of block diagrams, flowcharts, and/or examples. To the extent such block diagrams, flowcharts, and/or examples include one or more functions and/or operations, those skilled in the art will appreciate that various hardware, software, firmware, or almost any combination thereof Each function and/or operation in these block diagrams, flowcharts or examples can be implemented individually and/or collectively. In one embodiment, various portions of the subject matter described herein may be implemented via Application Specific Integrated Circuits (ASICs), Field Programmable Gate Arrays (FPGAs), digital signal processors (DSPs), or other integrated formats. However, those skilled in the art will understand that some solutions of the embodiments disclosed herein may be equivalently implemented in whole or in part as integrated circuits, one or more computer programs running on one or more computers (such as , implemented as one or more programs running on one or more computer systems), one or more programs running on one or more processors (e.g., implemented as one or more programs for the software and/or firmware), firmware, or virtually any combination, and in light of the present disclosure, designing circuits and/or writing code for the software and/or firmware will be within the skill of those skilled in the art. In addition, those skilled in the art will understand that the mechanisms of the subject matter described herein can be distributed as a program product in various forms, and that the exemplary embodiments of the subject matter described herein apply regardless of the particular How about the type of signal-carrying medium. Examples of signal bearing media include, but are not limited to, the following: recordable-type media such as floppy disks, hard disk drives (HDD), compact discs (CDs), digital versatile discs (DVDs), digital tapes, computer memory, etc.; and transmission-type media , such as digital and/or analog communication media (eg, fiber optic cables, waveguides, wired communication links, wireless communication links, etc.).

Those skilled in the art will appreciate that it is common in the art to describe devices and/or processes in the manner set forth herein and thereafter employ engineering practices to integrate such described devices and/or processes into data processing systems. That is, at least a portion of the devices and/or processes described herein can be integrated into a data processing system with a reasonable amount of experimentation. Those skilled in the art will appreciate that a typical data processing system typically includes one or more of the following: a system unit housing, a video display device, memory such as volatile and nonvolatile memory, memory such as a microprocessor processors and digital signal processors, computing entities such as operating systems, drivers, graphical user interfaces, and applications, one or more interactive devices such as touchpads or touchscreens, and/or include feedback loops and control motors ( For example, feedback for sensing position and/or velocity; control electric motors for moving and/or adjusting components and/or quantities). A typical data processing system may be implemented utilizing any suitable commercially available components, such as those commonly found in data computing/communication and/or network computing/communication systems.

The herein described subject matter sometimes illustrates different components contained within, or connected with, different other components. It is to be understood that these depicted architectures are exemplary only, and that in fact many other architectures can be implemented which achieve the same functionality. In a conceptual sense, any arrangement of components to achieve the same functionality is effectively "associated" such that the desired functionality is achieved. Hence, any two components herein combined to achieve a particular functionality can be seen as "associated with" each other such that the desired functionality is achieved, irrespective of architectures or intermedial components. Likewise, any two components so associated may also be considered to be "operably connected" or "operably coupled" to each other to achieve a desired function, and any two components capable of being so associated may also be considered to be "capable of Operably coupled" to achieve the desired function. Specific examples of operable coupling include, but are not limited to, physically connectable and/or physically interactable components and/or wirelessly interactable and/or wirelessly interactable components and/or logically interactable and/or logically interactable components .

With respect to the use of substantially any plural and/or singular term herein, those skilled in the art will be able to convert from the plural to the singular and/or from the singular to the plural as appropriate depending on the context and/or application. For purposes of clarity, each singular/plural permutation is explicitly set forth herein.

Those skilled in the art will appreciate that terms used herein in general, and especially in the appended claims (e.g., the body of the appended claims), are generally intended to be "open-ended" terms (e.g., The term "comprising" shall be interpreted as "including but not limited to", the term "having" shall be interpreted as "having at least", the term "including" shall be interpreted as "including but not limited to", etc.). It will also be understood by those within the art that if a specific number of an introductory claim recitation is intended, that intent will be explicitly recited in the claim, and in the absence of such recitation no such intent is present. For example, as an aid to understanding, the following appended claims may contain usage of the introductory phrases "at least one" and "one or more" to introduce claim recitations. However, use of this phrase should not be construed to imply that the indefinite article "a" or "an" introduces a claim recitation to limiting any particular claim containing the introduced claim recitation to containing only one of that recitation. even when the same claim includes the introductory phrase "one or more" or "at least one" and an indefinite article such as "a" or "an" (e.g., "a" and/or "a " should be construed to mean "at least one" or "one or more"); the same applies to the use of definite articles used to introduce claim recitations. In addition, even if the specific number of the introduced claim recitation items is explicitly recited, those skilled in the art will understand that these recitation items should be interpreted as at least indicating the recited number (for example, the bare recitation "two" without other modifiers A description item" means at least two description items or more than two description items). Furthermore, in those instances where a idiom similar to "at least one of A, B, and C, etc." is used, generally such constructions are intended to convey what those skilled in the art understand the idiom to mean (e.g., "has A, A system of at least one of B and C" will include, but is not limited to, having only A, only B, only C, having A and B, having A and C, having B and C, and/or having A, B, and C and other systems). In those instances where a idiom similar to "at least one of A, B, or C, etc." is used, generally such constructions are intended to convey the meaning that those skilled in the art understand the idiom (e.g., "having A, B, or A system of at least one of C" would include, but is not limited to, having only A, only B, only C, having A and B, having A and C, having B and C, and/or having A, B and C, etc. etc. system). Those skilled in the art will further appreciate that virtually any discrete word and/or phrase presenting two or more alternatives, whether in the specification, claims, or drawings, is to be understood as contemplated to include either, either, or both. item possibility. For example, the term "A or B" will be understood to include the possibilities of "A" or "B" or "A and B."

Reference in the specification to "an implementation," "an implementation," "some implementations," or "other implementations" may mean that a particular feature, structure, or characteristic described in connection with one or more implementations may be included in at least In some implementations, but not necessarily all implementations. Appearances of "an implementation," "an implementation," or "some implementations" in various places in the preceding specification are not necessarily all referring to the same implementation.

While some example techniques have been described and shown herein using various methods and systems, it will be understood by those skilled in the art that various other modifications may be made and equivalent features may be substituted without departing from claimed subject matter. Additionally, many modifications may be made to adapt a particular situation to the teachings of the claims without departing from the central concept described herein. Therefore, it is intended that claimed subject matter not be limited to the particular examples disclosed, but that claimed subject matter may also include all implementations falling within the scope of appended claims and their equivalents.

Claims (28)

1. A method that parity data is kept in a redundant array of independent disks (RAID), said method comprising: At the RAID control module, a request to write a data unit into the RAID is received, wherein the RAID has a data store associated with the current data unit, and the RAID has a parity associated with the current parity data data storage department; In response to the request to write the data unit to the RAID: determining interim data based at least in part on a first exclusive OR (XOR) operation between the data unit and the current data unit; determining new parity data based at least in part on a second XOR operation between the temporary data and the current parity data; and Deduplicating the new check data to determine whether any part of the new check data is a repetition of a part of the current check data. 2. The method according to claim 1, further comprising: writing the portion of the new parity data determined to be non-repetitive into the parity data storage part of the RAID. 3. The method according to claim 1, further comprising: before deduplicating the new verification data, dividing the new verification data into blocks. 4. The method of claim 3, wherein the data in the data storage portion of the RAID is organized into pages, the new parity data has a first size substantially similar to one of the pages, and wherein the The chunking of the new parity data includes splitting the new parity data into one or more blocks, wherein each block has a second size smaller than or equal to the first size. 5. The method of claim 4, wherein splitting the new parity data into one or more chunks includes splitting the new parity data such that the second size is 4 kilobytes. 6. The method of claim 1, wherein deduplicating the new verification data comprises: determining a first hash value corresponding to the new check data; comparing the first hash value with a second hash value, wherein the second hash value corresponds to the current check data; and A portion of the new parity data that is a duplicate of a portion of the current parity data is identified based on the comparison. 7. The method according to claim 3, wherein deduplicating the new verification data comprises: For each block of the new parity data: determining a first hash value corresponding to the block; comparing the first hash value with a second hash value stored in a hash table, wherein the second hash value stored in the hash table corresponds to a block of the current check data; and Identifying the block as a distinct of one or more blocks in the current parity data based on the comparison. 8. The method of claim 7, wherein deduplicating the new parity data further comprises, for each block in the new parity data: one or more blocks that will be identified as the current parity data A non-overlapping block of a plurality of blocks is written in the parity data storage unit of the RAID. 9. The method of claim 7, wherein said hash table includes an indicator for each block of said current parity data, wherein said indicator is consistent with said block's parity data in said RAID The locations in the storage section are associated, and wherein deduplication of the new verification data further includes: identifying one or more blocks of the new parity data that are duplicates of the one or more blocks of the current parity data based on the comparison; updating the first hash value in the hash table for one or more blocks of the new parity data that are identified as non-duplicates of the one or more blocks of the current parity data; and updating an indication in said hash table for one or more blocks of said new parity data identified as being duplicates of said one or more blocks of current parity data, wherein updating the indication in the hash table is based at least in part on writing non-duplicate blocks of the new parity data to the parity data of the RAID identified as one or more blocks of the current parity data in storage. 10. A machine-readable non-transitory storage medium having stored therein instructions, in response to execution by one or more processors, operable to enable a redundant array of independent disks (RAID) control module of a RAID to: determining temporary data based at least in part on a first exclusive OR (XOR) operation between the particular data unit and a first data unit in response to a request to write a particular data unit to the RAID, wherein the RAID has the a data store associated with the first data unit and the RAID has a parity data store associated with first parity data; determining second check data based at least in part on a second XOR operation between the temporary data and the first check data; and Deduplicating the second verification data to determine whether any part of the second verification data is a repetition of a part of the first verification data. 11. The machine-readable non-transitory medium of claim 10 , wherein in response to being executed by the one or more processors, the stored instructions are further operable to enable the RAID control module to write to the first A portion of the second parity data is determined to be a non-repetitive portion of the portion of the first parity data. 12. The machine-readable non-transitory medium of claim 10 , wherein in response to being executed by the one or more processors, the stored instructions are further operable to enable the RAID control module to operate on the first The second verification data is divided into blocks before deduplication of the second verification data. 13. The machine-readable non-transitory medium of claim 12 , wherein data in the data storage portion of the RAID is organized into pages, the second parity data having a value substantially similar to one of the pages Storage instructions of a first size and operable to enable the RAID control module to block the second parity data include responsive to execution by the one or more processors operable to enable the RAID control The module is capable of splitting the second parity data into instructions for one or more blocks, where each block has a second size less than or equal to the first size. 14. The machine-readable non-transitory medium of claim 13 , wherein the storing instructions operable to enable the RAID control module to split the second parity data comprises responding to The processor executes instructions operable to enable the RAID control module to split the second parity data into one or more blocks such that the second size is 4 kilobytes. 15. The machine-readable non-transitory medium of claim 10 , wherein the storage instructions operable to cause the RAID control module to deduplicate the second data include instructions responsive to executed by a processor, the instructions operable to enable the RAID control module to: determining a first hash value corresponding to the second check data; comparing the first hash value with a second hash value, wherein the second hash value corresponds to the first check data; and A portion of the second parity data that is a repetition of a portion of the first parity data is identified based on the comparison. 16. The machine-readable non-transitory medium of claim 10 , wherein in response to being executed by one or more processors, the stored instructions are further operable to enable the RAID control module to: comparing a second parity data block including a portion of the second parity data with a plurality of first parity data blocks, each first parity data block including a portion of the first parity data; determining whether the second check data block is a repetition of any one of the plurality of first check data blocks based on the comparison, wherein: In response to the second parity data block being a repetition of the first parity data block: identifying a location of the first parity data block in a parity data storage section of the RAID; and allocating the location to the second parity data block; allocating a new location in the parity data storage section of the RAID to the second parity data block in response to the second parity data block being not a duplicate of any of the plurality of first parity data blocks Verify data block. 17. The machine-readable non-transitory medium of claim 16 , wherein in response to being executed by one or more processors, storing instructions are further operable to enable the RAID control module to: comparing the second parity data block with a plurality of different second parity data blocks, each of the plurality of different second parity data blocks including other portions of the second parity data; as well as determining whether the second parity data block is a repetition of any one of the plurality of different second parity data blocks based on the comparison; In response to the second parity data block being a repetition of a different second parity data block among the plurality of different second parity data blocks, the parity data storage part of the RAID The same location of is allocated to the second parity data block and the one different second parity data block; and allocating a different location in the parity data storage section of the RAID to the second parity data block in response to the second parity data block being not a repetition of any one of the plurality of different second parity data blocks Two parity data blocks and the plurality of different second parity data blocks. 18. The machine-readable non-transitory medium of claim 16 , wherein in response to being executed by one or more processors, the stored instructions are further operable to enable the RAID control module to write third parity data to into the parity data storage section of the RAID including the second parity data block assigned a new location. 19. A system comprising: a redundant array of independent disks (RAID), wherein the RAID has a data store associated with the current data unit, and the RAID has a parity data store associated with the current parity data; and RAID control module, it is coupled with described RAID communication, and described RAID control module comprises: a data input/output (I/O) module configured to: receiving a request to write a data unit to said RAID; A verification data retention module configured to: comparing said data unit with said current parity data to determine provisional parity data in response to said request to write said data unit; comparing the temporary verification data with the current verification data to determine new verification data; Splitting the new check data into multiple new check data blocks; constructing a hash table that associates each of a plurality of first hash values with a different one of the new check data blocks, and associates each of a plurality of second hash values with the associated with a different one of the blocks of the current parity data; and A non-repeating block of the new check data comprising at least a first portion of the data unit is identified based on a comparison of the first plurality of hash values and the second plurality of hash values. 20. The system of claim 19 , wherein the verification data retention module is further configured to identify the data containing the data based on a comparison of the first plurality of hash values and the second plurality of hash values A repeating block of said new parity data for at least a second portion of cells. 21. The system of claim 19, wherein the data I/O module is further configured to write non-duplicate blocks of the new parity data to the parity data storage of the RAID. 22. The system of claim 19 , wherein the parity data retention module is further configured to associate a new location pointer pointing to a new location in the parity data storage section of the RAID with The identifiers of the non-duplicate blocks of the new parity data are associated to update the hash table. 23. The system of claim 20, wherein the parity data holding module is further configured to combine a current location pointer pointing to a current location in the parity data storage section of the RAID with a current location pointer in the hash table The identifier of the repeated block of the new check data is associated to update the hash table, wherein the current location pointer is associated with a second hash value among the plurality of second hash values. 24. The system of claim 19, wherein the verification data retention module is further configured to: Based on a comparison of each of the plurality of first hash values to others of the plurality of first hash values, identifying the first portion comprising the data unit, the second portion of the data unit, and the Two or more repeated blocks of the new parity data in the third part of the data unit. 25. The system according to claim 24, wherein the verification data holding module is further configured to: in the hash table, point to the same location pointer in the same location in the verification data storage part of the RAID Each identifier of a repeated block of said new parity data is associated to update said hash table. 26. The system of claim 22, wherein the parity data retention module is further configured to update the parity data storage of the RAID based on the updated hash table. 27. The system of claim 23, wherein the parity data retention module is further configured to update the parity data store of the RAID based on the updated hash table. 28. The system of claim 22, wherein the parity data retention module is further configured to update the parity data store of the RAID based on the updated hash table.