KR20180069176A - System and method for log-based parity update of SSD array and to defect block and node failures recovery method using the same - Google Patents

Abstract

The present invention relates to a system and a method for log-based parity update of SSD array and a method of recovering defects of a block and a node using the same to solve a write amplification problem increased due to a parity update when distributing files in RAID type using parity in an SSD-based massive cluster environment. To this end, according to the present invention, the system for log-based parity update of SSD array includes a RAID controller for controlling an SSD-based massive storage system, and an SSD array for storing files inputted from the RAID controller, wherein the RAID controller includes an address managing unit for distributing data based on a logical address so that the inputted files are stored in the SSD array; a stripe managing unit for generating a stripe by using the logical address transmitted from the address managing unit; a data managing unit for managing insertion/deletion/update of the data transmitted from the stripe managing unit; and a parity managing unit for managing a parity transmitted from the stripe managing unit.

Description

[0001] The present invention relates to a log-based parity update system and method for an SSD array, and a block and a node defect recovery method using the same.

The present invention relates to a system and method for updating a log-based parity of an SSD array that solves the problem of increased write amplification due to parity update when distributed in a RAID type using parity in a large-scale cluster environment based on SSD, And to a method for repairing defects.

 Recently, as NAND flash memory prices have fallen, the use of solid state drives (SSDs) has been actively used from personal devices to server systems in data centers. Compared to HDD (Hard Disk Drives), which have a large data access overhead such as disk head seek time and rotation delay time, SSD has faster data access time, low power, low noise, low heat, light weight And so on. As the price of NAND flash memory declined, the SSD began to be used as a main storage medium in place of the HDD in various environments and started to be installed in the cluster nodes of the distributed file system. If an HDD-based storage system replaces a storage device with an SSD, it can reduce power consumption by 17%, reduce storage costs by 30%, and achieve 60% higher I / O performance.

However, in the NAND flash memory, there is a physical property in which data can not be updated and the unit of the read / write operation is different from the unit of the erase operation. The read / write operation is performed in units of physical pages constituting the NAND flash memory, and the erase operation can be performed in units of physical blocks. In addition, a block can be erased only a predetermined number of times, and the NAND flash memory has a weak point in that stored data may be damaged in a block erased more than a predetermined number of times.

SSDs with different physical units for reading and writing and erasing operations have to copy the data of valid pages existing in the block to be erased to another empty block before performing the erase operation. An additional write operation occurs in the NAND flash memory other than the write operation requested from the host. Because of this nature, SSDs continue to provide update operations and empty blocks are gradually depleted and garbage collection functions to organize valid and invalid data pages. Therefore, the SSD generates more write operations that occur physically inside the logical write request, and has a write amplification problem. The write amplification problem degrades SSD input / output performance and increases the number of erase operations in the process of performing additional write operations, thereby degrading the lifetime of the SSD.

KR 1014450250000 B1

Disclosure of Invention Technical Problem [11] Accordingly, the present invention has been made to solve the above problems, and it is an object of the present invention to solve the problem of write amplification of an SSD occurring in a large-scale storage system using a SSD as a storage device. More specifically, Based parity update system and method for reducing the write amplification due to the parity update when the data is arranged in the parity-based RAID form in the SSD array in order to improve the reliability of the SSD array and the block and node defect And to provide a method for recovering the data.

In order to achieve the above object, a log-based parity update system of an SSD array according to the present invention includes a RAID controller for controlling a SSD-based large-scale storage system; And an SSD array for storing a file input from the RAID controller, wherein the RAID controller comprises: an address distributing data based on a logical address so that the input file is stored in the SSD array; Management; A stripe management unit for generating a stripe by the logical addresses transmitted from the address management unit; A data management unit managing insertion / deletion / update of data transmitted from the stripe management unit; And a parity management unit for managing parities transmitted from the stripe management unit.

