Database computer system with application recovery and dependency handling write cache

Claim 2

In a database computer system having a non-volatile memory, a volatile main memory, and an application object which executes from the main memory, a computer-implemented method comprising the following steps: executing the application object to perform a write operation to write data to a data object; logging, as a logical write operation, a reference to the application object to identify the application object as a source for the data written to the data object; establishing a flush order dependency between the application object and the data object; in an event that the application object is to be flushed to non-volatile memory, evaluating the flush order dependency between the application object and the data object to determine whether the data object should be flushed prior to the application object.

Claim 3

A computer-implemented method as recited in claim 1, wherein the step of establishing a flush order dependency comprises the step of associating with the application object a reference to the data object to identify the data object as being dependent on the application object.

Claim 4

A computer-implemented method as recited in claim 1, wherein the step of establishing a flush order dependency comprises the step of associating with the data object a reference to the application object to identify the application object as an object upon which the data object is dependent.

Claim 5

A computer-implemented method as recited in claim 1, wherein the step of establishing a flush order dependency comprises the step of recording an object identifier and a state identifier of one of the application object or the data object in association with information pertaining to the other of the application object or the data object.

Claim 6

A computer-implemented method as recited in claim 1, wherein information pertaining to the application object and the data object is kept in an object table, and the step of establishing a flush order dependency comprises the step of recording a pointer in the object table which leads from one of the application object or the data object to the other of the application object or the data object.

Claim 7

A computer-implemented method as recited in claim 1, wherein information pertaining to the application object and the data object is kept in an object table, and the step of establishing a flush order dependency comprises the step of recording two pointers in the object table, a first pointer from the application object to the data object and a second pointer from the data object to the application object.

Claim 8

A computer-implemented method as recited in claim 1, further comprising the step of classifying the data object as a predecessor to the application object indicating that the data object may precede the application object in the flushing sequence.

Claim 9

A computer-implemented method as recited in claim 7, wherein the classifying step further comprises the step of distinguishing between (1) a potential predecessor indicating that the data object depends on a current state of the application object which has not yet changed, and (2) a real predecessor indicating that the data object depends on a previous state of the application object which is previous to the current state.

Claim 10

A computer-implemented method as recited in claim 1, further comprising the step of flushing the application object and the data object to the non-volatile memory according to the flushing order.

Claim 11

A computer-implemented method as recited in claim 9, further comprising the step of retrieving the application object from the non-volatile memory following a system crash.

Claim 12

A computer-implemented method as recited in claim 1, wherein the establishing step comprises the step of initially establishing a potential dependency between the application object and the data object indicating that the data object is not yet dependent on the application object since the application object has not yet changed state, but that the data object might become dependent on the application object when the application object changes state.

Claim 13

A computer-implemented method as recited in claim 11, wherein the evaluating step comprises the step of evaluating whether the dependency is a potential dependency.

Claim 14

A computer-implemented method as recited in claim 12, wherein the evaluating step determines that the dependency is a potential dependency, further comprising the step of flushing the application object to the non-volatile memory without regard to flushing sequence in respect to the data object.

Claim 15

A computer-implemented method as recited in claim 1, wherein the establishing step comprises the step of establishing a real dependency between the application object and the data object when the data object depends on a previous state of the application object that is previous to a current state of the application object.

Claim 16

A computer-implemented method as recited in claim 14, wherein the evaluating step comprises the step of evaluating whether the dependency is a real dependency.

Claim 17

A computer-implemented method as recited in claim 15, wherein the evaluating step determines that the dependency is a real dependency, further comprising the step of flushing the data object prior to flushing the application object.

Claim 18

A record created in a storage medium as a result of the computer-implemented method as recited in claim 1.

Claim 19

A computer programmed to perform the steps of the computer-implemented method as recited in claim 1.

Claim 20

A computer-readable memory which directs a computer to perform the step in the method as recited in claim 1.

Claim 21

In a database computer system having a non-volatile memory and a volatile main memory, the volatile main memory maintaining an application object, a data object, and an object table with entries identifying the application object and the data object, a computer-implemented method comprising the following steps: executing the application object; calling to a resource manager to write data to a data object; performing a write operation at the resource manager on behalf of the application object to write the data from the application object to the data object; logging, in the non-volatile memory, a reference to the application object to identify the application object as a source for the data that was written to the data object; and recording in the object table a flush order dependency between the application object and the data object.

Claim 22

