CN1737745A - Read-write method for disc array data and parallel read-write method - Google Patents

Abstract

The invention provides a data reading method of a disk array, a data writing method of a disk array, a data reading method based on a data writing process, and a data writing method based on a normal data reading process. In the present invention, in the process of reading and writing, the strip unit is used as the unit to read data or write data, and the strip unit is used as the unit for calculation when calculating according to the read and write rules. Moreover, the data reading method based on the process of writing data in the present invention can realize the concurrency of normal reading or degraded reading in the process of uppercase, lowercase, reconstruction writing or degraded writing. The data writing method can realize the concurrency of uppercase writing, lowercase writing, reconstruction writing or downgrading writing in the normal reading process. By using the present invention, the speed of reading and writing can be increased, and concurrent reading and writing can be realized as much as possible.

Description

Method for reading and writing disk array data and parallel reading and writing method

technical field

The invention relates to data reading and writing technology of a disk array (RAID), in particular to a data reading and writing method of a disk array and a parallel reading and writing method.

Background technique

Disk array (RAID, Redundant Access Independent Disk) technology has been used as a mature technology in data storage backup. RAID5 (RAID LEVEL 5) is a standard for disk arrays. Figure 1 shows a RAID5 composed of 4 disks. Logically, the 4 disks are regarded as one disk for striping (Strip). In this example, the strips are divided into strips 0-3. For each stripe, three of the disks are used to store data, and the other disk is used to store the parity data of the stripe. The data distributed on each disk of each stripe is called a stripe unit (SU, Strip Unit), the strip unit can also be called a segment (Block/Segment). As for the size of the stripe unit, it depends on the system. In some systems, 1KB is the most efficient, or 4KB, or 6KB, or even 4MB or 8MB. Since the reading and writing of the disk is based on a sector (Sector, 512 bytes), the stripe unit should be a multiple of 512 bytes. In RAID5 shown in FIG. 1 , stripe 0 includes SU0-SU2 and a parity unit P, and each stripe unit includes data of 10 disk sectors. For the convenience of illustration, in this example, the sectors and stored data of each disk included in stripe 0 are numbered 0 to 29, the sectors storing verification data and the stored verification data are numbered P0 to P9, and P0 to P9 is called a check data unit.

Still taking FIG. 1 as an example, the process of writing data to sectors 9 and 10 under the current disk 0 fault condition is given below. Due to the failure of disk 0, the write request can be regarded as split into two different "sub-write" requests as follows, including the following steps:

1) Sub-write for writing new data 9, including: read sector 19, read sector 29, stored in the cache; because the disk to be written is faulty, according to the degraded write (Degraded Write) algorithm: P9=Original data 19XOR original data 29XOR new data 9, generate new verification data P9 and store in the cache, where XOR means XOR operation; write new verification data P9 into sector P9;

2) Sub-writing for writing new data 10 includes: reading sector 10, reading sector P0, stored in the cache; according to small write (Small Write) or called read-modify-write (Read-Modify-Write) Algorithm: P10=old data 10XOR new data 10XOR P0, generate new verification data P0, and store in the cache; write new data 10 into sector 10, and write new verification data P0 into sector P0.

Analyzing the above process, since reading and writing are carried out in units of sectors, reading and writing are relatively complicated. In this example, it includes four steps of reading to the disk, two calculations, and three steps of writing to the disk. On the other hand, since reading and writing are performed in units of sectors, if the read sectors are not continuous, even for a normal read (Fault-Free Read) data of an SU, such as reading sectors 11 and 13, due to the inconsistency The read operation is not for continuous sectors, it will be divided into two read operations, and the disk is frequently operated, which affects the data read and write speed.

Among them, the degraded write algorithm and lowercase algorithm mentioned above are the writing techniques in RAID5, and the writing technique also includes the uppercase algorithm (Large Write) and the reconstruction write (Reconstruct Write). Write), the above-mentioned normal read (Fault-FreeRead) and the degraded read (Degraded Read) algorithm mentioned later are the read technology in RAID5, and the read-write algorithm can refer to the read-write rule algorithm shown in Figure 2 Schematic diagram, in which D in the figure represents data, and P represents verification data. Read and write technology in RAID can also refer to information about RAID, such as "RAIDFrameBook" published by CMU University (Carnegie Mellon University) in August 1996 or "RAIDFrame: A Rapid Prototyping Toolfor RAID System" published by the university in August 1996 The RAID structure and related reading and writing technologies are described in detail.

In addition, it is not difficult to understand that when the read and write commands target the same sector, there may be read and write conflicts. But even when the read and write commands are not aimed at the same sector, read and write conflicts may occur. For example, if RAID5 is in the Degraded state, that is, there is a disk failure in the RAID group, when reading the data of the failed disk, it is necessary to use the degraded read algorithm to calculate the required data by reading the data and verification data of other disks. Therefore, even if the existing write command is not for the sector of the failed disk, there may be a read-write conflict, resulting in inconsistency in the read data. This situation is analyzed in detail below.