Preferably, the parity management unit includes: a parity log calculation unit for calculating a change value of data before and after the data update occurs when there is a data update request; A parity logger for receiving the parity log calculated by the data change unit and the parity log computation unit and storing the received parity log in the SSD array; And a parity merge unit for, when the parity log unit stores the parity log in the SSD array, processing a parity merge when the space for storing the parity log is insufficient.

Preferably, the parity merge module includes a pre-update parity collection module for randomly reading and collecting parities before update; A merging target stripe selecting module for selecting a stripe belonging to the parity before updating collected through the parity gathering module before the update; A parity log collection module for randomly reading the merged parities; A new parity calculation module for calculating a new parity with the randomly read old parity and parity logs; A parity log invalidation module for invalidating parity logs used for parity merging after a new parity is generated; And a pre-update parity non-validation module for de-validating the parities before update after the new parity is generated.

According to another aspect of the present invention, there is provided a method for updating a log-based parity of an SSD array through the system according to any one of claims 1 to 3, the method comprising: (a) requesting data update; (b) calculating a parity log after searching for the stripe to which the data requested to be updated in the step (a) belongs; (c) determining whether there is a parity log area to be written in the parity log calculated in the step (b); And (d) performing parity merge if the parity log area is not present as a result of the determination in step (c).

Preferably, the parity log calculation in the step (b) is performed by logarithmically computing the changed part between the data before update and the update data.

Preferably, performing the parity merge in step (d) comprises: (d1) requesting parity merge; (d2) reading the parity previously stored in the randomly stored parity log; (d3) calculating a new parity by XORing the sequentially stored parity logs read in step (d2) and the previously-updated parities that are randomly stored; And (d4) writing the new parity calculated in step (d3).

According to another aspect of the present invention, there is provided a method for recovering a block and a node defect in an SSD array for performing log-based parity update according to any one of claims 1 to 3, Retrieving a belonging stripe of data; (b) classifying the type of defect data in the step (a); And (c) reading the different data according to the type of the step (b), and XORing the read different data to recover the new data.

Preferably, the type of defect data in step (b) is any one of a parity log, new data, pre-update data, and pre-update parity.

Preferably, when the type of the defect data is a parity log, the different data in step (c) are the remaining parity logs sequentially with the data after the update.

Preferably, when the type of the defect data is new data, the different data in step (c) are parity logs sequentially arranged in the data and blocks before the update.

Preferably, when the kind of the defect data is the data before the update, the different data of the step (c) are the data before the update, which are randomly arranged, will be.

Preferably, when the type of the defect data is a parity before updating, the different data in step (c) are data before updating.

According to the present invention, there is an effect of providing high reliability by arranging data in a parity-based RAID form in a large cluster composed of nodes equipped with SSDs. This is because the problem of write amplification, Technology to improve the performance of SSD-based clusters and extend the lifetime.

Also, the present invention has an effect of achieving high economical efficiency by enhancing storage space efficiency in the field of cloud computing, big data processing and analysis, artificial intelligence and IoT, which are operated on a large scale cluster.

BRIEF DESCRIPTION OF THE DRAWINGS FIG. 1 schematically illustrates the overall structure of a log-based parity update system of an SSD arrangement according to the present invention; FIG.
FIG. 2 is a diagram illustrating a call process in which a parity update occurring during data update is processed using a log-based parity update system of an SSD array according to the present invention. FIG.
3 is a diagram illustrating a process in which a configuration of a parity merge unit is called when a parity merge request is generated using a log-based parity update system of the SSD array according to the present invention.
FIG. 4 is a flowchart illustrating a process of updating a data block and a parity block of an SSD array using a log-based parity update system of the SSD array according to the present invention.
FIG. 5 is a flowchart illustrating a process of recovering a defect block using a log-based parity update system of an SSD array according to the present invention; FIG.

