|Publication number||US7284151 B2|
|Application number||US 10/624,242|
|Publication date||Oct 16, 2007|
|Filing date||Jul 21, 2003|
|Priority date||Jul 21, 2003|
|Also published as||US20050022047|
|Publication number||10624242, 624242, US 7284151 B2, US 7284151B2, US-B2-7284151, US7284151 B2, US7284151B2|
|Original Assignee||Oracle International Corporation|
|Export Citation||BiBTeX, EndNote, RefMan|
|Patent Citations (17), Non-Patent Citations (3), Referenced by (24), Classifications (9), Legal Events (4)|
|External Links: USPTO, USPTO Assignment, Espacenet|
The present invention relates generally to data processing, and more particularly to accessing shared data in a clustered database system.
Data locking protocols are commonly used to manage access to shared data in a multi-processing environment. In a typical locking protocol, processes seeking read or write access to a data resource acquire locks to the resource to prevent incompatible accesses. For example, a process seeking to update a data resource (e.g., through a write operation or other data-modifying operation), requests an exclusive lock to the resource from a master process for that resource. After the master process grants the exclusive lock to the requester process, the requester process obtains a local copy of the resource, for example from a disk drive or other persistent storage, then performs update operations on the local copy, rendering the corresponding content of the persistent storage stale. Other requests to access the data resource are denied by the master pending release of the exclusive lock by the prior requester process. By serializing access to the data resource in this way, loss of data coherency is avoided as the subsequent requester processes are prevented from accessing stale data.
Not all accesses to shared resources must be serialized. For example, multiple shared locks may typically be held simultaneously by processes seeking to read the same data resource, as no loss of coherency will occur due to the order in which the read accesses take place. By contrast, if a requester process requests an exclusive lock to a data resource while a shared lock is open (i.e., shared lock granted and not yet released), the master process may deny the exclusive lock request until the shared lock is released to ensure that no out-of-order access occurs.
One contingency that locking protocols must usually account for is failure of a processing node. Referring to
In one prior-art locking protocol, a single process referred to herein as a centralized lock manager acts as the resource master for all shared resources in the database system. When a node fails, the centralized lock manager may continue to grant access to data resources that were not exclusively locked by the failed node. Thus, the centralized lock manager enables at least limited access to the shared data storage while the update operations performed by the failed node are recovered. On the downside, because all lock requests are directed to the centralized lock manager, the centralized lock manager tends to be a scalability bottleneck, degrading system performance as the number of processes and lock requests grows. Also, the centralized lock manager constitutes a single point of failure. If the node executing the centralized lock manager fails, all locking activity ceases, in effect rendering the shared data storage inaccessible and resulting in system-wide failure.
In another prior-art locking protocol, mastership of shared data resources is distributed among multiple lock manager processes each being executed by a respective one of the processing nodes 105. Thus, each processing node is a master for a subset of the shared resources. When a processing node fails, locking activity is temporarily halted and mastership of the resources mastered in the failed node is redistributed among the surviving nodes. Locking activity is resumed after the surviving nodes have completed applying the changes recorded in the redo log for the failed node. Although the single point failure and scalability limitations of the centralized lock manager approach are avoided, access to the shared data resources is denied until resource mastership is redistributed among the surviving nodes and the surviving nodes complete redoing the changes recorded in the redo log for the failed node.
Another prior-art locking protocol replicates mastership for each shared resource in two or more processing nodes, referred to as siblings. When the master for a particular resource fails, the sibling for the failed node will still have the locking information for the shared resource so that locking activity may continue during the recovery process. Unfortunately this replicated mastership approach substantially increases the amount of inter-process communication required for resource locking, decreasing system performance and limiting system scalability.
In yet another prior-art locking protocol coarse-grained locks are issued to enable exclusive or shared access to multiple data resources. Once a process acquires a coarse-grained lock, all data resources covered by that lock can be accessed even after a processing node failure, because the process owning the coarse-grained lock is assured that the failed node could not have modified any of the data resources. However, because many of the locked data resources may not actually be accessed by the lock holding process, coarse-grained locks tend to substantially increase false contention, leading to poor run-time performance.
The features and advantages of the present invention are illustrated by way of example, and not by way of limitation, in the figures of the accompanying drawings and in which like reference numerals refer to similar elements and in which
In embodiments of the present invention, lock management responsibility is distributed among multiple processing nodes in a shared-storage database system. When a node failure is detected, shared data resources are rendered conditionally accessible prior to full recovery of the failed node changes and without replication of resource mastership in multiple nodes, thereby reducing average access delay after node failure without increasing susceptibility to single point of failure and without limiting system scalability.
Overview of Conditional-Access Failure Recovery
The failure recovery operation 200 is initiated when a processing node failure is detected, as indicated by dashed line 201. Failure of a processing node may be detected in a number of ways including, without limitation, loss of heartbeat (i.e., periodic transmission or other detectable action by the failed node ceases to occur), non-response to communication or affirmative failure notification from the failed node. Initially, as shown at 202, each of the non-failed processing nodes, referred to herein as surviving nodes, identify and release locks held by the failed node, appending the resources locked exclusively by the failed node to a data structure referred to herein as a validation queue. The validation queue is discussed below in further detail.
After the locks held by the failed node have been released, mastership of the resources formerly mastered in the failed node is redistributed to the surviving nodes as shown at 204. Mastership redistribution involves two operations: reassignment of resource mastership to surviving nodes and lock list recovery. Both of these operations are described in detail below. Together the operations at 202 and 204 constitute a lock recovery phase of the overall failure recovery operation 200, as the records of locks granted to the failed node are cleared from the surviving nodes, and the lock mastership and lock grant status formerly maintained in the failed node are re-established in the surviving nodes. After the lock recovery phase is completed, one or more processes are executed in the surviving nodes to redo the transactions recorded in the redo log for the failed node, as indicated at 206. The redo operations collectively constitute a resource recovery phase of the failure recovery operation 200, as the redone transactions place the shared resources in the state they would have had in absence of the node failure. When all the transactions recorded in the redo log for the failed node have been redone, the recovery operation 200 is completed.
In contrast to the prior-art distributed lock management system described above, locking activity is not halted upon detecting the node failure, but rather is continued on a conditional basis throughout the lock recovery and resource recovery phases of the recovery operation. More specifically, during the lock recovery phase (i.e., between times 201 and 203), the surviving nodes may grant access to resources for which the failed node was not the resource master and for which the failed node did not hold an exclusive lock at the time the failure was detected. Such resources are referred to herein as zero-delay resources, as access to such resources may be granted without delay (or with negligible delay) following detection of the node failure. In the event of multiple requests to access the same zero-delay resource, lock grants may need to be serialized (e.g., through granting of exclusive locks) to avoid incompatible accesses, but the node failure itself does not mandate delay in granting access to the resources.
After mastership has been redistributed (i.e., during the resource recovery phase), the surviving nodes may continue to grant access to the zero-delay resources and may additionally grant access to a second category of resources referred to herein as partial-delay resources. Partial-delay resources are resources for which the failed node was the resource master and for which a surviving node (or a process executed thereon) held a lock at the time the node failure was detected. The existence of the orphaned lock (i.e., lock granted by a failed master) enables a logical conclusion that the failed node could not have held an exclusive lock to the resource. Accordingly, as soon as the resource is re-mastered (i.e., assigned a new lock master) and the list of lock holders for the resource regenerated, requests to access the resource may be granted. More specifically, if the orphaned lock (or locks) is a shared lock, then additional shared locks may be granted to requester processes immediately after re-mastering. If the orphaned lock is an exclusive lock, or the post-failure requester process seeks exclusive access, locking protocol may be used to serialize accesses to the resource. In either case, access to the partial-delay resources may be granted prior to completion of the resource recovery phase.
Note that partial-delay resources are referred to as such because the mastership redistribution imposes at least some access delay on resources that were mastered in the failed node. In one embodiment, referred to herein as a synchronized redistribution embodiment, no partial-delay resources are accessible until redistribution of mastership is completed for all re-mastered resources. In an alternative embodiment, referred to herein as an incremental redistribution embodiment, redistribution of mastership may be determined to be complete for some re-mastered resources before others. In the incremental redistribution embodiment, access to the re-mastered resources for which redistribution of mastership is determined to be complete may be granted prior to completion of mastership redistribution for other re-mastered resources. In either embodiment, after the resource recovery phase is completed (indicated at 205), full access to all shared resources is restored, though still subject to serialization by the resource locking protocol.
Assuming that node N1 fails at time T1, the lock release operation described in reference to block 202 of
After the surviving nodes N2 and N3 release the locks held by N1, the mastership redistribution operation described in reference to block 202 of
In the lock list recovery operation, indicated by reference numeral 227, the lock status for each re-mastered resource is recovered based on the locks held by the surviving nodes. In one embodiment, a lock list recovery process is executed within each surviving node to identify locks held to re-mastered resources and to notify the new master of the lock. In the exemplary lock list recovery of
Reflecting on the lock list recovery 227, it should be noted that, because node N1 has failed, node N1 will likely be unable to notify the new master for resource 130 (i.e., node N3) of the exclusive lock held by node N1. This fact illustrates a basic distinction between re-mastered resources for which at least one surviving node (or a process executing thereon) held a lock at the time of the node failure and re-mastered resources for which no surviving node held a lock. If a surviving node held a lock, then the failed node could not have held an exclusive lock to the re-mastered resource. By contrast, if no surviving node held a lock to the re-mastered resource, then, absent information from the failed node, the surviving nodes cannot determine whether the failed node held an exclusive lock to the resource. Thus, even though resource 130 is shown to be unlocked after the lock list recovery at 227, resource 130 is not a partial-delay resource and remains unavailable until the transactions recorded in the redo log for the failed node are redone.
Still referring to
Releasing Locks Held by the Failed Processing Node
If the end of the lock list is detected in decision block 233, the lock release operation 230 is completed. Otherwise, the lock holder component of the selected lock data value is compared with an identifier of the failed node in decision block 235 to determine whether the lock was granted to the failed node. If the lock was not granted to the failed node, no action is taken for the indicated lock, and the next lock data value is selected in block 231. If the lock was granted to the failed node, then the lock mode component of the selected lock data value is evaluated in decision block 237 to determine whether an exclusive lock was granted to the failed node. If so, then the resource indicated by the resource ID component of the selected lock data value is appended to a validation queue at block 239 and the lock data value is released from the lock list at 241. If a non-exclusive lock (e.g., a shared lock) was granted to the failed node, then the validation queue operation at 239 is skipped and the lock data value released at 241. In the linked list embodiment of
In one embodiment, the master process within a given node maintains the lock list and traverses the list in response to resource access requests to determine whether any incompatible locks are open for the resource. Thus, the release of a lock data value at 241 effectively releases a lock to a shared resource and, in the absence of other locks to the resource, enables subsequent requestor processes to access the resource. Because resources locked exclusively by the failed node are not zero-delay resources or partial-delay resources (i.e., the resources may be stale) such resources are appended to the validation queue at 239 to signal their status as inaccessible during the failure recovery operation.
Redistribution of Resource Mastership
Starting at block 285, the recovery process updates a cluster incarnation number (CIN), generates a list of processing nodes that constitute the present cluster incarnation and initializes an index variable, i, to zero. Herein, the expression “cluster incarnation” refers to the processing node configuration within the database system (i.e., cluster of processing nodes), and each new configuration has a corresponding cluster incarnation number. In one implementation, the cluster incarnation number is assigned a predetermined value for an initial cluster incarnation, and then incremented for each new cluster incarnation thereafter. In the case of a node failure, for example, a new cluster incarnation results from the loss of the failed node, and a new cluster incarnation number is generated to represent the surviving set of processing nodes. Thus, in the exemplary database system described in reference to
In one embodiment, each processing node in the database system maintains a global resource list (GRL) that identifies the resource master for each shared resource and the cluster incarnation (i.e., processing node configuration) in which the resource master was assigned. During normal operation, the global resource list is used to look up the resource master for a given resource so that access requests can be issued to the appropriate processing node. During failure recovery, the resource master information is used to identify resources mastered in the failed node and the cluster incarnation information is used to identify resources that have been re-mastered in the present cluster incarnation.
In one embodiment, illustrated in
In an alternative embodiment, the global resource list is composed of multiple sub-lists, with each sub-list being maintained for a respective group of shared resources. By this arrangement, the length of any linked list that must be traversed to find a resource data element for a given resource is reduced. A hash function, lookup or other technique may be used to deterministically group resources within one or more of the sub-lists. Thus, a process seeking information about a given resource may apply the hash function (or other group identifying technique) to the resource ID to identify the applicable sub-list for that resource, then traverse the sub-list to obtain the resource data element that corresponds to the resource ID. In one embodiment, recovery processes which access the GRL operate on groups of resources at a time, thereby completing component recovery operations one group at a time (e.g., lock release, master reassignment, lock list recovery, resource recovery). In such an embodiment, partial-delay resources that fall into a first-processed group may become accessible prior to subsequently processed resource groups. Thus, requests to access some partial-delay resources may be granted prior to completion of mastership redistribution for all resource groups. Hereinafter, reference to traversing the global resource list to identify a resource data element for a given resource should be understood to include an embodiment in which an initial operation of identifying a sub-list of resources prior to list traversal. It should be noted that the lock list described above in reference to
For i = 0 to (D−1) LookupTable[i].RsrcMaster = Node [i mod N] LookupTable[i].RsrcCIN = CIN i = i + 1 End For
The dimension of the array, D, may be any number, but is preferably large enough to ensure a relatively even assignment of the N processing nodes to the data elements of the lookup table 311. In one embodiment, for example, D is assigned (or declared to be) the value of the least common multiple of all numbers from 1 to N (i.e., the smallest number that all numbers from 1 to N divide into evenly).
The lookup table 311 may be updated after a processing node failure, for example, by scanning the array to identify data elements for which the RsrcMaster component matches the failed node identifier, assigning identifiers of surviving nodes to the RsrcMaster components of such data elements in round-robin fashion, and updating the RrscCIN components of such data elements with the number for the new cluster incarnation. The following pseudo-code listing illustrates an example of this operation (note that the number of processing nodes, N, and the node list, Node[ ], are first updated to reflect the new cluster incarnation as discussed above in reference to
For i = 0 to (D−1) If LookupTable[i].RsrcMaster = Failed Node ID, Then LookupTable[i].RsrcMaster = Node [i mod N] LookupTable[i].RsrcCIN = CIN End If i = i + 1 End For
Other techniques may be used to update the lookup table 311 in alternative embodiments (e.g., assigning a single processing node identifier to the RsrcMaster component of all data elements previously assigned the identifier of the failed node).
After the lookup table 311 has been initialized or updated, the master for a given node may be looked up by using a hash function to generate a lookup table index based on the resource identifier. For example, in one embodiment, a modulus function is used to generate the index for a given resource ID as follows: LookupTable Index=Resource ID mod D. By generating a lookup table index in this manner, the resource master and cluster incarnation number for a given resource may be obtained without having to traverse a linked list of resource data elements. The resource identifier for a given resource may be determined in a number of ways depending on the nature of the resources and system needs. In one embodiment, for example, the resource identifier is determined based on a logical or physical address of a data resource within a data storage device. In an alternative embodiment, resource identifiers are assigned to resources on an as-needed basis by a resource manager and provided to processes (or other requesting entities) on request. More generally, any techniques for obtaining or determining resource identifiers may be used without departing from the scope of the present invention.
For simplicity of description, embodiments described below refer to obtaining resource master information and cluster incarnation information from a global resource list as described in reference to
Returning to operation 320 of
Returning to decision block 327, if the resource CIN does not match the present CIN, then the resource was not re-mastered in the present cluster incarnation and therefore was mastered in the same node before and after node failure. Accordingly, the message sending operation at block 329 is skipped and execution loops back to block 321 to obtain the next held-lock data element. When the end of the held-locks list is detected in decision block 323, the local recovery process sends a lock-recovery-complete message to the recovery processes in other surviving nodes, if any, to notify those processes that all lock recovery messages have been sent by the local recovery process.
Still referring to
Handling Access Requests During Failure Recovery
Returning to decision block 403, if a failure recovery operation is in progress, then the shared resource is located in the global resource list at block 407 so that the identifier of the resource master (RsrcMaster) and cluster incarnation number for the resource (i.e., resource CIN) may be retrieved. In an embodiment in which resources are added to the global resource list when first accessed, the resource may be assigned a master and added to the global resource list if not found in the operation at block 407. At decision block 409, the identifier of the resource master is compared with the failed node identifier to determine if the resource is mastered in the failed node. If so, then the resource is not a zero-delay resource, but may be a partial-delay resource; a status that will not be known until mastership for the resource is redistributed (i.e., until the resource is re-mastered in a surviving node and the lock list for the resource is at least partially recovered). Accordingly, in one embodiment, the access request is queued in a retry queue at block 419 until mastership for the resource is redistributed. In an alternative embodiment, the access request may be denied outright, or denied with notification to retry the request after a predetermined delay or after mastership for the resource is determined to be redistributed.
If the failed node is determined not to be the resource master at decision block 409, then the resource CIN is compared with the present CIN at decision block 411 to determine whether the resource has been re-mastered in the present cluster incarnation. If the resource CIN does not match the present CIN, then the resource was not re-mastered in the present cluster incarnation, and therefore was not mastered in the failed node. If not re-mastered, then the resource is a zero-delay resource if the failed node did not hold an exclusive lock to the resource. Accordingly, if the resource is not on the validation queue (determined by searching the validation queue in decision block 413), then the resource was not exclusively locked by the failed node and therefore constitutes a zero-delay resource. In that case, the access request is queued in block 405. If the resource is on the validation queue, then the resource was exclusively locked by the failed node and the access request is denied. In an alternative embodiment, the access request may be queued on a wait queue that is processed after the failed node transactions recorded in the redo log have been redone (i.e., access delayed until recovery is completed).
Reflecting on the identification of zero-delay resources, it should be noted that access requests received prior to completion of the lock release operation described in reference
As discussed above, shared resources that are not zero-delay resources or partial-delay resources are brought up to date (i.e., recovered) during the resource recovery phase by applying transactions recorded in the redo log for the failed processing node. In one embodiment, the transactions recorded in the redo log are performed on a resource-by-resource basis (or by groups of resources) so that some shared resources are recovered before others. In such an embodiment, resources that have been recovered may be added to a recovered resource list having a structure similar to the validation queue described in reference to
Lock Release in Resource-Transferring Embodiment
In one embodiment, a process referred to herein as a coherency manager operates as an intermediary between requestor processes and a data storage device. For example, after an access request has been granted to a requester process (e.g., shared lock or exclusive lock issued to requestor process), the requestor process issues a resource retrieval request to the coherency manager which, in response, accesses the data storage device to retrieve the requested resource. Similarly, after a requestor process has updated a resource and commits the changes (e.g., records the changes in a redo log), the requestor process issues a resource write request to the coherency manager, which writes the updated data to the physical storage media within the data storage device (e.g., magnetic, optical or semiconductor media).
In one implementation, the coherency manager identifies access requests directed to a shared resource already retrieved for another requestor process, and passes the resource directly from the first requester to the subsequent requester without first writing the resource (which may be modified) to the data storage device. While such resource transfer operations reduce accesses to the data storage device (which tend to be slow and therefore prone to congestion), the transferred resource presents challenges in the face of node failure. For example, in one implementation, a sequence of transfer operations (e.g., resource transferred from one requester process to another) is unwound to the requestor process that made the most recent update to the transferred resource to enable that process to manage the write to data storage device via the cache coherency manager. That is, after a first requester process updates a shared resource, commits the changes (i.e., producing a transaction record in the redo log) and releases its exclusive lock, the updated resource may be transferred to any number of subsequent requestor processes before being returned to the first requester process to be written to the data storage device. Consequently, if the processing node executing the first requestor process fails before the resource transfer to subsequent processes is unwound, the first requester process will be unavailable to complete the write operation. In one implementation, this problem is managed by enabling one of the transferee processes (i.e., processes that received the updated resource in a transfer operation), to write the updated resource to shared storage on behalf of the first requestor process. In some systems, however, it may be desirable to enable the recovery process to redo the changes made by the first requestor process rather than reassign the write responsibility to a transferee process. In such systems, so long as the sequence of transfer operations does not unwind all the way to a dead updating process (i.e., the requestor process that made changes to the shared resource, then became unavailable due to processing node failure) prior to completion of the failure recovery operation, data coherency will be maintained. By contrast, if all the transferee processes release their locks to the resource prior to completion of the failure recovery operation, the resource will be unlocked and yet the resource instance in the shared storage will be stale. Thus, in one embodiment of the invention, requests to release locks are managed during a failure recovery operation by determining whether at least one lock remains open for the resource. If so, then the process requesting lock release cannot be the final process in a transfer-unwind sequence, and therefore performing the requested lock release will not expose a subsequent requester process to obtaining stale data in a data retrieval operation. That is, so long as there is one open lock, a subsequent requester will obtain the resource in a transfer operation rather than from the potentially stale source in the shared storage.
Still referring to
The embodiments described above may be implemented in a programmed general-purpose or special-purpose computer system or in a network of computer systems. Alternatively, the embodiments may be implemented in a device that includes hardwired logic for carrying out the above-described operations, or any combination of programmed processors and hardwired logic.
Computer system 500 may be coupled via bus 502 to a display 512, such as a cathode ray tube (CRT), for displaying information to a computer user. An input device 514, including alphanumeric and other keys, is coupled to bus 502 for communicating information and command selections to processing entity 504. Another type of user input device is cursor control 516, such as a mouse, a trackball, or cursor direction keys for communicating direction information and command selections to processing entity 504 and for controlling cursor movement on display 512. This input device typically has two degrees of freedom in two axes, a first axis (e.g., x) and a second axis (e.g., y), that allows the device to specify positions in a plane.
The invention is related to the use of computer system 500 for implementing the techniques described herein. According to one embodiment of the invention, those techniques are performed by computer system 500 in response to processing entity 504 executing one or more sequences of one or more instructions contained in main memory 506. Such instructions may be read into main memory 506 from another computer-readable medium, such as storage device 510. Execution of the sequences of instructions contained in main memory 506 causes processing entity 504 to perform the operations described herein. In alternative embodiments, hard-wired circuitry may be used in place of or in combination with software instructions to implement the invention. Thus, embodiments of the invention are not limited to any specific combination of hardware circuitry and software.
The term “computer-readable medium” as used herein refers to any medium that participates in providing instructions to processing entity 504 for execution. Such a medium may take many forms, including but not limited to, non-volatile media, volatile media, and transmission media. Non-volatile media includes, for example, optical or magnetic disks, such as storage device 510. Volatile media includes dynamic memory, such as main memory 506. Transmission media includes coaxial cables, copper wire and fiber optics, including the wires that comprise bus 502. Transmission media can also take the form of acoustic or light waves, such as those generated during radio-wave and infra-red data communications.
Common forms of computer-readable media include, for example, a floppy disk, a flexible disk, hard disk, magnetic tape, or any other magnetic medium, a CD-ROM, any other optical medium, punchcards, papertape, any other physical medium with patterns of holes, a RAM, a PROM, and EPROM, a FLASH-EPROM, any other memory chip or cartridge, a carrier wave as described hereinafter, or any other medium from which a computer can read.
Various forms of computer readable media may be involved in carrying one or more sequences of one or more instructions to processing entity 504 for execution. For example, the instructions may initially be carried on a magnetic disk of a remote computer. The remote computer can load the instructions into its dynamic memory and send the instructions over a telephone line using a modem. A modem local to computer system 500 can receive the data on the telephone line and use an infra-red transmitter to convert the data to an infra-red signal. An infra-red detector can receive the data carried in the infra-red signal and appropriate circuitry can place the data on bus 502. Bus 502 carries the data to main memory 506, from which processing entity 504 retrieves and executes the instructions. The instructions received by main memory 506 may optionally be stored on storage device 510 either before or after execution by processing entity 504.
Computer system 500 also includes a communication interface 518 coupled to bus 502. Communication interface 518 provides a two-way data communication coupling to a network link 520 that is connected to a local network 522. For example, communication interface 518 may be an integrated services digital network (ISDN) card or a modem to provide a data communication connection to a corresponding type of telephone line. As another example, communication interface 518 may be a local area network (LAN) card to provide a data communication connection to a compatible LAN. Wireless links may also be implemented. In any such implementation, communication interface 518 sends and receives electrical, electromagnetic or optical signals that carry digital data streams representing various types of information.
Network link 520 typically provides data communication through one or more networks to other data devices. For example, network link 520 may provide a connection through local network 522 to a host computer 524 or to data equipment operated by an Internet Service Provider (ISP) 526. ISP 526 in turn provides data communication services through the world wide packet data communication network now commonly referred to as the “Internet” 528. Local network 522 and Internet 528 both use electrical, electromagnetic or optical signals that carry digital data streams. The signals through the various networks and the signals on network link 520 and through communication interface 518, which carry the digital data to and from computer system 500, are exemplary forms of carrier waves transporting the information.
Computer system 500 can send messages and receive data, including program code, through the network(s), network link 520 and communication interface 518. In the Internet example, a server 530 might transmit a requested code for an application program through Internet 528, ISP 526, local network 522 and communication interface 518.
The received code may be executed by processing entity 504 as it is received, and/or stored in storage device 510, or other non-volatile storage for later execution. In this manner, computer system 500 may obtain application code in the form of a carrier wave.
The section headings in the preceding detailed description are provided for convenience of reference only, and in no way define, limit, construe or describe the scope or extent of such sections. Also, while the invention has been described with reference to specific exemplary embodiments thereof, it will be evident that various modifications and changes may be made thereto without departing from the broader spirit and scope of the invention. The specification and drawings are, accordingly, to be regarded in an illustrative rather than restrictive sense.
|Cited Patent||Filing date||Publication date||Applicant||Title|
|US4885684||Dec 7, 1987||Dec 5, 1989||International Business Machines Corporation||Method for compiling a master task definition data set for defining the logical data flow of a distributed processing network|
|US5305448 *||Sep 16, 1993||Apr 19, 1994||International Business Machines Corp.||Shared access serialization featuring second process lock steal and subsequent write access denial to first process|
|US5550973 *||Mar 15, 1995||Aug 27, 1996||International Business Machines Corporation||System and method for failure recovery in a shared resource system having a moving write lock|
|US5553303 *||Dec 20, 1994||Sep 3, 1996||Fujitsu Limited||Data processing system for dynamically switching access control process and for performing recovery process|
|US5615254||Apr 4, 1995||Mar 25, 1997||U S West Technologies, Inc.||Methods and systems for dynamic routing in a switched comunication network|
|US5623671 *||Mar 13, 1995||Apr 22, 1997||Nec Corporation||Mutual exclusion control apparatus for mutual exclusion control based on locking and unlocking requests|
|US5920872 *||Jun 25, 1996||Jul 6, 1999||Oracle Corporation||Resource management using resource domains|
|US5966706||Feb 19, 1997||Oct 12, 1999||At&T Corp||Local logging in a distributed database management computer system|
|US6199105 *||Dec 9, 1998||Mar 6, 2001||Nec Corporation||Recovery system for system coupling apparatuses, and recording medium recording recovery program|
|US6275953||Sep 26, 1997||Aug 14, 2001||Emc Corporation||Recovery from failure of a data processor in a network server|
|US6301676 *||Jan 22, 1999||Oct 9, 2001||Sun Microsystems, Inc.||Robust and recoverable interprocess locks|
|US6374362 *||Jan 13, 1999||Apr 16, 2002||Nec Corporation||Device and method for shared process control|
|US6510350||Apr 7, 2000||Jan 21, 2003||Steen, Iii Henry B.||Remote data access and system control|
|US6539446 *||May 7, 1999||Mar 25, 2003||Oracle Corporation||Resource locking approach|
|US6574749 *||Oct 29, 1999||Jun 3, 2003||Nortel Networks Limited||Reliable distributed shared memory|
|US6697901 *||Oct 24, 2000||Feb 24, 2004||Oracle International Corporation||Using secondary resource masters in conjunction with a primary resource master for managing resources that are accessible to a plurality of entities|
|EP1310873A1||Oct 11, 2002||May 14, 2003||Sun Microsystems, Inc.||Error recovery|
|1||Cai, "Building Highly Available Database Servers Using Oracle Real Application Clusters," Oracle Corporation, May 2001, pp. 1-16.|
|2||Josten et al., "DB2's Use of the Coupling Facility for Data Sharing," IBM 1997, pp. 1-30.|
|3||Yu et al., "On Affinity Based Routing in Multi-System Data Sharing," Proc. of 12th Int. Conf. on Very Large Databases (Kyoto), Aug. 1986, pp. 249-256.|
|Citing Patent||Filing date||Publication date||Applicant||Title|
|US7493618 *||Sep 19, 2003||Feb 17, 2009||International Business Machines Corporation||Fault tolerant mutual exclusion locks for shared memory systems|
|US7784049 *||Aug 24, 2010||Emc Corporation||System and method for providing a plurality of virtual computing environments that efficiently use data in the virtual environments|
|US7921169||Apr 5, 2011||Oracle International Corporation||System and method for exactly once message store communication|
|US7962915 *||Jun 14, 2011||International Business Machines Corporation||System and method for preserving state for a cluster of data servers in the presence of load-balancing, failover, and fail-back events|
|US8234646 *||Jul 31, 2012||International Business Machines Corporation||Fault tolerant mutual exclusion locks for shared memory systems|
|US8489636||Nov 4, 2010||Jul 16, 2013||Vmware, Inc.||Providing multiple concurrent access to a file system|
|US8543781||Sep 23, 2009||Sep 24, 2013||Vmware, Inc.||Hybrid locking using network and on-disk based schemes|
|US8560747||Feb 16, 2007||Oct 15, 2013||Vmware, Inc.||Associating heartbeat data with access to shared resources of a computer system|
|US8700585 *||Nov 26, 2008||Apr 15, 2014||Vmware, Inc.||Optimistic locking method and system for committing transactions on a file system|
|US9031984||Jul 15, 2013||May 12, 2015||Vmware, Inc.||Providing multiple concurrent access to a file system|
|US9130821||Sep 23, 2013||Sep 8, 2015||Vmware, Inc.||Hybrid locking using network and on-disk based schemes|
|US9389926 *||May 5, 2010||Jul 12, 2016||Red Hat, Inc.||Distributed resource contention detection|
|US20050066064 *||Sep 19, 2003||Mar 24, 2005||International Business Machines Corporation||Fault tolerant mutual exclusion locks for shared memory systems|
|US20060212453 *||Mar 18, 2005||Sep 21, 2006||International Business Machines Corporation||System and method for preserving state for a cluster of data servers in the presence of load-balancing, failover, and fail-back events|
|US20070006270 *||Jun 29, 2005||Jan 4, 2007||Nortel Networks Limited||Timely recovery for media on demand streaming|
|US20070130231 *||Dec 6, 2005||Jun 7, 2007||Brown Douglas P||Closed-loop supportability architecture|
|US20080243850 *||Jun 10, 2008||Oct 2, 2008||Michael Maged M||Fault tolerant mutual exclusion locks for shared memory systems|
|US20090106248 *||Nov 26, 2008||Apr 23, 2009||Vmware, Inc.||Optimistic locking method and system for committing transactions on a file system|
|US20100017409 *||Jan 21, 2010||Vmware, Inc.||Hybrid Locking Using Network and On-Disk Based Schemes|
|US20110055274 *||Mar 3, 2011||Vmware, Inc.||Providing multiple concurrent access to a file system|
|US20110179082 *||Jul 21, 2011||Vmware, Inc.||Managing concurrent file system accesses by multiple servers using locks|
|US20110276690 *||May 5, 2010||Nov 10, 2011||Steven John Whitehouse||Distributed resource contention detection|
|US20120110433 *||Oct 28, 2010||May 3, 2012||Microsoft Corporation||Parallel web page processing|
|US20160041882 *||Aug 7, 2014||Feb 11, 2016||Microsoft Corporation||Safe data access following storage failure|
|U.S. Classification||714/5.11, 707/E17.007, 714/13|
|International Classification||G06F11/00, G06F17/30, G06F11/14|
|Cooperative Classification||G06F17/30362, G06F11/1471|
|Jul 21, 2003||AS||Assignment|
Owner name: ORACLE INTERNATIONAL CORPORATION, CALIFORNIA
Free format text: ASSIGNMENT OF ASSIGNORS INTEREST;ASSIGNOR:SASHIKANTH CHANDRASEKARAN;REEL/FRAME:014324/0681
Effective date: 20030721
|Jun 24, 2008||CC||Certificate of correction|
|Mar 17, 2011||FPAY||Fee payment|
Year of fee payment: 4
|Apr 1, 2015||FPAY||Fee payment|
Year of fee payment: 8