Block storage by decoupling ordering from durability

• US 9,798,631 B2
• Filed: 03/28/2014
• Issued: 10/24/2017
• Est. Priority Date: 02/04/2014
• Status: Active Grant

• Current Assignee: Microsoft Technology Licensing LLC (Microsoft Corporation)
• Original Assignee: Microsoft Technology Licensing LLC (Microsoft Corporation)
• Inventors: Mickens, James W., Phanishayee, Amar, Velayudhan Pillai, Vijaychidambaram
• Primary Examiner(s): Bansal, Gurtej
• Application Number:
  US14/229,355
• Publication Number:
  US 20150220439A1
• Time in Patent Office: 1,306 Days
• CPC Class Codes: G06F 11/14 Error detection or correction of the data by redundancy in operation G06F11/16 takes precedence
• CPC Class Codes: G06F 11/1469 Backup restoration techniques
• CPC Class Codes: G06F 11/1471 involving logging of persistent data for recovery
• CPC Class Codes: G06F 2201/805 Real-time
• CPC Class Codes: G06F 2201/82 Solving problems relating to consistency ensuring consistency in mirrored systems G06F11/2064
• CPC Class Codes: G06F 2201/84 Using snapshots, i.e. a logical point-in-time copy of the data
• CPC Class Codes: G06F 3/061 Improving I/O performance
• CPC Class Codes: G06F 3/0619 in relation to data integrity, e.g. data losses, bit errors
• CPC Class Codes: G06F 3/0647 Migration mechanisms
• CPC Class Codes: G06F 3/0656 Data buffering arrangements
• CPC Class Codes: G06F 3/0659 Command handling arrangements, e.g. command buffers, queues, command scheduling
• CPC Class Codes: G06F 3/0683 Plurality of storage devices
• CPC Class Codes: G06F 3/0689 Disk arrays, e.g. RAID, JBOD

Abstract

This document relates to data storage techniques. One example can buffer write commands and cause the write commands to be committed to storage in flush epoch order. Another example can maintain a persistent log of write commands that are arranged in the persistent log in flush epoch order. Both examples may provide a prefix consistent state in the event of a crash.

Claims

1. A method performed by a computing device, the method comprising:

receiving multiple logical write commands from client code, the multiple logical write commands comprising write data for writing to a physical storage device;

buffering the write data of the multiple logical write commands in a buffer;

receiving flush commands from the client code to flush the write data to the physical storage device, the flush commands identifying at least a first flush epoch and a second flush epoch that is subsequent to the first flush epoch;

acknowledging the flush commands received from the client code by returning to the client code before the physical storage device acknowledges that the write data has been committed;

issuing first device write commands to send first write data of the first flush epoch to the physical storage device;

continuing to buffer second write data of the second flush epoch until an acknowledgement is received from the physical storage device that the first write data of the first flush epoch has been committed; and

responsive to the acknowledgement from the physical storage device that the first write data of the first flush epoch is committed, issuing second device write commands to send the second write data of the second flush epoch to the physical storage device.

2. The method of claim 1, wherein the write data is committed to the physical storage device in a different order than the multiple logical write commands are received from the client code.

3. The method of claim 1, further comprising:

designating the multiple logical write commands as occurring within different flush epochs; and

ensuring that the write data for each of the different flush epochs has been committed to the physical storage device prior to issuing any subsequent device write commands for a subsequent flush epoch.

4. The method of claim 1, further comprising:

while the second write data is stored in the buffer, servicing a request for the second write data from the buffer.

5. The method of claim 1, further comprising:

issuing at least some of the first device write commands in a different temporal order than corresponding first logical write commands are received during the first flush epoch.

6. The method of claim 1, wherein the physical storage device comprises multiple different physical storage devices.

7. The method of claim 1, further comprising:

removing the write data from the buffer as the physical storage device confirms that the write data has been successfully persisted.

8. A system comprising:

a physical storage device;

a hardware processing resource; and

computer-readable instructions that, when executed by the hardware processing resource, cause the hardware processing resource to;

receive write commands from client code, the write commands comprising write data for writing to the physical storage device;

store the write data of the write commands in a buffer;

receive flush commands from the client code to flush the write data to the physical storage device, the write commands having corresponding flush epochs designated by the flush commands and the flush commands including at least a first flush command designating a first flush epoch and a second flush command designating a second flush epoch, the second flush command being received subsequent to the first flush command;

send first write data for the first flush epoch to the physical storage device for storage thereon;

return to the first flush command received from the client code before the physical storage device acknowledges that the first write data has been committed;

defer sending second write commands for the second flush epoch to the physical storage device until receipt of confirmation that the first write data for the first flush epoch has been committed to the physical storage device; and

after receipt of the confirmation that the first write data has been committed to the physical storage device, send the second write commands to the physical storage device.

9. The system of claim 8, wherein the client code comprises application code.

10. The system of claim 8, wherein the client code comprises operating system code.

11. The system of claim 8, wherein the computer-readable instructions, when executed by the hardware processing resource, cause the hardware processing resource to:

receive additional write commands from the client code, the additional write commands comprising additional write data;

receive additional flush commands from the client code;

as the additional flush commands are received, increment a flush epoch counter;

as the additional write commands are received, tag the additional write data with corresponding additional flush epochs based at least on a current value of the flush epoch counter;

send the additional write data to the physical storage device for storage thereon; and

ensure that all additional write data tagged with a given flush epoch is persisted before sending any additional data tagged with a subsequent flush epoch to the physical storage device.

12. The system of claim 8, wherein the computer-readable instructions, when executed by the hardware processing resource, cause the hardware processing resource to:

maintain the physical storage device in a prefix-consistent state.

13. The system of claim 8, wherein the client code resumes executing after returning to the first flush command and before the confirmation is received from the physical storage device.

14. The system of claim 8, further comprising a volatile memory, wherein the buffer is stored on the volatile memory.

15. The system of claim 14, wherein the computer-readable instructions are stored on the volatile memory.

16. A system comprising:

a physical storage device; and

an asynchronous flushing driver configured to;

receive write commands from client code, the write commands comprising write data for writing to the physical storage device;

store the write data of the write commands in a buffer;

receive flush commands from the client code to flush the write data to the physical storage device, the flush commands designating corresponding flush epochs of the write commands;

send the write data to the physical storage device for storage thereon while maintaining the physical storage device in a prefix-consistent state; and

acknowledge the flush command and return to the client code before the physical storage device acknowledges that the write data has been committed.

17. The system of claim 16, wherein the asynchronous flushing driver is provided by a processing unit executing computer-readable instructions.

18. The system of claim 16, wherein the asynchronous flushing driver is further configured to:

maintain the physical storage device in the prefix-consistent state by ensuring that additional write data received after a given flush command is not committed to the physical storage device until the physical storage device acknowledges that write data received before the given flush command has been committed.

19. The system of claim 16, wherein the asynchronous flushing driver is provided by the physical storage device.

20. The system of claim 19, wherein the asynchronous flushing driver comprises device firmware of the physical storage device.