Hereinafter, preferred embodiments of the present invention will be described in detail with reference to the accompanying drawings. Prior to this, terms and words used in the present specification and claims should not be construed as limited to ordinary or dictionary terms, and the inventor should appropriately interpret the concepts of the terms appropriately It should be interpreted in accordance with the meaning and concept consistent with the technical idea of the present invention based on the principle that it can be defined. Therefore, the embodiments described in this specification and the configurations shown in the drawings are merely the most preferred embodiments of the present invention and do not represent all the technical ideas of the present invention. Therefore, It is to be understood that equivalents and modifications are possible.

1 is a diagram schematically illustrating a log-based parity update system of an SSD array according to the present invention. 1, the log-based parity update system of the SSD array includes a RAID controller 100 for controlling an SSD-based large-scale storage system and a RAID controller (not shown) by a user input (not shown) And an SSD array 200 for storing a file input to the SSD 100.

In general, raid (RAID) is a hardware method and a software method in which several disks are grouped into a single logical disk. The hardware approach is to make the disk look like a disk to the operating system, the software method is mainly implemented in the operating system, and makes the disk look like a disk to the user.

RAID 0 is a striped set with no parity, and RAID 1 is a mirrored set with no parity (error detection). Is composed of at least two discs. And 'RAID 3' and 'RAID 4' are provided with a simple parity. The striped set is composed of at least three disks. 'RAID 5' is a striped set in which parity is distributed. do. And 'RAID 6' is a striped set with distributed parity consisting of at least four disks.

The RAID controller 100 includes an address management unit 110 for receiving a logical address from a file system and distributing data and parity based on the input logical address, A stripe management unit 120 for generating a stripe from the logical addresses; a data management unit 130 for managing insertion / deletion / update of data transmitted from the stripe management unit 120; And a parity management unit 140 in charge.

The parity management unit 140 includes a parity log calculation unit 141 for calculating a change value of data before and after the data update when there is a data update request, A parity logger 142 for receiving a parity log calculated based on the change value of the data calculated by the log calculator 141 and storing the received parity log in the SSD array 200, 142 for storing the parity log in the SSD array 200, and a parity merge unit 143 for processing parity merge when the space for storing the parity log is insufficient.

The SSD array 200 includes a plurality of SSDs. The individual SSDs include a data page for storing block data, a parity page for storing parity, and a parity log page for storing a parity log. In addition, the block of the SSD is formed of a set of pages. In the present invention, one block is composed of two pages for simplifying the example, and one block is usually composed of 64 or 128 pages.