In a database computer system having a non-volatile memory and a volatile main memory, the volatile main memory maintaining an application object, a data object, and an object table with entries identifying the application object and the data object, a computer-implemented method comprising the following steps: executing the application object; calling to a resource manager to write data to a data object; performing a write operation at the resource manager on behalf of the application object to write the data from the application object to the data object; logging, in the non-volatile memory, a reference to the application object to identify the application object as a source for the data that was written to the data object; and recording in the object table a flush order dependency between the application object and the data object.

Claim 23

A computer-implemented method as recited in claim 20, wherein the recording step comprises the step of storing in an object table entry that is associated with the application object, an identity of the data object.

Claim 24

A computer-implemented method as recited in claim 20, wherein the recording step comprises the step of storing in an object table entry that is associated with the data object, an identity of the application object.

Claim 25

A computer programmed to perform the steps of the computer-implemented method as recited in claim 20.

Claim 26

A computer-readable memory which directs a computer to perform the step in the method as recited in claim 20.

Claim 27

In a database computer system having a non-volatile memory, a volatile main memory, and an application object which executes from the main memory, wherein the non-volatile memory includes a stable log, a computer-implemented method comprising the following steps: executing the application object to perform operations which read data from, and write data to, a data object; posting to the stable log a log record for each operation involving the reading or writing of data, the log record containing a reference to either the application object or the data object to identify that referenced object as a source for the data that is read from or written to; establishing flush order dependencies between the application object and the data object, wherein some of the flush order dependencies become cyclic indicating a condition in which the application object should be flushed not later than the data object and the data object should be flushed not later than the application object; detecting a dependency cycle; and following detection of the dependency cycle, writing one of the application object or the data object to the stable log to break the dependency cycle to enable the application and data objects to be flushed sequentially according to an ordered flushing sequence.

Claim 28

In a database computer system having a non-volatile memory, a volatile main memory, and an application object which executes from the main memory, wherein the non-volatile memory includes a stable log, a computer-implemented method comprising the following steps: executing the application object to perform operations which read data from, and write data to, a data object; posting to the stable log a log record for each operation involving the reading or writing of data, the log record containing a reference to either the application object or the data object to identify that referenced object as a source for the data that is read from or written to; establishing flush order dependencies between the application object and the data object, wherein some of the flush order dependencies become cyclic indicating a condition in which the application object should be flushed not later than the data object and the data object should be flushed not later than the application object; detecting a dependency cycle; and following detection of the dependency cycle, writing one of the application object or the data object to the stable log to break the dependency cycle to enable the application and data objects to be flushed sequentially according to an ordered flushing sequence.

Claim 29

A computer-implemented method as recited in claim 25, wherein the writing step comprises writing the data object to the stable log.

Claim 30

A computer-implemented method as recited in claim 26, further comprising the step of flushing the application object to the non-volatile memory after the data object is written to the stable log.

Claim 31

A computer-implemented method as recited in claim 27, further comprising the step of flushing the data object to the non-volatile memory after the application object has been flushed to the non-volatile memory.

Claim 32

A computer programmed to perform the steps of the computer-implemented method as recited in claim 25.

Claim 33

A computer-readable memory which directs a computer to perform the step in the method as recited in claim 25.

Claim 34

In a database computer system having a cache manager which occasionally flushes objects from a volatile main memory to a non-volatile memory to preserve those objects in the event of a system crash, and wherein a dependency cycle exists between at least two objects such that the two objects should be flushed simultaneously, a computer-implemented method comprising the following steps: detecting a dependency cycle; and writing one of the two objects to the stable log to break the dependency cycle to enable the two objects to be flushed to the non-volatile memory in a sequential manner according to an ordered flushing sequence.

Claim 35

In a database computer system having a cache manager which occasionally flushes objects from a volatile main memory to a non-volatile memory to preserve those objects in the event of a system crash, and wherein a dependency cycle exists between at least two objects such that the two objects should be flushed simultaneously, a computer-implemented method comprising the following steps: detecting a dependency cycle; and writing one of the two objects to the stable log to break the dependency cycle to enable the two objects to be flushed to the non-volatile memory in a sequential manner according to an ordered flushing sequence.

Claim 36

A computer-implemented method as recited in claim 31, further comprising the step of flushing the objects according to the ordered flushing sequence after said writing step.

Claim 37

A computer programmed to perform the steps of the computer-implemented method as recited in claim 31.

Claim 38

A computer-readable memory which directs a computer to perform the step in the method as recited in claim 31.

Claim 39

