Tail of logs in persistent main memory

Patent metadata

Field	Value
Publication number	US-9747174-B2
Application number	US-201514966724-A
Country	US
Kind code	B2
Filing date	Dec 11, 2015
Priority date	Dec 11, 2015
Publication date	Aug 29, 2017
Grant date	Aug 29, 2017

Abstract

A system that uses a persistent main memory to preserve events that await logging in a persistent store. Each event is written into the persistent main memory so as to be loggable in case of recovery. For instance, the event may be written into a log cache structure, along with other state which identifies that the event is in the particular log cache structure, the location of the event within the particular log cache structure, and the order of the event. To recover, the log in the persistent store is evaluated to identify the end of the stored log. The tail of the log is identified in the persistent main memory by identifying any log cache structures that are after the end of the stored log and which are validly recoverable. The log cache structure contents are then serialized one log cache at a time, earliest first.

First claim

What is claimed is:

1. A system comprising:
persistent main memory;
one or more event writing components that request logging of events;
persistent storage that has therein a log of events;
a recovery component that is triggered during recovery to use the log in persistent storage as well as events written to the persistent main memory in order to perform recovery; and
a log management component that causes events, that the writing component(s) request be logged, to be written to the persistent main memory in a manner that the recovery component would log the event in case of recovery, the event being written into the persistent main memory prior to the event being written along with other accumulated events into the log in the persistent store, the log management component causing threads for each of at least some of the event writes to be returned after the event is written to the persistent main memory but before the event is written to the log in the persistent storage.

2. The system in accordance with claim 1 , further comprising:
a volatile memory having a log cache, the log management component also causing the events, that the writing component(s) request be logged, to be written to the log cache in the volatile memory.

3. The system in accordance with claim 2 , the log management component periodically writing contents of the log cache to the log in the persistent store via a serializer.

4. The system in accordance with claim 2 , the persistent main memory having a log cache that mirrors the log cache of the volatile memory, the written event and the other accumulated events being included within the log cache of the volatile memory and the log cache of the persistent main memory.

5. The system in accordance with claim 2 , the log management component further configured to invalidate the written event and the accumulated events in the persistent main memory when the event and the accumulated events are all written into the log of the persistent store.

6. The system in accordance with claim 1 , the persistent main memory comprising a plurality of log cache structures that are usable in sequence for filling with events.

7. The system in accordance with claim 6 , the persistent main memory further comprising a plurality of slot structures, each of at least some of the plurality of slot structures being usable for association with a corresponding log cache structure, to describe where an event is written into the corresponding log cache structure, and to preserve ordering information of events written into the corresponding log cache structure.

8. The system in accordance with claim 7 , each of the at least some of the plurality of slot structures preserving ordering information by its order within a linked list of slot structures that have a log cache descriptor data, the log cache descriptor data structure identifying the log cache structure and indicating a status of the log cache structure.

9. A method for logging events of a computing system so as to enable the computing system to recovery for a possible failure, the method comprising:
an act of detecting that a thread requests to write an event for purposes of logging;
in response to the act of detecting, an act of writing the event into a persistent main memory prior to the event along with other accumulated events into a log in a persistent store, the event being written into the persistent main memory in a manner that a recovery component can cause the event to be logged if the recovery component is triggered to recover the computing system; and
after the act of writing the event into the persistent main memory, but before writing the event along with other accumulated events into the log in the persistent store, an act of returning the thread that requested the write of the event.

10. The method in accordance with claim 9 , further comprising the following in response to the act of detecting:
an act of writing the event into a log cache in a volatile memory, the writing of the event along with the other accumulated events into the log occurring by writing contents of the log cache from volatile memory to the log in the persistent store.

11. The method in accordance with claim 10 , the act of writing the event into the persistent main memory comprising an act of writing the event into a log cache in the persistent main that mirrors the log cache in the volatile memory.

12. The method in accordance with claim 9 , the act of writing the event into the persistent main memory comprising:
an act of writing the event into a log cache structure of the persistent main memory;
an act of allocating a slot structure to the event, the slot structure also being within the persistent main store; and
an act of modifying the slot structure so as to represents where the event is written in the log cache structure, and to preserve order information representing an order in which the event was written in the context of other events also written to the log cache structure.

13. The method in accordance with claim 9 , the thread being a first thread, the event being a first event, the method further comprising:
an act of detecting that a second thread requests to write a second event for purposes of logging;
in response to the act of detecting that the second thread requests to write the second event, an act of writing the second event into a persistent main memory prior to the second event along with other accumulated events into the log in the persistent store, the second event being written into the persistent main memory in a manner that the recovery component can cause the event to be logged if the recovery component is triggered to recover the computing system; and
after the act of writing the second event into the persistent main memory, but before writing the second event along with other accumulated events into the log in the persistent store, an act of returning the second thread that requested the write of the second event.

14. The method in accordance with 13 ,
the act of writing the first event into the persistent main memory comprising an act of writing the first event into a log cache structure of the persistent main store; and
the act of writing the second event in the persistent main memory comprising: an act of writing the first event into the log cache structure of the persistent main store in a manner that preserves ordering between the first event and the second event.

15. The method in accordance with 13 ,
the act of writing the first event into the persistent main memory comprising an act of writing the first event into a first log cache structure of the persistent main store; and
the act of writing the second event in the persistent main memory comprising: an act of writing the first event into a second log cache structure of the persistent main store.

16. A method for recovering a computing system using a log persisted in a persistent store as well as persistent main memory, the method comprising:
an act of evaluating the log in the persistent store to identify an end of the stored log;
an act of identifying a tail of the log in the persistent main memory by identifying one or more log cache structures that have events after the end of the stored log and which are validly usable for recovery; and
an act of capturing serialized contents of each of the identified one or more log cache structures into the log in the persistent store.

17. The method in accordance with claim 16 , the contents of the log cache structure being valid if it is confirmed that the content is in a state consistent

Assignees

• Microsoft Technology Licensing Llc

Inventors

• Fitzgerald Robert Patrick
• Larson Per-Ake
• Zwilling Michael James
• Diaconu Cristian

Classifications

• G06F11/1441

  Resetting or repowering · CPC title

• G06F11/1438

  Restarting or rejuvenating · CPC title

• G06F11/1471 Primary

  involving logging of persistent data for recovery · CPC title

• G06F3/0653

  Monitoring storage devices or systems · CPC title

• G06F3/0673

  Single storage device · CPC title