FIG. 2 is a diagram illustrating a call process in which updating of a parity occurring during data update using a log-based parity update system of the SSD array according to the present invention is processed. When a data update request is input to the RAID controller 100, the address management unit 110 of the RAID controller 100 stores the RAID level and the number of the SSD arrays 200 in logical addresses in the stripe management unit 120 And finds the stripe for which update is requested. Thereafter, the data management unit 130 updates the data of the corresponding stripe, and the parity management unit 140 requests the parity update. Here, in order to update the parity, the parity management unit 140 calculates the changed portion of the data and transmits the calculated parity log to the update command unit 300. [ At this time, the update command unit 300 may exist between the RAID controller 100 and the SSD array 200. If the parity log area of the SSD array 200 in which the parity log is to be stored is insufficient, the parity log is transferred to the SSD array 200 where the parity log is to be stored via the parity logging unit 142. At this time, And the parity log is transferred to the merge unit 143.

FIG. 3 is a diagram illustrating a process of calling a configuration module of the parity merge unit 143 when a parity merge request is generated using the log-based parity update system of the SSD array according to the present invention. A pre-update parity collection module 151 that reads pre-update parities, a merge target stripe selection module 152 that selects a stripe to be a parity merge, a parity log collection module 152 that collects a parity log of a parity to be updated, A new parity calculation module 154 for calculating a new parity by XORing the collected pre-update parity and the collected parity log, a parity log ineffective module 155 for deactivating the updated parity logs, And a pre-update parity invalidation module 156 for deactivating pre-update parities.

3, when the space allocated to the parity log is full and the parity merge is requested, the pre-update parity acquisition module 151 randomly reads the parities before the parity update of the accumulated parity logs, The merging target stripe selecting module 152 selects a stripe to be subjected to the parity merger. The parity log collection module 153 reads the parity logs accumulated in the parity log collection module 153 and calculates new parities generated in the new parity calculation module 154 through XOR operation with the parities before the update. When a new parity is written to the SSD array 200, the parity log invalidation module 155 deactivates the merged parity logs, and the pre-update parity invalidation module 156 invalidates the parities before being updated So that the SSD arrays 200 can be collected and erased when garbage collection is performed.

4 is a flowchart illustrating a process of updating a data block and a parity block of an SSD array using a log-based parity update system of the SSD array according to the present invention.

As shown in FIG. 4, the host requests data update to the data block (S110).

When data update of the data block is requested (S110), the stripe to which the update requested data belongs is searched (S111). When updating the data block in which the update request is issued, the parity of the stripe to which the data belongs must be updated together, so that the stripe to which the data belongs is searched.

When a belonging stripe of data to be updated is found (S111), a parity log is calculated through a series of log operations between the updated data and the updated data (S112).

Then, when the parity log is calculated (S112), the parity log writing is requested (S113).

At this time, when the parity log write request is received (S113), it is determined whether a parity log area used for the parity log remains (S114).

If the parity log area remains, the parity log is sequentially written to the remaining area (S115).

On the other hand, if the parity log area does not remain as a result of the determination (S114), parity merging stored sequentially in the parity log area should be performed. This is because, after merging the parities before the update and the parity logs sequentially stored, the parities are updated, and the space for storing the currently calculated parity log is secured after all the parity log areas are cleared. To do this, the parity merge is requested (S116).

When the parity merge is requested (S116), a plurality of parity logs stored in sequence are sequentially read (S117), a plurality of parities before being updated are read (S118) S117) and the new parity values read in step S118 are computed by XORing the new parity values (S119).

When the parities are newly updated, the updated parities are written into the corresponding SSD array (S120). Thereafter, the parity logs of the updated parities are deactivated (S121), and the data before the update of the stripes to which the updated parities belong belongs (S122).

FIG. 5 is a flowchart illustrating a process of decoding a defect block using a log-based parity update system of the SSD array according to the present invention. In the case where a defect occurs, there are four cases. When a parity log defect occurs, A case where a defect occurs in the data before the update, and a case where a defect occurs in the parity before the update.

If the defect is detected in the system, the stripe belonging to the block in which the defect occurs first is searched (S210), and then the defect data type classification is requested (S221).

If the type of the defective data is a parity log (S222), the data a after the update is read (S223), the remaining parity logs (b) are read out sequentially (S224), and then, in steps S222 and S223 The read data (a, b) is XORed and the recovery data is written (S280).

On the other hand, if the type of defect data is new data (S232). The data read in steps S233 and S234 in step S270 after reading the data a before update S233 and reading the parity log b sequentially arranged on the blocks S234, (a, b) and writes the restored data (S280), and terminates the data defect process.

If the type of the defect data is the data before the update (S242), the parity (a) in the pre-update state that is randomly arranged is read (S243). The data (a, b) read in step S243 and step S244 in step S270 are read out in step S244, And the recovery data is written (S280), and the data defect processor is terminated.

Finally, if the type of the defect data is the parity before update (S252), the randomly stored pre-update data (a) is randomly read (S253) (S270), restores the parity before the update in which the defect occurred, and writes the recovered parity in the SSD to terminate the data defect repair processor.

While the present invention has been particularly shown and described with reference to exemplary embodiments thereof, it is to be understood that the invention is not limited to the disclosed exemplary embodiments. It will be understood that various modifications and changes may be made without departing from the scope of the appended claims.