Still taking the RAID5 shown in Figure 1 as an example, assuming that disk 0 is broken and invalid, assuming that there are currently commands to write sectors 11-18 of stripe 0, and at the same time there are commands to read data from sectors 0-10 of stripe 0. Order.

The process of writing data into sectors 11-18 includes the following steps:

Step 1: According to the RAID5 Small Write algorithm, first read the old data 11~18_old of sectors 11~18 on SU1, and read the corresponding old verification data P1~P8_old from disk 3, and read the Data is stored in the cache (Cache).

Step 2: The old data read from sectors 11-18 of disk 1 and the corresponding old parity data and the new data to be written in the sectors 11-18 in the Cache according to the lowercase algorithm: (P1-P8_new)= (11~18_old)XOR(11~18_new)XOR(P1~P8_old) to generate new check data (P1~P8_new). Since the process of steps 1-2 does not perform a "write" action on the disk, the above steps 1-2 are collectively referred to as a pre-write-back or pre-read (Preread) step in the write action.

Step 3: Write back the new data 11-18_new and the new verification data P1-P8_new respectively to the corresponding disk sectors, and end.

The process of reading data from sectors 0 to 10 on disk 0 includes the following steps:

Step 1: Since disk 0 is broken, use the degraded read algorithm to read data from sectors 10 to 19 on disk 1, data from sectors 20 to 29 on disk 2, and checksum data P0 to P9, and store the read data in Cache.

Step 2: The data read in step 1 is read according to the degraded algorithm: (0~9)=(10~19)XOR(20~29)XOR(P0~P9) to get the data of disk 1 sector 0~9, save it on the Cache.

Step 3: Provide the calculated data 0-9 and the cached data 10 in the Cache as data 1-10 to be read to the user, and end.

Analyzing the above reading and writing steps, reading data needs to involve reading 10~19 of different disks SU1, 20~29 of SU2, and P0~P9 of P. Since it is read for consecutive sectors of different disks, it is equivalent to dividing into 3 sub-read commands. The write operation needs to write 11-18 of SU1 and P1-P8 of P, which can also be regarded as two sub-write commands. When reading and writing happen at the same time, because the order of the reading and writing subcommands arriving on each disk cannot be guaranteed, reading and writing errors may occur. For example, when the reading data completes the subreading commands for 10~19, but has not yet executed the reading of P0~P9 During the sub-command, if the write operation completes the sub-write command to P1-P8 at this time, the read data will read the updated check data. Therefore, when degraded reading data occurs, the data read from disk 1 is old data, but the data read from disk 3 contains updated checksum data, resulting in that when the read data is XORed , the generated data 0~9 is wrong.

Therefore, in order to avoid the parallel occurrence of read and write operations, the parallel operations of reading and writing are currently locked, and the unit of locking is a stripe. The parallel occurrence here refers to the occurrence of another operation between the start and completion of one operation. Operations, such as a read operation occurring before a write operation completes, or a write operation occurring before a read operation completes. Locking for reading and writing, that is, locking when reading data prohibits concurrent write operations for the stripe; locking when writing data prohibits concurrent read operations for the stripe.

By locking in units of stripes, it is possible not only to avoid read-write conflicts for the same sector, but also to avoid the above-mentioned read-write conflicts for sectors that are not the same. Moreover, by locking in strip units, when the write command appears uppercase, lowercase, downgraded write, or the read command appears normal read, downgraded read, no matter which kind of write command and read command can be avoided at the same time, avoid reading and writing Conflicts ensure that data is read and written correctly.

Although the current locking method guarantees the correctness of reading and writing data, because no matter what the situation is, the locking is performed, so that the read and write operations of the stripes cannot be parallelized, which affects the performance of the read and write operations. As a result, after the command is issued during the write/read operation, the user must wait for the current operation process to be unlocked before reading/writing data on the stripe. Therefore, the locking method has a great impact on the performance of parallel read and write operations, which affects the read and write speed.

Contents of the invention

In view of this, the main purpose of the present invention is to provide a method for reading disk array data, so as to reduce the number of read commands issued to the disk and increase the data reading speed.

Another main purpose of the present invention is to provide a method for writing data in a disk array, so as to reduce the number of read-ahead and write-back commands issued by a write command to the disk, and increase the data writing speed.

A further object of the present invention is to provide a data reading method based on the data writing process of disk array data, to reduce the locking situation of reading operations in writing data, to realize parallel operations of reading and writing as much as possible, and to improve data reading. write speed.

