FULL-STRIPE-WRITE PROTOCOL FOR MAINTAINING PARITY COHERENCY IN A WRITE-BACK DISTRIBUTED REDUNDANCY DATA STORAGE SYSTEM

• US 20110208912A1
• Filed: 02/22/2010
• Published: 08/25/2011
• Est. Priority Date: 02/22/2010
• Status: Active Grant

• Current Assignee: International Business Machines Corporation
• Original Assignee: International Business Machines Corporation
• Inventors: Chambliss, David D., Thakur, Tarun, Hafner, James L.
• Granted Patent: US 8,583,866 B2
• Time in Patent Office: Days
• US Class Current: 711/114
• CPC Class Codes: G06F 11/1076 Parity data used in redundant arrays of independent storages, e.g. in RAID systems
• CPC Class Codes: G06F 2211/1028 Distributed, i.e. distributed RAID systems with parity
• CPC Class Codes: G06F 2211/1057 Parity-multiple bits-RAID6, i.e. RAID 6 implementations

Abstract

Data storage reliability is maintained in a write-back distributed data storage system including multiple nodes. Information is stored as a stripe including a collection of a data strips and associated parity strips, the stripe distributed across data and parity nodes. Each data node maintains the data strip holding a first copy of data, and each parity node maintains a parity strip holding a parity for the collection of data strips. A driver node initiates a full-stripe-write parity update protocol for maintaining parity coherency in conjunction with other nodes, to keep the relevant parity strips coherent. Parity is determined directly by computing parity strips for all data strips of a stripe. Any node may function as a driver node.

Claims

1. A method of maintaining data storage reliability in a write-back distributed data storage system including multiple nodes, each node comprising an array of failure independent data storage devices, the method comprising:

storing information as a stripe including a collection of data strips and associated parity strips, the stripe distributed across data and parity nodes;

each data node maintaining an associated data strip holding a first copy of data, and each parity node maintaining a parity strip holding a parity for the collection of data strips; and

a driver node initiating a full-stripe-write parity update protocol for maintaining parity coherency in conjunction with other nodes comprising data and parity nodes, by determining parity directly by computing parity strips for all data strips of a stripe in order to keep the relevant parity strips coherent, wherein any node may function as a driver node.

2. The method of claim 1, wherein:

each parity calculated based on a different parity calculation formula;

the method further comprising;

upon detecting new data;

writing new data to one or more strips in a stripe;

the driver node computing new parity when applicable, and sending a commit message to another node in a predefined order;

each node receiving a commit message computing new parity when applicable, and sending a commit message to a next node in a predefined message order sequence; and

starting from the last node in the sequence, on receiving a commit message each node computing new parity when applicable, and sending an acknowledgement message to an immediately prior node in the sequence, wherein each node upon receiving an acknowledgement message commits new data and/or newly computed parity.

3. The method of claim 2 further comprising:

the driver node initiating the full-stripe-write parity update protocol upon determining that the new data comprises a full stripe of new data.

4. The method of claim 2 further comprising:

each data node locking its new data then sending a commit message, and upon committing, unlocking its new data; and

each parity node locking its parity data then computing new parity and sending a commit message, and upon committing, unlocking its new parity.

5. The method of claim 3 further comprising:

each data node maintaining at least two versions of the data for a strip, a fast write version and a parity-integrated version, wherein the fast write copy has been written into a storage system by a host or client and not integrated into a parity strip, and wherein the parity-integrated version has been incorporated into a process for defining a parity value; and

transitioning the fast write version to the parity-integrated version at completion of a parity update protocol at all relevant data and parity nodes, whereby the prior parity-integrated version is discarded.

6. The method of claim 5 further comprising, in each parity node:

maintaining a working version of its parity strip value containing a current parity-integrated value for each of the data strips computed into that parity strip; and

at the end of the parity update as viewed by each parity node, the parity node transitioning the working version to the parity-integrated value and discarding a previous parity-integrated value.

7. The method of claim 3 further comprising:

upon a node failure, performing a roll-forward full-stripe-write protocol restarted by a successor driver node in the messaging order.

8. A write-back distributed data storage system for maintaining data storage reliability, comprising:

multiple nodes, each node comprising a data managing processor and an array of failure independent data storage devices;

the nodes configured for storing information as a stripe including a collection of data strips and associated parity strips, the stripe distributed across data and parity nodes, each data node configured for maintaining an associated data strip holding a first copy of data, and each parity node configured for maintaining a parity strip holding a parity for the collection of data strips; and

a driver node further configured for initiating a full-stripe-write parity update protocol for maintaining parity coherency in conjunction with other nodes comprising data and parity nodes, by determining parity directly by computing parity strips for all data strips of a stripe in order to keep the relevant parity strips coherent, such that any node may function as a driver node.

