|Publication number||US5613139 A|
|Application number||US 08/241,922|
|Publication date||18 Mar 1997|
|Filing date||11 May 1994|
|Priority date||11 May 1994|
|Also published as||EP0682312A2, EP0682312A3|
|Publication number||08241922, 241922, US 5613139 A, US 5613139A, US-A-5613139, US5613139 A, US5613139A|
|Inventors||James T. Brady|
|Original Assignee||International Business Machines Corporation|
|Export Citation||BiBTeX, EndNote, RefMan|
|Patent Citations (14), Referenced by (74), Classifications (9), Legal Events (5)|
|External Links: USPTO, USPTO Assignment, Espacenet|
This invention relates to resource access control in parallel/distributed computing systems and, more particularly, to a hardware-implemented locking mechanism that is non-software controlled when processing a lock request.
Modern parallel/multi-processing systems employ many processor-containing nodes which simultaneously perform multiple tasks that are either related or independent. Each node communicates with all other nodes via a communication network. Each node includes a processor which operates under control of its own operating system and functions as the overseer of all procedures executed within the node. It is often the case that one or more nodes, in the course of performing their respective procedures, will require access to system resources housed on another node or nodes. To prevent contention between nodes for a shared resource, a locking mechanism is provided to guarantee that competing nodes do not simultaneously attempt to use or modify a same shared resource during performance of different procedures. A locking system enables synchronization of the use of shared resources amongst competing nodes and enables organized functioning of the multi-processor system.
As is known, a lock generally constitutes one or more words in a memory which manifest a state indicating whether a resource associated with that lock is busy or free. When a lock request is received and manifests a value that differs from the value of the lock, it is known that the lock is in use and unavailable to the requestor. If, by contrast, a received lock request matches a stored lock value, then it is known that the associated resource is available and steps are taken to (1) grant ownership of the lock to the requesting party and (2) to change the stored lock value so that another requestor will not be able to access the lock.
To enable the described lock protocol, prior art systems have employed a "Compare and Swap" hardware instruction which enables a requestor's lock value to be compared to the stored lock value and, if equality of values is found, to swap in a new value in place of the stored lock word, while simultaneously granting ownership of the lock to the requestor.
The prior art includes various locking schemes which are employed when memory is shared by two or more processors. For instance, in U.S. Pat. No. 4,965,718 to George et al, a memory contains "semaphore" data which indicates the status of a requested resource. A requestor transmits a "directive" which includes an address of a selected memory location, including a semaphore comparison value, and an identification of the requestor. If the semaphore is found to indicate a busy status (a non-comparison), the directive is stored in the selected memory element where the semaphore data is stored and the state of the semaphore data is thereafter monitored until a change occurs. In this manner, controlled access is achieved for the requested resource.
U.S. Pat. No. 5,175,837 to Arnold et al, is a further shared memory system wherein a central memory stores a directory of lock bits. Each lock bit controls a predefined segment of system memory. When the lock bit is set in an unlock state, access to the protected area of memory is allowed. A fairness procedure processes denied lock requests and sequentially positions them in a first come, first served queue.
U.S. Pat. No. 5,115,499 to Stiffler et al, describes a resource control procedure which employs a memory that indicates a current state of the resource and the identity of the processing element currently utilizing the resource. The memory location can be interrogated by any of the processing elements and thereby performs a lock allocation function.
U.S. Pat. No. 5,060,144 to Sipple et al, describes a shared memory system that includes a special lock processor. The lock processor enables requests for objects stored in a shared memory to be properly allocated amongst contending users.
Other prior art systems have employed a "pass the buck" approach to lock management. In such systems, a table containing the state of all locks is passed among nodes comprising the system. The node that has ownership of the lock table has access to the locks listed therein. Substantial processing overhead is required to transfer the lock table between nodes and, in systems where a large number of nodes are present, a substantial latency period may occur between table ownership periods.
As the number of nodes in multi-processing systems have increased (presently being on the order of thousands), it is preferred that any locking mechanism be distributed amongst the nodes, rather than being dependent upon a central controlling processor. Such a distributed feature enables the locking system to be recovered in the event of failure of a node, as contrasted to a possible complete system failure when a central lock processor fails.
As above indicated, a lock processing system is required to enable nodes in a multi-processing system to operate in a synchronous manner. If however, lock processing is software-controlled in a node, substantial amounts of system time need to be allocated to the lock processing function. As a result, overall system performance is degraded when multiple nodes implement simultaneous lock requests during performance of a system-wide procedure.
Accordingly, it is an object of this invention to provide a parallel/multi-processing system with a distributed lock processing procedure.
It is another object of this invention to provide improved lock processing apparatus for a parallel/multi-processing system wherein nodal processor-involvement is minimized.
It is another object of this invention to provide an improved lock processing mechanism which enables plural lock requests from a single requesting node to be handled on an atomic basis.
It is yet another object of this invention to provide an improved locking mechanism for a parallel/multi-processing system which implements lock processing on a real-time hardware basis rather than a software-controlled basis.
A parallel computing system includes multiple nodes, each node including a processor with software control. The parallel computing system includes a distributed lock mechanism that controls access to system resources, the lock mechanism distributed among the multiple nodes, with each node including hardware-based lock processing apparatus. Such apparatus comprises a communication interface for receiving and transmitting control and data messages and a table arrangement for storing plural lock words. A state machine is present in each node and is connected to the table arrangement and to the communications interface and is responsive to a received lock request to perform hardware-controlled lock processing functions. Those functions include: reading a stored locked word from the table arrangement; comparing the stored lock word with a lock word in the received lock request; compiling a message which grants the lock request if the comparison indicates a match, or a message denying the lock request if the comparison indicates a non-match. The state machine performs the function without invoking the processor and/or its software control, thereby enabling lock grant/denial messages to be handled independently of software controlled processor procedures.
FIG. 1 is a high level block diagram of a parallel/multiprocessor system that includes a distributed lock control mechanism in accordance of the invention hereof.
FIG. 2 is a high level block diagram of a processor node shown in FIG. 1.
FIG. 3 is a chart illustrating contents of a lock request received from a requesting node.
FIG. 3a illustrates a lock message with plural lock requests.
FIG. 4 is a more detailed block diagram of a memory interface module contained in each node which implements the invention hereof.
FIG. 5 is a high level logic flow diagram illustrating the operation of the invention when a "Compare and Swap" lock request is received.
FIG. 6 is a high level logic flow diagram illustrating the operation of the invention when a "Compare and Swap on All Locks of a Set" lock request is received.
FIG. 7 is a high level logic flow diagram illustrating the operation of the invention when a "Compare and Swap on Any Lock of a Set" lock request is received.
FIG. 8 is a high level logic flow diagram illustrating the operation of the invention when a "Compare and Swap with Fetch" lock request is received.
FIG. 9 is a high level logic flow diagram illustrating the operation of the invention when a "Compare and Swap with Store" lock request is received.
FIG. 10 is a high level logic flow diagram illustrating the operation of the invention when a "Compare and Swap with Bit Mask" lock request is received.
Referring to FIG. 1, a plurality of nodes N0-N6 are shown which communicate with each other through a switch matrix 10 which may either be centralized or distributed. Each of nodes N0-N6, etc. include and/or "own" resources which will be called upon by other nodes during execution of distributed procedures. For instance, one node may control access to a disk drive which may be accessed by any other node. Each of nodes N0-N6, etc. includes a hardware-based lock control mechanism which enables appropriate control of access to the aforesaid resources. It is to be understood that the node containing the lock need not contain the resource. A node may be configured as a disk storage node with plural disk storage modules, an electronic storage node with large capacity dynamic or staticRAM modules, an input/output node enabling system communication with other systems, etc.
FIG. 2 illustrates a high level block diagram of a node. Each node includes a processor 12 which operates under software control to perform various procedures within the node. Communications with other nodes is handled via node communication interface 14. Incoming data packets to node communication interface 14 may be of two types, i.e. control packets and data packets. Received data packets are buffered in a buffer interface 16 and their data is stored in data memory 18.
Control packets are fed to a memory interface 20 which decodes control messages contained therein and, in combination with data stored in operand memory 23, enables various control functions to be carried out within the node. A bus 22 carries control outputs from memory interface 20 to various adapter modules 24, 26, etc. which connect to other apparatus within a node (e.g. disk storage, additional random access memory, external I/O interface modules, etc.). Data is fed to adapter modules 24, 26 via buffer interface 16 and bus 28.
Memory interface 20 controls many functions within the node, however, for the purposes of this description, only control of that portion of the locking mechanism resident within the node will be described. To accomplish lock control, memory interface 20 has access to two tables in operand memory 23, i.e. an input port table 30 and a lock table 32. Input port table 30 includes at least one entry for each "logical" input port to the node. Each node is provided with many "logical" input ports, each port capable of having plural locks associated therewith. For instance, the system of FIG. 1 may have tens of thousands of logical input ports, each logical input port having hundreds of thousands of locks associated therewith. As a result, memory interface module 20 may have access to tens of thousands of input port tables 30.
Each input port table includes pointers to lock table 32 wherein lock words associated therewith may be found. The operation of memory interface module 20, input port table 30 and lock table 32 will be better understood from a detailed description of FIG. 4 below which illustrates hardware included within memory interface 20 that implements the lock control procedures.
Before turning to FIG. 4, however, it is useful to describe the message structure employed by the system of FIG. 1 to implement lock requests and lock responses. Lock requests are contained in control messages (i.e. lock messages) that are configured in packet form, each packet including a header with address data, control data and one or more lock requests. Each control message which embodies a lock request includes (see FIG. 3) up to 12 bytes of data, with bytes 0-3 including a lock address of a particular lock word that is sought. A lock address is an offset value from the beginning of a lock table 32. A lock message contains one or more of these lock requests as shown in FIG. 3a.
Each logical input port which is adapted to receive a lock request (a "lock port") contains an associated lock table 32 with lock words stored therein. As a result, a received lock address identifies where in a lock table 32 can be found the desired lock word. Bytes 4-7 of a lock request include a "compare word" and bytes 8-11 include a "swap word". The compare word and swap word enable the system to implement a compare and swap protocol. More specifically, if a received compare word matches a lock word at the lock address designated in the lock request, then a "grant of lock" message is compiled and transmitted to the lock requestor and the lock word is changed to the swap word, thereby preventing any other requestor from gaining access to the resource. When the lock owner is finished with the resource, a lock message is again transmitted which replaces the original swap word with the original compare word, thereby freeing the lock for a subsequent lock request.
In addition to containing a lock request, a lock request control message further contains an input port table address to an entry which contains a pointer 49 (see FIG. 4) to a lock table 32 containing the desired lock word. The input port table address thereby enables the incoming packet to identify where in input port table 30 may be found the address of a desired lock table 32, and by subsequent computation, to locate the desired lock word in lock table 32.
Referring to FIG. 4, the hardware within memory interface 20 that implements lock control will be described. Memory interface 20 contains a state machine 40 which operates the lock control system. State machine 40 includes plural, pre-wired, hardware subsystems which automatically respond to control instructions to carry out a required procedure. State machine 40 requires no software intervention during the handling of a lock request, the compilation of a response to a lock requestor, and the dispatch of a response to node communication interface 14 for transmission to the lock requestor. It is to be further understood that state machine 40 may also include ROM-based firmware that is employed for system control. As the structure of a state machine is well known to those skilled in the art, internal details of state machine 40 will not be described. Suffice to say, that it includes sufficient registers, logic circuitry and interconnecting control lines to implement an automatic lock control operation in response to an incoming lock control message.
State machine 40 connects via a bus 42 to both input port table 30 and a plurality of lock tables 32. There is one lock table 32 for each entry in an input port table which corresponds to an input port used as a lock port. Also connected to state machine 40 is a lock request buffer 43 which enables queuing of lock requests, before processing. As indicated above, input port table 30 has plural entries 44 wherein pointers may be found to lock tables 32 that store associated lock words 46.
It is to be understood that the operation of the circuitry of FIG. 4 proceeds without software intervention and without recourse to processor 12. This action enables lock requests to be handled via a linked series of circuit operations without software intervention and/or control. More specifically, each lock message is handled atomically. In other words, each lock message proceeds to completion without interruption, thereby enabling an immediate response to be constructed and transmitted to a lock requestor without software intervention. The only node which is required to incur software overhead in the handling of a lock messages is the node which desires to acquire or to free a lock. The lock holding node requires no software operation to respond to either a request for a lock or a message to free a lock.
Should a user desire that a node update its software upon responding to a request for a lock or a message to free a lock, an additional entry 50 may be appended to each entry in input port table 30. That entry signals processor 12 to institute an interrupt to processor 12 upon dispatch of a lock message by state machine 40 to node communication interface 14.
Referring now to FIGS. 2, 4 and 5, the operation of the invention will be described assuming a lock message contains a single lock request. Upon receipt of a packet, node communication interface 14 passes the packet to memory interface 20. The header of the packet is examined and the packet is identified as either a data or control packet. Assuming it is a control packet with a lock request, memory interface 20 identifies the addressed logical port and fetches the entry at that address from input port table 30.
Assuming a correct lock word address has been received, the lock word stored at the indicated address is returned to state machine 40. State machine 40 then compares the stored lock word to the received compare word in the lock request, and, if a match is found, compiles a message granting the lock request, which message is transmitted to node communication interface 14 and then to the requesting node. If the compare word does not match the accessed lock word, a message is compiled denying the lock request.
When state machine 40 accesses a lock word 46 from lock table 32, a memory busy flag is set in access control module 41 which denies access to the lock word 46. That denial of access continues until lock word 46 has been compared and found to either match or not match the received compare word. If a match is found, the received swap word is placed into lock table 32 in place of lock word 46. At that time, the memory busy flag is released, thereby enabling further lock messages to be processed. Upon dispatch of a lock response message to the requesting node, and assuming that an interrupt is desired to update processor 12, flag 50 causes an interrupt to be generated and the necessary data transmitted to processor 12.
Each of the lock processing operations takes place atomically within state machine 40 and proceeds to completion without interruption.
The description above has considered a control message including a single lock request, which lock request was atomically processed by state machine 40. Additional modes are supported by the invention which enable plural lock requests to be handled atomically and, further, enable data to be accessed with a lock request, all in an atomically processed manner. Those modes are as follows:
Compare and Swap on All Locks Out of a Set: (FIG. 6)
This mode enables a lock message to carry multiple compare and swap lock requests. If all of the compare words match addressed lock words, the lock requests are executed atomically as a group with the guarantee that no other lock operations can be interleaved with the execution of the requests. If any one of the lock words does not match a compare word, all of the lock requests of the set are not executed, that is, none of the swaps are performed.
Compare and Swap on any Lock Out of the Set (FIG. 7):
In this mode, the lock message carries multiple compare and swap lock requests and one and only one lock request is granted from the set (i.e., the first request that can be satisfied). Other requests in the same message are not executed. The lock address of the executed request is returned by state machine 40 to the requesting node.
Compare and Swap with Fetch (FIG. 8):
This mode combines lock processing and data fetching into a single atomic operation. After a last compare-and-swap lock request in a lock message is executed, plural words immediately following the last lock words from lock table 32 are fetched and returned to the requesting node. In this case a lock word (e.g. lock word 46) is followed by one or more bytes of data which may indicate the identity of the node which has possession of the lock; and/or other status information regarding the lock.
Compare and Swap with Store (FIG. 9):
This mode combines lock processing and data storage into a single atomic operation. N words of data are included in a control message that includes a lock request. If the lock request is executed successfully, the N words are written into lock table 32 in memory locations immediately following the last lock word written thereinto. If the lock request fails, no data is written.
Compare and Swap with Bit Masks (FIG. 10):
To accomplish this function, a lock message contains a pair of additional fields (i.e. a Compare Mask and a Swap Mask) that are added to the compare-and-swap lock request. The Compare Mask is used by state machine 40 to select bits from both the Compare Word and Lock Word for comparison purposes. The Swap Mask is used by state machine 40 to select bits from both the Swap Word and Lock Word for swap operations. In other words, if the Compare Word matches the Lock Word AND Compare Mask, the Lock Word is updated to be the following: (Swap Word) OR (Lock Word AND Swap Mask).
The above described invention enables simple locks to be directly manipulated by sending of hardware messages and requires no software intervention on the node holding the lock table. Where multiple resources need to be acquired together, a group of locks can be acquired by sending a single hardware message, again requiring no software intervention on the node holding the lock table. A group of hardware locks can further form a shared logical lock. The exclusive right to a shared logical lock can be acquired by sending a control message asking for all associated hardware locks in the group. The shared right can be acquired by sending a control message asking for only one hardware lock in the group. The size of the group determines the number of nodes that can actively share the logical locks simultaneously.
A lock is usually used to protect some data. In a conventional system, acquiring the lock and accessing the data are done in separate steps, resulting in multiple messages. With the fetch and store extensions to the compare and swap protocol, a piece of data can be accessed in a guarded way with a single hardware message, again requiring no software intervention by the node holding the data.
A lock requesting node may wish its lock request to be queued if a lock is not available and to be notified when the lock becomes available at some later time. The interrupt procedure is enabled by flags 50 in input port table 30 and allows for implementation of queuing and notification. On the lock-requesting node, receipt of a lock request denial message from the lock holding node may be accompanied by a flag 50 from input port table 30. This flag enables an interrupt to occur at the lock holding node which notifies the software at that node of the lock request failure. A state machine at the lock holding node generates an interrupt to inform its local software/processor. At the same time, it transmits a message back to the lock requesting node. As a result, the lock holding node may queue the lock request while the lock requesting node software is processing the lock request denial. As a result parallel operations are enabled.
It should be understood that the foregoing description is only illustrative of the invention. Various alternatives and modifications can be devised by those skilled in the art without departing from the invention. For instance, while the invention has been described using a compare and swap protocol, other locking protocols are within the scope of the invention, e.g., Fetch and Add; Test and Set; atomic modify; etc. Accordingly, the present invention is intended to embrace all such alternatives, modifications and variances which fall within the scope of the appended claims.
|Cited Patent||Filing date||Publication date||Applicant||Title|
|US4308580 *||7 Sep 1979||29 Dec 1981||Nippon Electric Co., Ltd.||Data multiprocessing system having protection against lockout of shared data|
|US4937733 *||1 May 1987||26 Jun 1990||Digital Equipment Corporation||Method and apparatus for assuring adequate access to system resources by processors in a multiprocessor computer system|
|US4965718 *||29 Sep 1988||23 Oct 1990||International Business Machines Corporation||Data processing system incorporating a memory resident directive for synchronizing multiple tasks among plurality of processing elements by monitoring alternation of semaphore data|
|US5060144 *||16 Mar 1989||22 Oct 1991||Unisys Corporation||Locking control with validity status indication for a multi-host processor system that utilizes a record lock processor and a cache memory for each host processor|
|US5115499 *||2 Jan 1991||19 May 1992||Sequoia Systems, Inc.||Shared computer resource allocation system having apparatus for informing a requesting computer of the identity and busy/idle status of shared resources by command code|
|US5161227 *||13 Nov 1989||3 Nov 1992||International Business Machines Corporation||Multilevel locking system and method|
|US5175837 *||3 Feb 1989||29 Dec 1992||Digital Equipment Corporation||Synchronizing and processing of memory access operations in multiprocessor systems using a directory of lock bits|
|US5237694 *||30 May 1991||17 Aug 1993||Advanced Micro Devices, Inc.||Processing system and method including lock buffer for controlling exclusive critical problem accesses by each processor|
|US5283870 *||4 Oct 1991||1 Feb 1994||Bull Hn Information Systems Inc.||Method and apparatus for avoiding processor deadly embrace in a multiprocessor system|
|US5293491 *||28 Dec 1990||8 Mar 1994||International Business Machines Corp.||Data processing system and memory controller for lock semaphore operations|
|US5321825 *||18 Jun 1991||14 Jun 1994||Advanced Micro Devices, Inc.||Processing system with lock spaces for providing critical section access|
|US5341510 *||22 Oct 1993||23 Aug 1994||Digital Equipment Corporation||Commander node method and apparatus for assuring adequate access to system resources in a multiprocessor|
|US5423044 *||16 Jun 1992||6 Jun 1995||International Business Machines Corporation||Shared, distributed lock manager for loosely coupled processing systems|
|US5442785 *||31 Mar 1994||15 Aug 1995||Unisys Corporation||Method and apparatus for passing messages between application programs on host processors coupled to a record lock processor|
|Citing Patent||Filing date||Publication date||Applicant||Title|
|US5737611 *||5 Apr 1996||7 Apr 1998||Microsoft Corporation||Methods for dynamically escalating locks on a shared resource|
|US5805900 *||26 Sep 1996||8 Sep 1998||International Business Machines Corporation||Method and apparatus for serializing resource access requests in a multisystem complex|
|US5841631 *||14 Jun 1996||24 Nov 1998||Texas Instruments Incorporated||Latch block control for media bay module|
|US6041385 *||14 Oct 1998||21 Mar 2000||Intel Corporation||Method and apparatus for protecting data using lock values in a computer system|
|US6088757 *||28 Aug 1998||11 Jul 2000||International Business Machines Corporation||Computer program means and device for conducting high performance locking facility in a loosely coupled environment|
|US6105085 *||26 Dec 1997||15 Aug 2000||Emc Corporation||Lock mechanism for shared resources having associated data structure stored in common memory include a lock portion and a reserve portion|
|US6105099 *||30 Nov 1998||15 Aug 2000||International Business Machines Corporation||Method for synchronizing use of dual and solo locking for two competing processors responsive to membership changes|
|US6185650||28 Aug 1998||6 Feb 2001||International Business Machines Corporation||High performance locking facility|
|US6189007||28 Aug 1998||13 Feb 2001||International Business Machines Corporation||Method and apparatus for conducting a high performance locking facility in a loosely coupled environment|
|US6223335 *||9 Dec 1998||24 Apr 2001||Sun Microsystems, Inc.||Platform independent double compare and swap operation|
|US6253274 *||28 Aug 1998||26 Jun 2001||International Business Machines Corporation||Apparatus for a high performance locking facility|
|US6343338 *||1 Apr 1997||29 Jan 2002||Microsoft Corporation||System and method for synchronizing disparate processing modes and for controlling access to shared resources|
|US6523078 *||23 Nov 1999||18 Feb 2003||Steeleye Technology, Inc.||Distributed locking system and method for a clustered system having a distributed system for storing cluster configuration information|
|US6662252 *||8 Dec 2002||9 Dec 2003||Cisco Technology, Inc.||Group and virtual locking mechanism for inter processor synchronization|
|US6832268 *||19 Dec 2002||14 Dec 2004||Intel Corporation||Mechanism to guarantee forward progress for incoming coherent input/output (I/O) transactions for caching I/O agent on address conflict with processor transactions|
|US6981108 *||23 Oct 2001||27 Dec 2005||P-Cube Ltd.||Method for locking shared resources connected by a PCI bus|
|US7062583 *||15 Jan 2003||13 Jun 2006||Nokia Corporation||Hardware semaphore intended for a multi-processor system|
|US7089555||25 Jun 2002||8 Aug 2006||International Business Machines Corporation||Ordered semaphore management subsystem|
|US7127587 *||11 Dec 2003||24 Oct 2006||International Business Machines Corporation||Intent seizes in a multi-processor environment|
|US7143414||19 Sep 2002||28 Nov 2006||International Business Machines Corporation||Method and apparatus for locking multiple semaphores|
|US7155551 *||2 May 2006||26 Dec 2006||Nokia Corporation||Hardware semaphore intended for a multi-processor system|
|US7290105 *||16 Dec 2002||30 Oct 2007||Cisco Technology, Inc.||Zero overhead resource locks with attributes|
|US7386643||21 Oct 2004||10 Jun 2008||Tan Sin S||Mechanism to guarantee forward progress for incoming coherent input/output (I/O) transactions for caching I/O agent on address conflict with processor transactions|
|US7406690||19 Sep 2002||29 Jul 2008||International Business Machines Corporation||Flow lookahead in an ordered semaphore management subsystem|
|US7454753||25 Jun 2002||18 Nov 2008||International Business Machines Corporation||Semaphore management subsystem for use with multi-thread processor systems|
|US7606985 *||23 Aug 2006||20 Oct 2009||Advanced Micro Devices, Inc.||Augmented instruction set for proactive synchronization within a computer system|
|US7660927 *||21 May 2007||9 Feb 2010||International Business Machines Corporation||Apparatus and method to control access to stored information|
|US7750923||5 Apr 2007||6 Jul 2010||Microsoft Corporation||Implementing limited function mode in a display device|
|US7844585||17 Aug 2007||30 Nov 2010||International Business Machines Corporation||Method, system, and program for managing locks and transactions|
|US7856521||28 Dec 2009||21 Dec 2010||International Business Machines Corporation||Apparatus and method to control access to stored information|
|US7870111||13 Jul 2007||11 Jan 2011||International Business Machines Corporation||Method, system, and program for lock and transaction management|
|US7917908||12 Jun 2008||29 Mar 2011||International Business Machines Corporation||Flow lookahead in an ordered semaphore management subsystem|
|US8161018||26 Jun 2008||17 Apr 2012||International Business Machines Corporation||Managing locks and transactions|
|US8190780||30 Dec 2003||29 May 2012||Sap Ag||Cluster architecture having a star topology with centralized services|
|US8200643||6 Dec 2010||12 Jun 2012||International Business Machines Corporation||Lock and transaction management|
|US8468169||1 Dec 2010||18 Jun 2013||Microsoft Corporation||Hierarchical software locking|
|US8495131||8 Oct 2002||23 Jul 2013||International Business Machines Corporation||Method, system, and program for managing locks enabling access to a shared resource|
|US8589867||18 Jun 2010||19 Nov 2013||Microsoft Corporation||Compiler-generated invocation stubs for data parallel programming model|
|US8726279 *||6 May 2006||13 May 2014||Nvidia Corporation||System for multi threaded multi processor sharing of asynchronous hardware units|
|US8768905||12 Mar 2012||1 Jul 2014||International Business Machines Corporation||Managing locks and transactions|
|US8984653||3 Apr 2008||17 Mar 2015||Microsoft Technology Licensing, Llc||Client controlled lock for electronic devices|
|US9250976 *||14 Mar 2013||2 Feb 2016||International Business Machines Corporation||Tiered locking of resources|
|US9250977 *||15 Mar 2013||2 Feb 2016||International Business Machines Corporation||Tiered locking of resources|
|US9767135 *||13 Sep 2007||19 Sep 2017||International Business Machines Corporation||Data processing system and method of handling requests|
|US20030002440 *||25 Jun 2002||2 Jan 2003||International Business Machines Corporation||Ordered semaphore management subsystem|
|US20030005195 *||25 Jun 2002||2 Jan 2003||International Business Machines Corporation||Semaphore management subsystem for use with multi-thread processor systems|
|US20030060898 *||19 Sep 2002||27 Mar 2003||International Business Machines Corporation||Flow lookahead in an ordered semaphore management subsystem|
|US20030061259 *||19 Sep 2002||27 Mar 2003||International Business Machines Corporation||Method and apparatus for locking multiple semaphores|
|US20030149820 *||15 Jan 2003||7 Aug 2003||Nokia Corporation||Hardware semaphore intended for a multi-processor system|
|US20040068563 *||8 Oct 2002||8 Apr 2004||International Business Machines Corporation||Method, system, and program for managing locks enabling access to a shared resource|
|US20040107240 *||2 Dec 2002||3 Jun 2004||Globespan Virata Incorporated||Method and system for intertask messaging between multiple processors|
|US20040122995 *||19 Dec 2002||24 Jun 2004||Intel Corporation||Mechanism to guarantee forward progress for incoming coherent input/output (I/O) transactions for caching I/O agent on address conflict with processor transactions|
|US20050060502 *||21 Oct 2004||17 Mar 2005||Tan Sin S.|
|US20050132143 *||11 Dec 2003||16 Jun 2005||International Business Machines Corporation||Intent seizes in a multi-processor environment|
|US20050155011 *||12 Jan 2004||14 Jul 2005||Stephan Heik||Method and system for restricting access in a distributed job environment|
|US20050188021 *||30 Dec 2003||25 Aug 2005||Hans-Christoph Rohland||Cluster architecture having a star topology with centralized services|
|US20060200609 *||2 May 2006||7 Sep 2006||Pasi Kolinummi||Hardware semaphore intended for a multi-processor system|
|US20070050560 *||23 Aug 2006||1 Mar 2007||Advanced Micro Devices, Inc.||Augmented instruction set for proactive synchronization within a computer system|
|US20070168507 *||15 Nov 2005||19 Jul 2007||Microsoft Corporation||Resource arbitration via persistent reservation|
|US20070261053 *||6 May 2006||8 Nov 2007||Portal Player, Inc.||System for multi threaded multi processor sharing of asynchronous hardware units|
|US20070282839 *||13 Jul 2007||6 Dec 2007||International Business Machines Corporation||Method, system, and program for lock and transaction management|
|US20070282966 *||17 Aug 2007||6 Dec 2007||International Business Machines Corporation||Method, system, and program for managing locks and transactions|
|US20080244130 *||12 Jun 2008||2 Oct 2008||International Business Machines Corporation||Flow lookahead in an ordered semaphore management subsystem|
|US20080246774 *||5 Apr 2007||9 Oct 2008||Microsoft Corporation||Implementing Limited Function Mode in a Display Device|
|US20080263549 *||26 Jun 2008||23 Oct 2008||International Business Machines Corporation||Managing locks and transactions|
|US20080294826 *||21 May 2007||27 Nov 2008||International Business Machines Corporation||Apparatus and method to control access to stored information|
|US20090254995 *||3 Apr 2008||8 Oct 2009||Microsoft Corporation||Client controlled lock for electronic devices|
|US20090300018 *||13 Sep 2007||3 Dec 2009||International Business Machines Corporation||Data processing system and method of handling requests|
|US20100106877 *||28 Dec 2009||29 Apr 2010||International Business Machines Corporation||Apparatus and method to control access to stored information|
|US20110078126 *||6 Dec 2010||31 Mar 2011||International Business Machines Corporation||Method, system, and program for lock and transaction management|
|US20110314256 *||18 Jun 2010||22 Dec 2011||Microsoft Corporation||Data Parallel Programming Model|
|US20140115213 *||14 Mar 2013||24 Apr 2014||International Business Machines Corporation||Tiered locking of resources|
|US20140115215 *||15 Mar 2013||24 Apr 2014||International Business Machines Corporation||Tiered locking of resources|
|US20140207881 *||26 Jan 2012||24 Jul 2014||Ruprecht-Karls-Universitat Heidelberg||Circuit arrangement for connection interface|
|U.S. Classification||710/200, 710/36, 710/18|
|International Classification||G06F9/46, G06F15/16, G06F9/52, G06F15/177|
|11 May 1994||AS||Assignment|
Owner name: INTERNATIONAL BUSINESS MACHINES CORPORATION, NEW Y
Free format text: ASSIGNMENT OF ASSIGNORS INTEREST;ASSIGNOR:BRADY, JAMES T.;REEL/FRAME:007001/0654
Effective date: 19940510
|28 Jun 2000||FPAY||Fee payment|
Year of fee payment: 4
|7 Oct 2004||REMI||Maintenance fee reminder mailed|
|18 Mar 2005||LAPS||Lapse for failure to pay maintenance fees|
|17 May 2005||FP||Expired due to failure to pay maintenance fee|
Effective date: 20050318