A further object of the present invention is to provide a data writing method based on the normal read data process of the disk array data, to reduce the locking situation of the write operation in the normal read data process, to realize the parallel operation of read and write as far as possible, and to improve the data quality. Read and write speed.

The invention provides a data reading method of a disk array, comprising the following steps:

A. According to the current reading rules, determine the sector where the data to be read is located;

B. Determine the striping unit or verification data unit to which the sector to be read belongs, read the determined striping units and verification data units from the disk, and store them in the cache;

C. Determine whether the current read is a normal read, and if so, execute step D; otherwise, according to the current read rule, use the cached stripe unit and check data unit to calculate and generate the stripe unit to which the data to be read belongs, and store in the cache;

D. Read the required data from the stripe unit in the cache and provide it to the user.

The present invention also provides a data writing method of a disk array, comprising the following steps:

A. According to the current writing rules, determine the sector where the data to be read in advance is located;

B. Determine the striping unit or verification data unit to which the pre-reading sector belongs, take the striping unit as a unit, read each striping unit and verification data unit determined from the disk, and store them in the cache;

C. Process the data to be written with the corresponding striping unit in the cache, generate a striping unit containing the data to be written, and store it in the cache as the striping unit to be written back;

D. According to the current writing rules, use the cached, read-out stripe units, the generated stripe units to be written back and the verification data units to calculate the verification data units to be written back, and store them in the cache;

E. Taking the stripe unit as a unit, write back the stripe unit to be written back and the verification data unit to be written back into the corresponding disk.

Wherein in the writing method, according to the current writing rules described in step A, determining the sector where the data to be pre-read is located includes:

When judging that the writing is lowercase, the determined sector includes: the sector corresponding to the data to be written and the sector where the corresponding verification data is located;

When judging that the writing is uppercase, the determined sector includes: the sector corresponding to the data to be written;

When judging that the writing is reconstruction writing, the determined sectors include: the pre-read sector required by the writing rule of reconstruction writing, and the sector corresponding to the data to be written;

When it is judged that the writing is degraded writing, the determined sectors include: the pre-read sector required by the writing rule of degraded writing, and the sector where the verification data is located.

The present invention also provides a corresponding data reading method based on the process of writing data, wherein writing data includes reading the strip unit where the data to be written is located into the cache, and generating a strip containing the data to be written. The pre-reading of the unit is to write the generated strip unit and the verification data unit into the disk; the data reading method includes the following steps:

A. According to the current reading rules, judge whether all the stripe units to which the data to be read belong to are stored in the cache, if yes, execute step C; otherwise, execute step B;

B. Determine the striping unit to which the data to be read that is not stored in the cache belongs; read the determined striping unit from the disk, and store it in the cache;

C. Determine whether the current read is a normal read, and if so, execute step D; otherwise, according to the current read rule, use the cached stripe unit and check data unit to calculate and generate the stripe unit to which the data to be read belongs, and store in the cache;

D. Take out the required data from the cached stripe unit and provide it to the user.

Wherein, the writing is uppercase, lowercase, reconstructed or downgraded.

Wherein in the reading method in the process of writing data, the striping unit mentioned in step D is the striping unit read out in advance during the writing process, or the striping unit to be written back calculated after the prereading.

The present invention also correspondingly provides a data writing method based on the process of normal data reading, wherein the normal data reading includes reading the stripe unit where the required data is located into the cache, taking out/calculating the data from the cache stripe unit The required data is provided to the user; the data writing method comprises the following steps:

A. Determine whether all stripe units or/and check data units to which the data to be pre-read belong to, which are determined according to the current write rule, are stored in the cache, and if so, perform step C; otherwise, perform step B;

B. Determine the stripe unit or/and check data unit to which the data not stored in the cache belongs; read the determined stripe unit or/and check data unit from the disk, and store it in the cache;

C. Process the data to be written with the corresponding striping unit in the cache, generate a striping unit containing the data to be written, and store it in the cache as the striping unit to be written back;

Then, according to the adopted writing rule, the read-out stripe unit and the verification data unit of the cache are used, and the generated stripe unit to be written back is calculated to generate the verification data unit to be written back;

D. Write back the striping units that need to be written back and the verification data units that need to be written back to the corresponding disks.

Wherein, in the data writing method in the process of reading data, all the striping units or/and verification data units to which the data to be read in advance are determined according to the current writing rules in step A include:

When judging that it is written in lowercase, the striping unit includes: the striping unit to which the data to be written belongs, and the verification data unit;

When judging that the writing is uppercase, the striping unit includes: the striping unit to which the data to be written belongs;

When it is judged that the writing is reconstruction writing, the striping unit includes: the striping unit to which the read-ahead data required by the writing rule for reconstruction writing belongs, and the striping unit to which the data to be written belongs;

When it is judged that the writing is downgraded writing, the striping unit includes: the striping unit of the pre-read data required by the writing rule of the downgraded writing, and a check data unit.

