US 9,959,137 B2Granted

Transaction redo using skip element for object

AssigneeMicrosoft Technology Licensing, LLC

InventorCristian Diaconu

Life of this patent

Estimating the term…

Loading patent…

Abstract

The use of a skip element when redoing transactions, so as to avoid tracking dependencies between transactions assigned to different threads for parallel processing. When the second thread comes to a second task in the course of redoing a second transaction, if a first task that is mooted by the second task is not already performed, the second thread inserts a skip element associated with the object to be operated upon by the particular task, instead of actually performing the particular task upon the object. When the first thread later comes to the first task in the course of redoing a first transaction, the first thread encounters the skip element associated with the object. Accordingly, instead of performing the dependee task, the first thread skips the dependee task and perhaps removes the skip element. The result is the same regardless of whether the first or second task is redone first.

Claims19

Dependent claims

A computing system comprising:

one or more processors;
a computer-readable storage media having thereon computer-executable instructions that are structured such that, when executed by the one or more processors causes the computing system to perform a method for a worker thread to assist in redoing a transaction segment of a log that has an associated plurality of transaction segment records each representing an associated transaction segment of a log, the method comprising:
a first worker thread accessing a transaction segment record for a first transaction segment assigned to the first worker thread;
the first worker thread reviewing the first transaction segment record to encounter a first transaction segment definition;
the first worker thread accessing the first transaction segment using the first transaction segment definition;
and
the first worker thread redoing the first transaction segment;
during the redoing of the first transaction segment, performing the following:
evaluating a potential redo of a first task within the first transaction segment, by at least attempting to perform the first task for operation on a first object;
as a result of evaluating the potential redo of the first task on the first object, determining that a dependee task for the first task has not yet been performed, the dependee task being both a task that would be rendered moot by the first task, and a task that is part of a second transaction segment and is operable on a second object;
and
as a result of determining that the dependee task would be rendered moot by the first task, associating a skip element with the second object with respect to the dependee task, the skip element being structured to be interpretable by a second worker thread assigned to the second transaction segment as an instruction to the second worker thread to skip the dependee task during any subsequent reprocessing of the second transaction segment that includes the dependee task.

9 more elements

A computer implemented method for a worker thread to assist in redoing a transaction segment of a log that has an associated plurality of transaction segment records each representing an associated transaction segment of a log, the method being implemented by a computing system having one or more processors and storage media having stored instructions that are executable by the one or more processors for implementing the method, the method comprising:

a worker thread accessing a transaction segment record for a transaction segment assigned to the worker thread;
the worker thread reviewing the transaction segment record to encounter a transaction segment definition;
the worker thread accessing the transaction segment using the transaction segment definition;
and
the worker thread redoing the transaction segment;
at least during redoing the transaction segment, performing the following:
evaluating a potential redo of a particular task within the transaction segment by at least attempting to perform the particular task for operation on an object;
as a result of evaluating the potential redo of the particular task, determining that there is a skip element associated with the object of the particular task and that is applicable to the particular task due to the particular task being rendered moot by a dependent task in a different transaction segment that is assigned to a different worker thread;
and
as a result of determining that the object has a skip element that is applicable to the particular task, not redoing the particular task.

7 more elements

A computer program product comprising one or more computer-readable hardware storage device having stored computer executable instructions which are executable by one or more processors of a computing system to cause the computing system to perform a method for a worker thread to assist in redoing a transaction segment of a log that has an associated plurality of transaction segment records each representing an associated transaction segment of a log, wherein the method includes:

a worker thread accessing a transaction segment record for a transaction segment assigned to the worker thread;
the worker thread reviewing the transaction segment record to encounter a transaction segment definition;
the worker thread accessing the transaction segment using the transaction segment definition;
and
the worker thread redoing the transaction segment;
during the redoing of the transaction segment, performing the following:
evaluating a potential redo of a particular task within the transaction segment by at least attempting to perform the particular task for operation on an object;
as a result of evaluating the potential redo of the particular task, determining that there is a skip element associated with the object of the particular task and that is applicable to the particular task due to the particular task being rendered moot by a dependent task in a different transaction segment that is assigned to a different worker thread;
and
as a result of determining that the object has a skip element that is applicable to the particular task, not redoing the particular task.

7 more elements

Dependencies are inferred from the claim text.