A database computer system comprising: a volatile main memory; a non-volatile memory that persists across a system crash; a processing unit coupled to the main memory and the non-volatile memory; an application object stored in the volatile main memory and executable on the processing unit; a resource manager which interacts with the application object to mediate communication between the application object and a data object so that, during a write operation, the resource manager writes data from the application object to the data object; the resource manager being configured to log, in a log record on the non-volatile memory, a reference to the application object to identify the application object as a source for the data that was written to the data object; and the resource manager including a cache manager for establishing a flush order dependency between the application object and the data object as a result of the write operation and managing a flushing order in which the application object and the data object are occasionally flushed to the non-volatile memory according to the flush order dependency.

Claim 40

A database computer system comprising: a volatile main memory; a non-volatile memory that persists across a system crash; a processing unit coupled to the main memory and the non-volatile memory; an application object stored in the volatile main memory and executable on the processing unit; a resource manager which interacts with the application object to mediate communication between the application object and a data object so that, during a write operation, the resource manager writes data from the application object to the data object; the resource manager being configured to log, in a log record on the non-volatile memory, a reference to the application object to identify the application object as a source for the data that was written to the data object; and the resource manager including a cache manager for establishing a flush order dependency between the application object and the data object as a result of the write operation and managing a flushing order in which the application object and the data object are occasionally flushed to the non-volatile memory according to the flush order dependency.

Claim 41

A database computer system as recited in claim 35, wherein the resource manager logs an object identifier and a state identifier of the application object.

Claim 42

A database computer system as recited in claim 35, wherein the resource manager logs an object identifier and a state identifier of the data object.

Claim 43

A database computer system as recited in claim 35, wherein the cache manager maintains an object table having entries pertaining to the data object and the application object, the cache manager stores an identity of the data object in an entry associated with the application object to identify a dependency between the application object and the data object.

Claim 44

A database computer system as recited in claim 35, wherein the cache manager maintains an object table having entries pertaining to the data object and the application object, the cache manager stores an identity of the application object in an entry associated with the data object to identify a dependency between the application object and the data object.

Claim 45

A database computer system as recited in claim 35, wherein the cache manager maintains an object table having entries pertaining to the data object and the application object, the object table holding information pertaining to the dependency between the application object and the data object in at least one of an entry associated with the application object or an entry associated with the data object, the cache manager scanning the object table to discover dependencies between the application object and the data object prior to flushing either one of the objects.

Claim 46

A database computer system as recited in claim 35, wherein the cache manager flushes the application object and the data object in the flushing order dictated by the flush order dependency.

Claim 47

A database computer system as recited in claim 35, wherein the write operation results a dependency cycle between the data object and the application object indicating that the data and application objects should be flushed simultaneously, the cache manager being configured to detect the cycle dependency.

Claim 48

A database computer system as recited in claim 35, wherein the write operation results in a dependency cycle between the data object and the application object indicating that the data and application objects should be flushed simultaneously, the cache manager being configured to detect the cycle dependency and in response to said detection, to write one of the application object or the data object as a log record to the non-volatile memory to break the dependency cycle so that the application object and data object can be flushed to the non-volatile memory in a sequential manner.

Claim 49

A computer-readable medium storing an object table which tracks objects stored in a volatile memory and is used by a cache manager in flushing the objects from volatile memory to non-volatile memory, the object table having individual entry structures comprising: an object identifier field to hold an object identifier for an object; a node list field to hold a reference to a node table that identifies one or more node entries, each node entry identifying a logical node that forms a logical representation of one or more objects and any computer application operations that affect the one or more objects; and each said node entry having a data structure comprising (1) a "last" field that indicates when the object represented by the node was last updated, (2) a node ID field, (3) a predecessor field to hold a reference to a node for any object which must be flushed prior to flushing said object, and (4) a successor field to hold a reference to a node for any object which must be flushed after the flushing of said object.

Claim 50

A computer-readable medium storing an object table which tracks objects stored in a volatile memory and is used by a cache manager in flushing the objects from volatile memory to non-volatile memory, the object table having individual entry structures comprising: an object identifier field to hold an object identifier for an object; a node list field to hold a reference to a node table that identifies one or more node entries, each node entry identifying a logical node that forms a logical representation of one or more objects and any computer application operations that affect the one or more objects; and each said node entry having a data structure comprising (1) a "last" field that indicates when the object represented by the node was last updated, (2) a node ID field, (3) a predecessor field to hold a reference to a node for any object which must be flushed prior to flushing said object, and (4) a successor field to hold a reference to a node for any object which must be flushed after the flushing of said object.

Claim 51

An object table stored in a computer-readable medium as recited in claim 44, further comprising a dirty flag field to hold a flag bit indicating whether or not the object has been modified in the volatile memory without those modifications being flushed to the non-volatile memory.

Claim 52

An object table stored in a computer-readable medium as recited in claim 44, further comprising a cache location field to hold an address to a location in the main memory where the host object physically resides.