Wherein, in the data writing method in the process of reading data, step D further includes: when writing back the stripe unit that needs to be written back into the corresponding disk, the stripe unit to be written back is just the stripe unit that is currently being read by the normal data read operation. When the stripe unit is used, the stripe unit cached before the write-back operation is sent is used as the stripe unit currently read by the normal read data operation. Wherein, the striping unit is the striping unit that is pre-read during the writing process, or is the striping unit that is calculated to be written back after the pre-reading.

As can be seen from the above method, when the present invention performs read and write operations on the striping unit, it is not for each sector, so the reading and writing of a plurality of discontinuous sectors of a striping unit can be read and written at one time, reducing the The number of reads and writes to the disk. On the other hand, the calculation is also carried out in units of stripe units, which can simplify the operation for discontinuous sectors of a stripe unit into one operation process, reduce the number of operations, and increase the read and write speed.

On the other hand, when reading and writing in the existing technology of RAID in parallel, no matter what the situation is, the data reading method based on the data writing process provided by the present invention and the data writing method based on the normal reading data process are adopted. method, only when writeback occurs during the downgraded read process, stripe lock is required to prohibit writeback. In other cases, read and write can occur in parallel without locking. That is to say, using the present invention, in the parallel process of reading and writing data, when normal reading or degraded reading occurs in the process of writing data; or when writing data occurs in the process of normal reading data, no lock is required. Lowercase, downgrade write, rebuild write.

Since the lock can be realized as much as possible, the read/write data request is not affected by the command to write/read data as far as possible, which speeds up the read and write speed of data when reading and writing in parallel, and improves the read and write performance.

Description of drawings

Figure 1 is a schematic diagram of RAID5.

FIG. 2 is a schematic diagram of an algorithm for reading and writing rules in RAID5.

Fig. 3 is the process of reading data in the present invention.

Fig. 4 is the process of writing data in the present invention.

Fig. 5 is the process of reading data in writing data according to the present invention.

FIG. 6 is a flow chart of writing data in reading data according to the present invention.

Detailed ways

The present invention adopts the reading and writing operation in the unit of the stripe unit instead of the reading and writing operation in the unit of the sector, that is to say, when performing the reading and writing operation on a certain sector, it will read and write the The entire strip unit. The reading and writing method based on the strip unit can simplify the reading and writing process and improve the reading and writing speed. The present invention will be further described in detail below through specific embodiments and accompanying drawings.

The method for reading data provided by the present invention can be applied to normal reading and degraded reading of RADI5, referring to the flow chart shown in Figure 3, comprising the following steps:

Step 301: Determine the sector to be read according to the current read rule. That is, the sector to be read is determined according to whether it is a normal read or a degraded read. As shown in Figure 2, for normal reading, the determined sector is located at D0; for degraded reading, the determined sectors are located at D1, D2, and P. This step is the same as the existing technology.

Step 302: Determine the stripe unit to which the data to be read belongs, and use the stripe unit as a unit, read each determined stripe unit or/and verify the data unit and store it in the cache. As shown in Figure 2, when it is a normal read, only the stripe unit D0 to which the read data belongs is stored in the cache; when it is a degraded read, the stripe units D1, D2, and the check data unit P are read and stored in the cache.

Step 303: Calculate the stripe unit where the data to be read is located according to the read rule. When reading normally, this step is actually empty, skip and directly execute step D; when reading downgrade, according to the rules of downgrade read, use the read strip unit and check data unit to calculate the location of the data to be read The stripe units are stored in the cache. Wherein, the calculation algorithm rule is the same as that shown in FIG. 2 , except that the calculation is performed in units of strip units.

Step 304: Read out the required sector data from the stripe unit in the cache, and provide it to the user. The stripe units in the cache mentioned here include the stripe units cached in steps B and C.

The RAID write data method provided by the present invention can be applied to uppercase, lowercase, downgraded write, and rebuilt write, referring to the flow chart shown in Figure 4, comprising the following steps:

Step 401: According to the current writing rule, determine the sector to be preread (Preread), that is, determine the sector to be read according to whether it is uppercase, lowercase, downgraded write, or reconstructed write. For lowercase, the determined sector is the sector where the data to be written back is located and the corresponding verification data sector; this step is the same as the existing technology. For capitalization and reconstruction, the sector determined by the present invention includes not only the sector to be pre-read, but also the sector where the data to be written back is located. For degraded writing, the sector determined by the present invention includes the sector where the data to be written back is located and the sector where the verification data is located.

As shown in Figure 2, for lowercase, the determined sectors are located at D0, P; for uppercase, the determined sectors are located at D0, D1, D2; for reconstruction writing, the determined sectors are located at D0, D1, D2; for degraded Write, the determined sectors are located in D1, D2, P.