9. The system of claim 8, wherein:

each parity calculated based on a different parity calculation formula;

upon detecting new data, a host writes new data to one or more strips in a stripe;

the drive node computes new parity when applicable and sends a commit message to a another node in a predefined order, each node receiving a commit message computes new parity when applicable, and sends a commit message to a next node in a predefined message order sequence; and

starting from the last node in the sequence, on receiving a commit message each node computes new parity when applicable, and sends an acknowledgement message to an immediately prior node in the sequence, wherein each node upon receiving an acknowledgement message commits new data and/or newly computed parity.

10. The system of claim 9, wherein the driver node initiates the full-stripe-write parity update protocol upon a determination that the new data comprises a full stripe of new data.

11. The system of claim 10, wherein:

each data node locks its new data and sends a commit message, and upon committing, unlocks its new data; and

each parity node locks its parity data, computes new parity and sends a commit message, and upon committing, unlocks its new parity.

12. The system of claim 9, wherein:

each data node maintains at least two versions of the data for a strip, a fast write version and a parity-integrated version, wherein the fast write copy has been written into a storage system by a host or client and not integrated into a parity strip, and wherein the parity-integrated version has been incorporated into a process for defining a parity value, and each data node transitions the fast write version to the parity-integrated version at completion of a parity update protocol at all relevant data and parity nodes, whereby the prior parity-integrated version is discarded.

13. The system of claim 12, wherein each parity node is further configured for:

maintaining a working version of its parity strip value containing a current parity-integrated value for each of the data strips computed into that parity strip; and

at the end of the parity update as viewed by each parity node, the parity node transitioning the working version to the parity-integrated value and discarding a previous parity-integrated value.

14. The system of claim 10, wherein the nodes are further configured for, upon detecting a node failure, performing a roll-forward full-stripe-write protocol restarted by a successor driver node in the messaging order.

15. A computer program product for maintaining data storage reliability in a write-back distributed data storage system including multiple nodes, each node comprising an array of failure independent data storage devices, the computer program product comprising:

a computer readable storage medium having computer usable program code embodied therewith, the computer usable program code comprising;

computer usable program code configured to store information as a stripe including a collection of data strips and associated parity strips, the stripe distributed across data and parity nodes;

computer usable program code configured for each data node to maintain an associated data strip holding a first copy of data, and each parity node maintain a parity strip holding a parity for the collection of data strips; and

computer usable program code configured to initiate a full-stripe-write parity update protocol at a driver node for maintaining parity coherency in conjunction with other nodes comprising data and parity nodes, by determining parity directly by computing parity strips for all data strips of a stripe in order to keep the relevant parity strips coherent, such that any node may function as a driver node.

16. The computer program product of claim 15 further comprising:

computer usable program code configured for calculating each parity based on a different parity calculation formula, and for a host to write new data to one or more strips in a stripe;

computer usable program code configured for the driver node to compute new parity when applicable and sends a commit message to another node in a predefined order, each node receiving a commit message computes new parity when applicable, and sends a commit message to a next node in a predefined message order sequence; and

computer usable program code configured for, starting from the last node in the sequence, on receiving a commit message each node computing new parity when applicable, and sending an acknowledgement message to an immediately prior node in the sequence, wherein each node upon receiving an acknowledgement message commits new data and/or newly computed parity.

17. The computer program product of claim 16 further comprising:

computer usable program code configured for the driver node to initiate the full-stripe-write parity update protocol only upon a determination that the new data comprises a full stripe of new data.

18. The computer program product of claim 17 further comprising:

computer usable program code configured for each data node locking its new data and sending a commit message, and upon committing, unlocking its new data; and

computer usable program code configured for each parity node locking its parity data, computing a new parity and sending a commit message, and upon committing, unlocking its new parity.

19. The computer program product of claim 17 further comprising:

computer usable program code configured for each data node maintaining at least two versions of the data for a strip, a fast write version and a parity-integrated version, wherein the fast write copy has been written into a data storage system by a host or client and not integrated into a parity strip, and wherein the parity-integrated version has been incorporated into a process for defining a parity value;

computer usable program code configured for transitioning the fast write version to the parity-integrated version at completion of a parity update protocol at all relevant data and parity nodes, whereby the prior parity-integrated version is discarded;

computer usable program code configured for each parity node performing;

maintaining a working version of its parity strip value containing a current parity-integrated value for each of the data strips computed into that parity strip; and

at the end of the parity update as viewed by each parity node, the parity node transitioning the working version to the parity-integrated value and discarding a previous parity-integrated value.

20. The computer program product of claim 17 further comprising:

computer usable program code configured for, upon detecting a node failure, performing a roll-forward full-stripe-write protocol restarted by a successor driver node in the messaging order.