100: RAID controller
110: address management unit
120: Stripe management section
130:
140: parity management unit
141: parity log calculation unit
142: Parity Logging Unit
143: Parity merger department

Claims (12)

RAID controllers that control SSD-based mass storage systems; And
An SSD array for storing a file input from the RAID controller
/ RTI >
The RAID controller includes:
An address manager for distributing data based on a logical address so that the input file is stored in the SSD array;
A stripe management unit for generating a stripe by the logical addresses transmitted from the address management unit;
A data management unit managing insertion / deletion / update of data transmitted from the stripe management unit; And
A parity management unit for managing parity transmitted from the stripe management unit,
Based parity update of the SSD array. The method according to claim 1,
The parity management unit,
A parity log calculator for calculating a change value of data before and after the data update occurs when there is a data update request;
A parity logger for receiving the parity log calculated by the data change unit and the parity log computation unit and storing the received parity log in the SSD array; And
When the parity log is stored in the SSD array in the parity logging unit, when parity log storage space is insufficient, a parity merge unit
Based parity update system of an SSD array. The method of claim 2,
The parity merge part
A pre-update parity collection module for randomly reading and collecting the parities before update;
A merging target stripe selecting module for selecting a stripe belonging to the parity before updating collected through the parity gathering module before the update;
A parity log collection module for randomly reading the merged parities;
A new parity calculation module for calculating a new parity with the randomly read old parity and parity logs;
A parity log invalidation module for invalidating parity logs used for parity merging after a new parity is generated; And
After the new parity is generated, the pre-update parity non-validation module
Wherein the SSD array comprises a plurality of SSDs. A method for updating a log-based parity of an SSD array through a system as claimed in any one of claims 1 to 3,
(a) requesting data update;
(b) calculating a parity log after searching for the stripe to which the data requested to be updated in the step (a) belongs;
(c) determining whether there is a parity log area to be written in the parity log calculated in the step (b); And
(d) if parity log area is not present as a result of the determination in step (c), performing parity merge
Based parity update of the SSD array. The method of claim 4,
The parity log calculation in the step (b) is performed by logarithmically computing the changed part between the data before update and the update data
Based parity update of the SSD array. The method of claim 4,
The performing the parity merge in the step (d)
(d1) requesting parity merge;
(d2) reading the parity previously stored in the randomly stored parity log;
(d3) calculating a new parity by XORing the sequentially stored parity logs read in step (d2) and the previously-updated parities that are randomly stored; And
(d4) writing the new parity calculated in the step (d3)
Based parity update of the SSD array. A method for recovering a block and a node defect in an SSD array performing log-based parity update according to any one of claims 1 to 3,
(a) searching for a belonging stripe of defect data;
(b) classifying the type of defect data in the step (a); And
(c) reading different data according to the type of the step (b), and XORing the read different data to recover new data
A method for recovering a block and a node defect using log-based parity update of an SSD array comprising: The method of claim 7,
The type of the defect data in the step (b) is any one of a parity log, new data, pre-update data, and pre-update parity
A method for recovering block and node defects using log-based parity update of an SSD array. The method of claim 7,
If the type of the defect data is a parity log, the different data in step (c) are the remaining parity logs sequentially with the data after the update
A method for recovering block and node defects using log-based parity update of an SSD array. The method of claim 7,
If the type of the defect data is new data, the different data in the step (c) are parity logs sequentially arranged in the data and blocks before the update
A method for recovering block and node defects using log-based parity update of an SSD array. The method of claim 7,
If the type of the defect data is the data before the update, the different data in the step (c) are the data before the update other than the parity in the pre-update state and the data before the update in which the error occurred.
A method for recovering block and node defects using log-based parity update of an SSD array. The method of claim 7,
And if the type of the defect data is a parity before updating, the different data in the step (c)
A method for recovering block and node defects using log-based parity update of an SSD array.

Images