Step 402: Determine the stripe unit or verification data unit to which the sector to be pre-read belongs, take the stripe unit as a unit, read each determined stripe unit and verification data unit, and store them in the cache.

Step 403: Process the data to be written and the stripe units in the cache to generate the stripe units containing the data to be written, and store them in the cache as the stripe units to be written back. Since this processing process can be regarded as filling up the data to be written into a stripe unit, this process is called a filling process in the present invention. As shown in Figure 2, it is precisely because of this filling process, therefore, in steps 401 to 402 in the present invention, for capitalization, D0, D1, D2 stripe units should be read into the cache; for reconstruction writing, D0 , the D1 stripe unit is read into the cache; and for downgraded writing, the parity data unit P is read together to calculate the stripe unit D0 by using the downgraded read algorithm, which is equivalent to reading D0.

Step 404: According to the current write rule, calculate the check data unit to be written back by using the cached read stripe unit, the filled stripe unit to be written back and/or the check data unit, and store in cache. Wherein, the calculation algorithm rule is the same as that shown in FIG. 2 , except that the calculation is performed in units of strip units. For example, for lowercase in FIG. 2 , it is necessary to use step 402 to read out the cached stripe units D0 and P, and the stripe unit D0 to be written back after filling up to calculate the check data unit P to be written back.

Step 405: Taking the stripe unit as a unit, write back the stripe unit and the verification data unit to be written back into the corresponding disk.

The advantages of using the stripe unit as the read/write unit are analyzed below in combination with specific embodiments. The reading and writing of the present invention will be described with an example in the background art: the process of writing data 9 and 10 in the case of a failure of the current disk 0 . In order to compare with the process described in the background technology, the following steps are not compared with the writing process shown in FIG. 4 , but the processing flow is still in accordance with the steps shown in FIG. 4 . Include the following steps:

Step 1: Determine the striping units where 9 and 10 are located, read the striping units 10~19, 20~29, and verify the data units P0~P9; XOR generates old data 0~9 and store them in the cache;

Step 2: Use the stripe unit data in the cache and the data to be written to fill up the stripe units to be written back in SU0 and SU1 in the Cache. In this example, SU0 after filling up is: 0~8 are old data, 9 is new data to be written; SU1 after filling up is: 10 is new data to be written, and 11~19 are old data.

Step 3: Use the full stripe units SU0, SU1, and SU2 in the Cache to XOR to generate a new verification data unit P according to the capitalization method; then write back the filled stripe unit SU1 and write back the generated new Verify data unit P to disk.

From the analysis above, it can be seen that the writing process includes: three reads to the disk, two XOR operations, and two writes to the disk. Compared with the method in the background technology, one less read and one write to the disk simplifies the processing flow and improves the write performance.

Especially when reading/writing non-adjacent sectors of an SU mentioned in the background technology, because the sectors are not continuous, the background technology will separate the reading/writing twice, but using the present invention, due to Reading is for the striping unit, and writing uses the fill-up technology, so writing is also for the striping unit, and both operate on continuous sectors, so reading/writing will also be regarded as a reading/writing process, which greatly reduces The number of reads and writes to the disk simplifies the processing steps and improves the read and write performance.

Since reading and writing is performed in strip units, the complexity of reading and writing is reduced. Therefore, the present invention provides the possibility of parallel reading and writing. Analyze as follows:

First analyze the normal read and write process of RAID5. As shown in FIG. 1 , it is assumed that sectors 8, 11-18, and P1 need to be written; sectors 10, 19, 20-29 need to be read. When reading and writing occur in parallel, the following situations may exist:

Case 1: During normal reading, pre-reading is enabled; or during pre-reading, normal reading is issued again:

The read-ahead step is:

①. According to the data to be written, determine and read the stripe units SU0, SU1 and the verification data unit P where the data is located, and store them in the Cache;

Use the fill-up technology to process the stripe units in the cache, generate the filled stripe units to be written back, and store them in the Cache. In this example, use the cached 0~7 and 9 to fill up the data 8 to be written to generate SU0 to be written back, and use the cached 10 and 19 to fill up the data 11 to 18 to be written back to generate SU1 to be written back;

②. According to the lowercase algorithm, use the filled SU0, the filled SU1, and the old check data unit P to perform an XOR operation to generate a new check data unit P and store it in the Cache.

It is not difficult to understand that since only read requests are issued for pre-reading, there will be no conflict with normal reading.

Case 2: Before the normal reading is completed, write-back starts, that is, write-back occurs during the reading process:

In this example, there is no intersection between the sectors read and written back, so in fact, although the stripe units that have not been read will be updated during the write-back process, some stripe units read are Old striping units, some are new striping units, but because the sector data corresponding to the data finally provided to the user has not changed, the impact of writing back is only the impact of the process, and the final readout to the user The result is irrelevant. Therefore, when the sectors read and written back do not overlap as in this example, the write may not be locked and the write is allowed.

