Oracle International Corporation

Compaq Computer Corporation, Inc.

Hewlett-packard Development Company, L.p.

Hewlett Packard Enterprise Development LP

Compaq Information Technologies Group, L.p.

Roger J Hansen

Sitaram V Lanka

Johannes Klein

Albert C Gondi

Kothanda Umamageswaran

Juan R Loaiza

Wei-Ming Hu

Pankaj Mehra

Alexander Tsukerman

Selcuk Aya

Neil J S MacNaughton

Kiran Badrinarain Goyal

Adam Y Lee

Eugene Reddy Ho

Vipin Gokhale

Boris Erlikhman

Bharat C V Baddepudi

Adrian Ng

Keith B Evans

Jia Shi

Vinay H Srihari

Alex Tsukerman

Sameer Arun Joshi

Jonghyun Lee

Umesh Panchaksharaiah

Samuel A Fineberg

Sam Fineberg

Tsz Him (Adrian) Ng

Techniques are provided for using an intermediate cache between the shared cache of an application and the non-volatile storage of a storage system. The application may be any type of application that uses a storage system to persistently store data. The intermediate cache may be local to the machine upon which the application is executing, or may be implemented within the storage system. In one embodiment where the application is a database server, the database system includes both a DB server-side intermediate cache, and a storage-side intermediate cache. The caching policies used to populate the intermediate cache are intelligent, taking into account factors that may include which object an item belongs to, the item type of the item, a characteristic of the item, or the type of operation in which the item is involved.

Caching data between a database server and a storage system

A system and method is described that accesses a network persistent memory unit (nPMU). One embodiment comprises a primary region corresponding to a predefined portion of a primary network persistent memory unit (nPMU) communicatively coupled to at least one client processor node via a communication system, wherein the primary region is assigned to a client process running on the client processor node and is configured to store information received from the client process; and a mirror region corresponding to a predefined portion of a mirror nPMU communicatively coupled to the client processor node via the communication system, wherein the mirror region is assigned to the client process and is configured to store the information received from the client process.

Communication-link-attached persistent memory system

A system is described that includes a network interface attached to a persistent memory unit. The persistent memory unit is configured to receive checkpoint data from a primary process, and to provide access to the checkpoint data for use in a backup process, which provides recovery capability in the event of a failure of the primary process. The network interface is configured to provide address translation information between virtual and physical addresses in the persistent memory unit. In other embodiments, the persistent memory unit is capable of storing multiple updates to the checkpoint state. The checkpoint state and the updates to the checkpoint state, if any, can be retrieved by the backup process periodically, or all at once upon failure of the primary process.

Persistent memory device for backup process checkpoint states

An improved approach is described for implementing transformations of data records in high concurrency environments. Each transformation is performed in parallel at the source when the data record is first generated. According to one approach for data integrity validation, record generators compute an integrity checksum for a newly generated record before copying into a data unit in shared memory. Subsequent generators may aggregate integrity checksums for data records into checksums for data units incrementally. This approach achieves end-to-end protection of data records against corruption using an efficient method of maintaining verifiable data integrity. In another approach, compression and encryption data transformations may be performed by themselves, or in combination with an integrity checksum transformation.

Method and system for implementing parallel transformations of records

Techniques are provided for using an intermediate cache between the shared cache of a database server and the non-volatile storage of a storage system. The intermediate cache may be local to the machine upon which the database server is executing, or may be implemented within the storage system. In one embodiment, the database system includes both a DB server-side intermediate cache, and a storage-side intermediate cache. The caching policies used to populate the intermediate cache are intelligent, taking into account factors that may include which database object an item belongs to, the item type of the item, a characteristic of the item; or the database operation in which the item is involved.

Techniques are provided for isolating faults in a software program by providing at least two code paths that are capable of performing the same operation. When a fault occurs while the one of the code paths is being used to perform an operation, data that indicates the circumstances under which the fault occurred is stored. For example, a fault-recording mechanism may store data that indicates the entities that were involved in the failed operation. Because they were involved in an operation that experienced a fault, one or more of those entities may be 'quarantined'. When subsequent requests arrive to perform the operation, a check may be performed to determine whether the requested operation involves any of the quarantined entities. If the requested operation involves a quarantined entity, a different code path is used to perform the operation, rather than the code path from which the entity is quarantined.