However, if there is an intersection between the read and write-back sectors, for example, the write-back data also includes 10, then when reading SU1, if it is found that the write-back exists for this unit, it means that the read-ahead has been completed. The SU1 to be read can be replaced by the SU1 generated before the write-back operation is started and stored in the cache. In this way, the data read and provided to the user will be the latest data, that is, the updated 10 to be written back, so there will be no read-write conflicts in this case, and the write can not be locked and the write can be allowed; of course , the pre-read SU1 before starting the write-back can also be used to replace the SU1 to be read normally, but the data finally provided to the user is the data before the start of the write operation.

Situation 3: Before the write-back is completed, the normal read is issued again, that is, during the writing process, the read occurs:

Since the write-back starts, it means that the pre-reading has ended. According to the pre-reading steps, the data of 10~19 are already in the Cache, and the data can be read directly from the Cache; if the data 20~29 is not in the Cache, a request is sent to the disk for reading Take SU2, read the data into the cache, and then extract the data and send it to the user. In this case, there will be no read-write conflict, and the write may not be locked, allowing the write to proceed. And when SU1 calculated during pre-reading is used, the data provided to the user for final reading is the latest data.

Next, we will analyze the process of parallel occurrence of RAID5 degraded read and write.

Still taking Figure 1 as an example, assuming that disk 0 is damaged, data 0-10 needs to be read, and data 11-18 needs to be written. When reading and writing happen at the same time, the following situations may exist:

Case 1: During downgraded reading, read-ahead is enabled again; or during pre-reading, downgraded reading is issued again:

The downgrade read step is:

①: According to the data to be read, judge and read the striping units SU1, SU2, and the verification data unit P, and store them in the Cache;

According to the degraded read algorithm, XOR generates SU0, stores it in the cache, and provides data 0 to 10 from the cache to the user.

The read-ahead step is:

①: According to the data to be written, determine and read the stripe unit SU1 where the data is located; read the verification data unit P and store it in the Cache;

Use the fill-up technique to process the stripe units in the cache to generate the filled stripe units to be written back. In this example, use the cached 10 and 19 to fill up the data 11-18 to be written to generate the SU1 to be written back , stored in Cache;

②: According to the lowercase algorithm, use the new SU1 and the old P to generate a new verification data unit P, and store it in the Cache.

It is not difficult to understand that downgraded read and read-ahead are two read commands, so there will be no conflicts and no locking is required. That is, as long as write-back does not start before the read is completed, there is no conflict between non-hit read and read-ahead.

Case 2: Before the downgrade read is completed, the write-back starts, that is, during the downgrade read process, write-back occurs:

Since write-back will modify P1, and downgraded read will read the old data of P1, there is a conflict between downgraded read and write-back, and a "stripe lock" needs to be added to ensure data consistency. That is, when the downgraded read starts, the downgraded read will add a "stripe lock" to the stripe to prohibit writeback, and the execution of the writeback command will be suspended to ensure data consistency.

Case 3: After the write-back starts, the degraded read is issued again, that is, the degraded read occurs during the write-back process:

According to the write-back algorithm, when the write-back starts, the read-ahead step has been completed, and SU1 and the verification data unit P must have been stored in the Cache after the read-ahead step. Therefore, the degraded read can read the new SU1, the new The data unit P is checked, and SU2 is obtained by reading the disk, and SU0 is generated by XOR. It is not difficult to understand that the degraded read can also read the old SU1 and the old parity data unit P from the cache, and obtain SU2 by reading the disk, and also XOR to generate SU0. Then the generated 0-9 and 10 are provided to the user from the cache. It can be seen that in this case, it is also possible to realize degraded reading without locking.

Situation 3 in this example is lowercase as an example. In the case of downgraded reading, downgraded writing may also occur. Judging from the writing method corresponding to Figure 4 of the present invention, the read-ahead process of downgraded writing must necessarily First generate the stripe unit of the faulty disk. Therefore, when the write-back of the degraded write is started, all the stripe units and parity units of a stripe must already exist in the cache. Therefore, if any read occurs, it can be read from the cache. The data to be read is found in , so writing in this case can be realized.

Through the above analysis, using the read and write method based on the striped unit does not need to be locked for any situation like the existing RAIDFrame, and only needs to be locked for writing back during the reduction of reading. In other cases, there is no mutual exclusion between reading and writing, and no locking is required, which can realize parallel reading and writing and shorten the waiting delay, thus improving the speed of data reading and writing and improving performance.

Based on the above analysis, on the basis of the RAID writing method and reading method described in the present invention, the present invention provides a reading method in the writing process and a writing method in the reading process, so as to realize the The method of parallel process of reading and writing that does not require locking as far as possible in the above-mentioned RAID is as follows:

The method of reading data based on the process of writing data provided by the present invention is applied to the situation where the reading is normal reading (Fault-Free Read) or degraded reading (Degraded Read), and writing can be arbitrary writing. Wherein, the writing process includes read-ahead and write-back processes, and the reading in the writing process includes the following steps:

Step 501: According to the read rule, first judge whether all the stripe units of the data to be read are stored in the cache, if yes, operate on the cache stripe units, and execute step 503; otherwise, execute step 502. Taking Figure 2 as an example, when it is a normal read, it is judged whether there is a stripe unit D0 in the cache; when it is a degraded read, it is first judged whether there is a stripe D0, if not, it is further judged whether there are D1, D2 and p.

Step 502: Determine the stripe unit where the data to be read that is not stored in the cache is located, and store the stripe unit where the read data is located in the cache. The non-hit read mentioned here refers to reading data directly from the disk, and the corresponding hit read refers to reading data directly from the cache.

Step 503: According to the current read rule, the required data is fetched or calculated from the cached stripe unit, and provided to the user. As shown in Figure 4, for normal reading, it is enough to directly read the required data from the stripe unit D0 in the cache and provide it to the user; The striping unit D0 is obtained by XOR operation, and then the required data is read from the cached striping unit D0 and provided to the user.

The present invention also provides a method for writing data based on a normal read (Fault-Free Read) data process, applying all situations of writing, wherein, reading data normally includes reading the striping unit where the required data is located into the cache, from the cache The required data is taken out from the striping unit and provided to the user; the writing in the normal read data process includes the following steps:

Step 601: In the prereading (Preread) process of writing rules, judge whether there are all the striping units where the data that needs to be read in advance are stored in the cache, if yes, then perform step 603; otherwise step 602; the writing rules here include capitalization, Rules for lowercase and downgraded writing. Wherein, when determining which data needs to be read, refer to step 401 .

Step 602: Determine the stripe unit where the data that needs to be pre-read is located that is not stored in the cache; then read the stripe unit where the determined data is located by non-hit, and store it in the cache;

Steps 603-604: Process the data to be written back with the stripe units in the cache, generate a filled stripe unit containing the data to be written back, store it in the cache as the stripe unit to be written back, and then According to the adopted write rule, the operation is performed in units of stripe units, and the verification data unit to be written back is calculated. Wherein, the rules for calculating the verification unit can be referred to as shown in FIG. 2 , except that the present invention uses the strip unit as the unit for calculation.

Step 605: Write back the calculated stripe units and check data units that need to be written back into corresponding disks. If when writing back, the write-back stripe unit is exactly the stripe unit that the normal read data is currently reading, then continue to write back, and for this normal read, use the cached stripe or It is enough to fill up the calculated stripe unit as the stripe unit to be read. That is to say, when the data read from the disk is stored in the cache, if there is an intersection with the data in the write operation cache, it must be The data already cached in the cache during the write operation shall prevail.

From the above, it can be seen that only when writing back occurs during the degraded reading process, stripe locks are required to prohibit writing. In other cases, reading and writing can be performed using the above steps without locking.

Since RAID0 (RAID LEVEL 0) and RAID1 (RAID LEVEL 1) do not have a verification unit, there are only steps of direct reading and direct writing to the disk, and there is no calculation process for using verification (for details, please refer to the CMU mentioned in the background technology. Two books published by the university), so the reading and writing in units of stripe units described in the present invention is also applicable to RAID0 and RAID1, and its reading method and writing method are similar to the method described in the present invention, and the difference is that all The process of calculating according to the rules described above is omitted. And according to the reading method and the writing method of the present invention, the parallel reading and writing of RAID0 and RAID1 can be realized, and no locking is required for reading and writing.

The above descriptions are only preferred embodiments of the present invention, and are not intended to limit the present invention. Any modifications, equivalent replacements, improvements, etc. made within the spirit and principles of the present invention shall be included in the scope of the present invention. within the scope of protection.

Claims (10)

1, the method for reading data of a kind of disk array RAID may further comprise the steps:

A, according to the current rule of reading, determine the sector, data place that will read;

B, determine stripe unit or checking data unit under the sector that to read, read each stripe unit and the checking data unit of determining, deposit buffer memory in from disk;

C, judge whether current reading is normal read, if, execution in step D then; Otherwise, according to the current rule of reading, use the stripe unit of buffer memory and checking data unit to calculate and generate the affiliated stripe unit of institute's reading of data of wanting, be stored in buffer memory;

D, the stripe unit from buffer memory read out needed data.

2, the data write method of a kind of disk array RAID may further comprise the steps:

A, according to the current rule of writing, determine the sector, data place that will read in advance;