Fault isolation using code paths

A protocol for a transaction involving two homogeneous or two heterogeneous computing systems involves starting a transaction on one of the two systems, sending a request for participation in the transaction to an application resident on the other of the two systems, together with an identification and address of the transaction. Upon receipt of the request, the application will initiate a subordinate transaction through a resident (subordinate) transaction manager. The subordinate transaction manager will notify the Beginner transaction manager and at the same time cause the application to start work on the request. Later, the subordinate transaction, through the subordinate transaction manager participates in a two-phase commit protocol that concludes the transaction to ensure that all changes effected by the transaction are done, or none are done, i.e., the transaction is aborted.

Method and apparatus for conducting a transaction between homogeneous and/or heterogeneous transaction processing systems using asynchronous pull of a transaction transfer

Systems and Methods for identifying in the gateway processes or application processes whether an imported transaction is a loop-back transaction, and if so performing work for the imported transaction under the parent transaction. Upon receiving a work request from a remote transaction processing system, an endpoint identifier included as part of the work request is analyzed to determine whether the work request is associated with a parent transaction initiated at the local transaction processing system. If the endpoint identifier indicates that the work request is associated with a transaction initiated in the local transaction processing system, a global transaction identifier included as part of the work request is analyzed to determine the identity of the parent transaction. If the work request includes a remote TIP URL, the application process that receives the request is configured to analyze the global transaction identifier and determine the identity of the parent transaction. If the remote transaction processing system sends a push request, the gateway process that receives the request is configured to analyze the global transaction identifier and determine the identity of the parent transaction. Work is thereafter performed according to the work request under the parent transaction such that a new transaction is not initiated.

Systems and methods for the detection of a loop-back of a transaction

Systems and methods for supporting and maintaining a distributed global map of transaction identifiers at the gateway processes using a hashing algorithm configured on each application process to access the global maps. A global map of transaction identifiers that associates global transaction identifiers with remote local transaction identifiers is maintained at each gateway process. When an application process performing work for a particular transaction desires to export the transaction to a remote node, a hashing function configured on the application process is applied to the global transaction identifier associated with the particular transaction. Application of the hashing function to the global transaction identifier identifies one of the gateway processes. The global transaction identifier is stored to the global map associated with that gateway process. When the remote transaction manager associated with the remote node responds with a local transaction identifier for a local transaction initiated at the remote node, the local transaction identifier is stored to the identified gateway's global map in association with the global transaction identifier. Each application process is configured with the same hashing function so that the same gateway process will always be identified given a particular global transaction identifier. If the same or another application process desires to export to a remote node a transaction that has already been exported, the hashing function on that application process identifies the same gateway through which the transaction was originally exported.

Process of maintaining a distributed map of transaction identifiers and using hashing to access these maps

Systems and methods for ensuring that two different subordinate transactions will not be created at any given transaction processing node for the same parent transaction. Upon receiving a work request from a remote transaction processing system, the local transaction manager creates a local subordinate transaction associated with the parent transaction. A local transaction identifier that identifies the local subordinate transaction is also created. The local identifier includes an indicator, such as a one-bit flag, which identifies the local subordinate transaction as an imported transaction. The global identifier for the parent transaction is stored to a map in association with the transaction identifier of the new local subordinate transaction. If a work request associated with an imported transaction is sent to a remote transaction processing system, the global transaction identifier of the parent transaction is retrieved from the map and included in the work request so that the receiving system will know that the work request is associated with the parent transaction. In this manner, the receiving system will know not to start a new subordinate transaction on behalf of the parent transaction if a transaction subordinate to the parent transaction has already been started on that system.

Detection of an imported transaction for finding the global transaction identifier

Growing community of inventors

San Francisco, CA, United States of America

Roger J Hansen