B, determine and to read stripe unit or checking data unit under the sector in advance, read each stripe unit and the checking data unit of determining, deposit buffer memory in from disk;

Stripe unit corresponding in C, the data that will write and the buffer memory is handled, and generates and contains the stripe unit that will write data, and the stripe unit as wanting write-back is stored in buffer memory;

D, according to the current rule of writing, utilize the stripe unit of wanting write-back of the stripe unit that is read out of buffer memory and checking data unit, generation to calculate and generate the checking data unit of wanting write-back, be stored in buffer memory;

E, with the stripe unit of want write-back, want the checking data unit of write-back to be written back in the corresponding disk.

3, method according to claim 2 is characterized in that, steps A is described according to the current rule of writing, and determines the sector, data place that will read in advance and comprises:

Judge that the described sector of determining comprises: pairing sector of the data that will write and sector, corresponding check data place when being written as small letter;

Judge that the described sector of determining comprises: will write the pairing sector of data when being written as capitalization;

Judge to be written as and rebuild when writing that the described sector of determining comprises: rebuild write write rule the sector of reading in advance that requires and will write the pairing sector of data;

When judging that be written as degradation writes, the described sector of determining comprises: degradation is write writes rule and requires the sector and the sector, checking data place of reading in advance.

4, a kind of disk array RAID's based on the method for reading data in the write data process, wherein, write data comprises that the data place stripe unit that will will write reads in the buffer memory, computing generates and contains reading in advance of the stripe unit that will write data and checking data unit, the write-back that the stripe unit that generates and checking data unit are write disk; Described method for reading data may further comprise the steps:

A, according to the current rule of reading, judge that whether storing all in the buffer memory wants stripe unit under the reading of data, if, execution in step C then; Otherwise, execution in step B;

B, determine the stripe unit under the reading of data wanted that is not stored in the buffer memory; From disk, read the described stripe unit of determining, deposit buffer memory in;

C, judge whether current reading is normal read, if, execution in step D then; Otherwise, according to the current rule of reading, use the stripe unit of buffer memory and checking data unit to calculate and generate the affiliated stripe unit of institute's reading of data of wanting, be stored in buffer memory;

D, from the stripe unit of buffer memory, take out needed data.

5, method according to claim 4 is characterized in that, describedly is written as capitalization, small letter, reconstruction is write or demote and write.

6, method according to claim 4 is characterized in that, the described stripe unit of step D is the stripe unit of reading in advance of writing process, perhaps the stripe unit of wanting write-back for calculating after reading in advance.

7, a kind of disk array RAID based on the data write method in the normal read data procedures, wherein, the normal read data comprise desired data place stripe unit are read in the buffer memory, take out/calculate desired data and offer the user from the stripe unit of buffer memory; Described data write method may further comprise the steps:

A, judge whether to store in the buffer memory and write all stripe units under that rule is determined, the data that will read in advance or/and the checking data unit according to current, if, execution in step C then; Otherwise execution in step B;

B, determine stripe unit under the data that are not stored in the buffer memory or/and the checking data unit; From disk, read the described stripe unit of determining or/and the checking data unit deposits buffer memory in;

Stripe unit corresponding in C, the data that will write and the buffer memory is handled, and generates and contains the stripe unit that will write data, and the stripe unit as wanting write-back is stored in buffer memory;

Then according to the rule of writing that is adopted, utilize the stripe unit of wanting write-back of the stripe unit that is read out of buffer memory and checking data unit, generation to calculate and generate the checking data unit of wanting write-back;

D, will need write-back stripe unit, want the checking data unit of write-back to be written back in the corresponding disk.

8, method according to claim 7 is characterized in that, steps A described according to current write under that rule is determined, the data that will read in advance all stripe units or/and the checking data unit comprise:

Judge that described stripe unit comprises when being written as small letter: stripe unit and checking data unit under the data that will write;

Judge that described stripe unit comprises when being written as capitalization: will write the affiliated stripe unit of data;

Judge to be written as and rebuild when writing that described stripe unit comprises: rebuild the affiliated stripe unit of writing of data of writing stripe unit under the rule institute pre-read data that requires and will writing;

When judging that be written as degradation writes, described stripe unit comprises: degradation is write writes rule and requires described stripe unit of data and the checking data unit read in advance.

9, method according to claim 7 is characterized in that, step D further comprises:

When the stripe unit that needs write-back is written back into corresponding disk, the stripe unit of write-back is during just for the current stripe unit that is reading of normal read data manipulation, use described write back operations to issue before this stripe unit of buffer memory as the current stripe unit that reads of described normal read data manipulation.

10, method according to claim 9 is characterized in that, described stripe unit is to write the stripe unit that process is read in advance, perhaps calculates the stripe unit of wanting write-back after reading in advance.

Images