System for achieving atomic non-sequential multi-word operations in shared memory
BACKGROUND AND SUMMARY OF THE INVENTION 
     This invention relates to operation of computer systems having shared memory, and more particularly to a transactional memory for use in multiprocessor systems. 
     Synchronizing access to shared data structures is one of the oldest and most difficult problems in designing software for shared-memory multiprocessors. Without careful synchronization, a data structure may be left in an inconsistent state if different processes try to modify it at the same time. Conventional techniques for synchronizing access to shared data structures in shared-memory multiprocessors center around mutual exclusion protocols. Each data structure has an associated lock. Before a process can access a data structure, it must acquire the lock, and as long it holds that lock, no other process may access the data structure. 
     Nevertheless, locking is poorly suited for modern shared-memory multiprocessor architectures, for several reasons. First, locking is poorly suited for processes that must modify multiple data objects, particularly if the set of objects to be modified is not known in advance. Care must be taken to avoid deadlocks that arise when processes attempt to acquire the same locks in different orders. Second, if the process holding a lock is descheduled, perhaps by exhausting its scheduling quantum, by a page fault, or by some other kind of interrupt, then other processes capable of running may be unable to progress. Third, locking interacts poorly with priority systems. A lower-priority process may be preempted in favor of a higher-priority process, but if the preempted process is holding a lock, then other, perhaps higher priority processes will be unable to progress (this phenomenon is sometimes called &#34;priority inversion&#34;). And fourth, locking can produce &#34;hot-spot&#34; contention. In particular, spin locking techniques, in which processes repeatedly poll a lock until it becomes free, perform poorly because of excessive memory contention. 
     By contrast, a concurrent object implementation is non-blocking if some process is guaranteed to complete an operation after the system as a whole takes a finite number of steps (referred to as atomicity, as will be described). This condition rules out the use of locking, since a process that halts while holding a lock may force other processes trying to acquire that lock to run forever without making progress. 
     Described herein is a new multiprocessor architecture that permits programmers to construct non-blocking implementations of complex data structures in a simple and efficient way. This architecture is referred to as transactional memory, and consists of two parts: (1) a collection of special machine instructions, and (2) particular techniques for implementing these instructions. 
     Most of the programming language constructs proposed for concurrent programming in the multiprocessor with shared memory model employ locks, either explicitly or implicitly (Andrews et al, &#34;Concepts and notations for concurrent programming,&#34; ACM Computing Surveys, Vol. 15, No. 1, pp. 3-43, March 1983, disclose a survey). Early-locking algorithms used only load and store operations, as disclosed in Dijkstra, &#34;Co-operating sequential processes,&#34; pp. 43-112, Academic Press, New York, 1965, in Knuth, &#34;Additional comments on a problem in concurrent programming control,&#34; Communications of the ACM, Vol. 9, No. 5, pp. 321-322, May 1966, in Peterson, &#34;Myths about the mutual exclusion problem,&#34; Information Processing Letters, Vol. 12, pp. 115-116, June 1981, and in Lamport, &#34;A new solution of Dijkstra&#39;s concurrent programming problem,&#34; Communications of the ACM, Vol. 18, No. 8, pp. 453-455, August 1974. 
     These algorithms using only load and store operations, however, are cumbersome and inefficient, so current practice is to provide support for read-modify-write (RMW) operations directly in hardware. A read-modify-write operation is parameterized by a function f. It atomically (1) reads the value v from a location, (2) computes f(v) and stores it in that location, and (3) returns v to the caller. Common read-modify-write operations include TEST&amp;SET, atomic register-to-memory SWAP (see Graunke et al, &#34;Synchronization algorithms for shared memory multiprocessors,&#34; IEEE Computer, Vol. 23, No. 6, pp. 60-70, June 1990), FETCH&amp;ADD (see Gottlieb et al, &#34;The NYU Ultracomputer--designing an MIMD parallel computer,&#34; IEEE Trans. on Computers, Vol. C-32, No. 2, pp. 175-189, February 1984), COMPARE&amp;SWAP (see IBM, &#34;System/370 principles of operation,&#34; Order No. GA22-7000), and LOAD -  LINKED and STORE -  CONDITIONAL (see Jensen et al, &#34;A new approach to exclusive data access in shared memory multiprocessors,&#34; Technical Report UCRL-97663, Lawrence Livermore National Laboratory, November  1987). 
     Although these hardware primitives were originally developed to support locking, they can sometimes be used to avoid locking for certain data structures. A systematic analysis of the relative power of different read-modify-write primitives for this purpose is given in Herlihy, &#34;Wait-free synchronization,&#34; ACM Trans. on Programming Languages and Systems, Vol 13, No. 1, pp. 123-149, January 1991. If an architecture provides only read and write operations, then it is provably impossible to construct non-blocking implementations of many simple and familiar data types, such as stacks, queues, lists, etc. Moreover, many of the &#34;classical&#34; synchronization primitives such as TEST&amp;SET, SWAP, and FETCH&amp;ADD are also computationally weak. Nevertheless, there do exist simply universal primitives from which one can construct a non-blocking implementation of any object. Examples of universal primitives include COMPARE&amp;SWAP, LOAD -  LINED and STORE -  CONDITIONAL, and others. 
     Although the universal primitives are powerful enough in theory to support non-blocking implementations of any concurrent data structure, they may perform poorly in practice because they can update only one word of memory at a time. To modify a complex data structure, it is necessary to copy the object, modify the copy, and then to use a read-modify-write operation to swing a base pointer from the old version to the new version. Detailed protocols of this kind for COMPARE&amp;SWAP and for LOAD -  LINED and STORE -  CONDITIONAL have been published (see Herlihy, &#34;A methodology for implementing highly concurrent data structures,&#34; Proc. 2nd ACM SIGPLAN Symp. on Princ. and Practice of Parallel Programming, pp. 197-206, March 1990, and Herlihy, &#34;A methodology for implementing highly concurrent data objects,&#34; Tech. Rpt. No. 91/10, Digital Equipment Corporation, Cambridge Research Laboratory, Cambridge, Mass. 02139, October 1991). One exception to the single-word limitation is the Motorola 68030 architecture, which provides a two-word COMPARE&amp;SWAP instruction. Masselin and Pu exploit this primitive to construct an operating system kernel that employs a number of non-blocking data structures. 
     In copending application Ser. No. 547,618, filed Jun. 29, 1990, by Sites and Witek, for &#34;Ensuring Data Integrity in Multiprocessor or Pipelined Processor,&#34; assigned to Digital Equipment Corporation, a processor of a 64-bit RISC architecture is disclosed. Atomic byte writes are implemented by providing load/locked and store/conditional instructions. To write to a byte address in a quadword aligned memory location, the processor loads a quadword, performs an internal byte write in the processor&#39;s register set, then conditionally stores the updated quadword in memory, depending upon whether the quadword has been written by another processor since the load/locked operation. As with the conditional stores discussed above, this operation is limited to a fixed-size memory reference, and does not provide the full range of functions needed for the transactional memory of the present invention. 
     Transactional memory according to this invention improves on these primitives by effectively providing the ability to implement customized read-modify-write operations that affect arbitrary regions of memory. This ability avoids the need for copying imposed by the single-word primitives, since complex atomic updates can now be applied in place. Moreover, since the number of locations affected by a transaction is limited only by processor cache size, transactional memory is strictly more flexible than two-word COMPARE&amp;SWAP. 
     A second feature of transactional memory is its close integration with cache consistency protocols. There are several ways read-modify-write instructions may interact with the cache. Perhaps the simplest is to bypass the cache entirely, locking the bus for several cycles while making updates directly to memory. (Some of these protocols invalidate any cached copies of that location, while some do not.) As described in the survey article by Glew and Hwu, &#34;A feature taxonomy and survey of synchronization primitive implementations,&#34; Technical Report CRHC-91-7, Univ. of Illinois at Urbana-Champagne, 1101 W. Springfield, Urbana, Ill. 61801, December 1990, this approach is taken by the BBN TC2000, by the early version of the EncOre Multimax, by the Motorola MC68030, by Pyramid, by the VAX 6200, and others. Locking the bus is clearly unsuitable for transactional memory. 
     A more sophisticated approach is to cache an exclusive copy of a memory location and to prevent other processors from acquiring that value while the read-modify-write is in progress. This technique is used by the Berkeley Protocol (see Katz et al, &#34;Implementing a cache consistency protocol,&#34; Proc. 12th Annual Int&#39;l Symp. on Computer Architecture, pp. 276-286, IEEE, June 1985), by the Sequent Symmetry (see Graunke et al, cited above), by the later version of the Encore MultiMax, and by the SPUR processor (the last two as described in Clew and Hsu, cited above). This technique is essentially equivalent to locking. It works well for predefined read-modify-write instructions, where the duration of locking is fixed in advance, but it is not suitable for transactional memory, where there may be an arbitrarily long interval between reading a location and modifying it. 
     The S1 project (see Jensen et al, cited above) uses a kind of cache invalidation scheme to implement LOAD -  LINKED and STORE -  CONDITIONAL synchronization primitives. When a process executes a LOAD -  LINKED, it effectively caches the variable in exclusive mode. The STORE -  CONDITIONAL will succeed only if that entry has not been invalidated. The transactional memory implementation, according to the invention, in contrast, is applied to multiple memory locations, and to a large class of cache consistency protocols. 
     The notion of a transaction, in the sense of a sequence of operations executed atomically with respect to other transactions, has been used in database technology. Many techniques have been proposed for synchronizing transactions. Although the properties provided by transactional memory have some similarity to the properties provided by database transactions, there are important differences. Most mechanisms for synchronizing database transactions are based on some form of locking (e.g., as described by Eswaran et al, &#34;The notion of consistency and predicate locks in a database system,&#34; Communications of the ACM, Vol. 19, No. 11, pp. 624-633, November 1976, by Moss, &#34;Nested transactions: An approach to reliable distributed computing, &#34; Technical Report MIT/LCS/TR-260, M.I.T. Laboratory for Computer Science, April 1981, and by Reed, Implementing atomic actions on decentralized data,&#34; ACM Trans. on Computer Systems, Vol. 1, No. 1, pp. 2-23, February 1983). The database mechanisms that most closely resemble transactional memory are optimistic techniques (as described by Kung et al, &#34;On optimistic methods for concurrency control,&#34; ACM Trans. on database Systems, Vol. 2, No. 6, pp. 213-226, June 1981) in which transactions execute without synchronization, but each transaction must be validated before it is allowed to commit. The techniques for validating transactions are entirely different in a transactional memory, however. The database techniques rely on software validation, while in a transactional memory validation is integrated with the multiprocessor&#39;s cache consistency protocol. 
    
    
     BRIEF DESCRIPTION OF THE DRAWINGS 
     The novel features believed characteristic of the invention are set forth in the appended claims. The invention itself, however, as well as other features and advantages thereof, will be best understood by reference to the detailed description of a specific embodiment, when read in conjunction with the accompanying drawings, wherein: 
     FIG. 1 is an electrical diagram in block form of a computer system which may employ transactional memory according to one embodiment of the invention; and 
     FIG. 2 is a table of transactional instructions used in a computer system such as that of FIG. 1; 
     FIG. 3 is a program listing in C for implementing a FIFO using transactional memory and transactional instructions of FIG. 2. 
    
    
     DESCRIPTION OF PREFERRED EMBODIMENTS 
     Referring to FIG. 1, a computer system employing transactional memory is illustrated according to one example embodiment. A CPU 10 is coupled by a system bus 11 to main memory 12, and other CPUs 13 as well as system resources such as disk storage, etc., are also accessing the main memory 12 via the system bus. The problem arising in a multiprocessor system such as this, with shared memory, is that the CPU 10 can start a transaction involving a location A in main memory, then one of the other CPUs 13 may write to the location A before CPU 10 has completed its transaction. For example, the CPU 10 may wish to add a number B to the contents of location A (e.g., A may be a counter maintaining an account balance). To accomplish this transaction, CPU 10 first reads the value at location A into an internal register C, then adds the value B to register C, then writes the contents of C to the location A in memory 12. The problem is, another CPU 13 may be doing the same type of transaction at about the same time, and writes to location A after CPU 10 has read location A but before CPU 10 has rewritten its completed result to A. In such case, the data at A is corrupted. Both CPUs have attempted to modify A, but the modification made by CPU 13 is overwritten by the later write by CPU 10. 
     To avoid the multiprocessor problem, &#39;the memory of the system of FIG. 1 can be constructed to operate in a transactional manner, according to one embodiment. The transactional memory has a number of elements in common with a conventional system using a cache, which will first be described as background. The system has a cache 15, including a cache memory 16 operated by a cache controller 17, in the usual manner. The cache 15 may be a secondary cache, with an on-chip primary cache being included in a single-chip processor device used as the CPU 10, in a typical construction. Data is stored in the cache memory 16 in a number of cache lines 18, where each line may be 128-bits, or 256-bits, etc., depending upon the architecture and partitioning of the system. The cache controller 17 includes a tag memory 19 storing a tag for each cache line 18, and, in the usual manner, the address of a read or write request by the CPU 10 is compared with the tag memory 19 to see if the request can be satisfied in the cache; if not the request is forwarded to main memory 12. When the CPU 10 writes to a location in a cache line 18 in cache 15, then the corresponding location in main memory 12 is no longer consistent, so a write-back or write through scheme must be implemented. Assuming that this is a write-back cache, each cache line 18 will have a &#34;dirty&#34; bit 20, which is set by the cache controller when the CPU 10 writes to a location in the line. Each line 18 also has a &#34;valid&#34; bit 21, indicating whether or not this line is valid. A so-called &#34;snoop bus&#34; 22 monitors the system bus 11 and compares the address used on any write transaction emanating from one of the other CPUs 13 to alter the memory 12. Whenever this address matches a tag in the tag memory 19, the valid bit 21 for this line is reset, indicating this line is no longer valid. Whenever the address of a read request on bus 11 monitored by the snoop bus 22 matches a tag in tag memory 19 for which the dirty bit 20 is set, this indicates that the location in main memory is not up to date and so the read is prevented from taking place until this dirty (written by CPU 10) line in cache is written back to memory 12. A write back is executed whenever some other CPU needs the data at the location, or whenever the line is moved out of the cache 15. The snoop bus 22 and snoop circuit 23 in the cache controller 17 is thus able to detect reads or writes to locations in memory 12 by monitoring the addresses and read/write control signals on the bus 11; this ability is used in implementing the transactional memory. 
     In addition to the cache operation with invalidate and dirty bits for each cache line, and the snoop operation, other functions are added to the cache 15 to facilitate transactional operation. A transaction bit 25 is stored for each cache line 18, and this transaction bit is set whenever data in this line is involved in a transaction operation. When the transaction is completed, successfully or not, the transaction bit is reset. Another element added is a transaction status bit 26 in the cache controller, which indicates whether a currently-executing transaction is healthy or not. This bit 26 is set when a transaction is started, and remains set unless something happens that indicates that the transaction cannot successfully complete, e.g., another CPU reads from or writes to the location in memory 12 involved in the transaction. Thus, the status bit 26 is operated by an output from the snoop circuit 23; the status bit 26 is reset, indicating a failed transaction, whenever the following kinds of address match are detected: (1) a bus read from snoop bus 22 matches a tag in the tag memory 19, and the transaction bit 25 and dirty bit 20 are both set, or (2) the bus write from snoop bus 22 matches a tag and the transaction bit 25 is set. The CPU 10 can query this status bit 26, as by a read to a register location in the cache controller, to determine the status of a pending transaction. 
     Accordingly, using the system of FIG. 1, the example transaction mentioned above would proceed as follows, using this example embodiment of a transaction memory. First, the CPU 10 reads the location A and stores it in an internal register and thus in the cache memory 16 as a line 18 (or multiple lines). At the same time, the line 18 is marked as a transaction by setting the bit 25. As usual, the line is marked valid by setting the valid bit 21. Also, the status bit 26 is set. A transaction is thus initiated. Then, the CPU 10 does whatever activity is needed involving the data in this cache line, such as adding an amount B to a counter value defined in the location A which is now in the register and selected cache line 18. When the counter value is changed, the cache line&#39;s dirty bit is set. During this activity by CPU 10, the snoop bus is monitoring the bus 11 to see if another CPU either reads or writes the location A. If another CPU reads the location A, this will mean it will be getting data that is stale, since a transaction has already begun that would eventually change this data, even though the change may not yet have been made. Of course, if a write is done to location A, this indicates that the transaction cannot be properly completed. So, in either case the status bit 26 is reset, indicating the transaction is fatally defective. When the CPU 10 has finished its alteration of the location A data in its internal register set, it writes the result to cache 15, and is ready to end the transaction; the CPU first checks the status bit 26 (i.e., a &#34;commit&#34; operation as described below). If it finds the status bit 26 reset, the transaction is scrubbed, and begins again. That is, the CPU 10 will again read the value at location A into its cache 15, set the status bit 26 and transaction bit 25, and do the updating of the counter value as before. Whenever it completes its activity on the value from location A and finds the status bit 26 still set, the CPU makes the transaction visible to the other users of the memory 12 by clearing the transaction bit 25 and allowing a write back from cache 15 to memory 12 if another CPU 13 sends a read or write request for location A onto the bus 11. 
     A feature of the transactional memory operations described below is allowing a transaction to involve a memory area of some arbitrary size (no larger than the cache, however), rather than being limited to a word or the like. The size is referred to as the &#34;read set or &#34;write set,&#34; and these are recorded implicitly in the cache. A line is in the read set if the transactional bit 25 is set but the dirty bit 20 is not set, and is in the write set if both the transactional and dirty bits are set. The read set may be made up of non-contiguous areas of memory, as may the write set. A read set 28 is thus defined to be whatever cache lines currently meet the conditions of &#34;bit 25 set, bit 20 not set,&#34; and the write set 29 is whatever cache lines have bits 20 and 25 both set. 
     Another element of hardware that may be helpful is a status bit 30 indicating whether or not a transaction completed. If the CPU 10 tries to commit a transaction as will be described, the bit 30 is set if it is successful, or reset if failure. Thus, the CPU 10 can check the bit 30 to see if the transaction completed so it can determine whether or not to repeat the transaction. Alternatively, of course, a &#34;completed&#34; signal may be sent to the CPU 10 from the cache controller 17, without the CPU making inquiry. 
     With this overview of a simplified example, transactional memory will be described in more generic terms. 
     A transaction is a finite sequence of machine instructions executed by a single process, satisfying the properties of serializability and atomicity. Serializability means that each transaction appears to take place instantaneously, in the sense that the steps of one transaction never appear to be interleaved with the steps of another. Atomicity means that each transaction makes a sequence of tentative changes to shared memory; when the transaction completes, it either commits, instantaneously making its changes visible to other processes, or it aborts causing its changes to be discarded. 
     In the example of FIG. 1, a transaction must be serializable so that once a transaction by the CPU 10 starts (e.g., adding to the value of the counter at location A), another operation involving the location A by another CPU 13 must not start or be active. Thus, each transaction appears to take place instantaneously, because if there is any overlap the transaction will be aborted. Also, a transaction has atomicity in that it doesn&#39;t reach a half-way condition; it either does the entire operation, or it does none of it (aborts). 
     In the transactional memory, transactions satisfy the same serializability and atomicity properties as in database technology, but are implemented using entirely different techniques, and their intended applications are entirely different. Unlike database transactions, in a transactional memory transactions are intended to be short-lived activities that access a relatively small number of memory locations. The ideal size and duration of transactions is implementation-dependent, but, roughly speaking, a transaction should be able to run to completion within a single scheduling quantum, and the set of variables it accesses should be small enough to fit in the processor&#39;s cache. 
     Transactional memory provides six primitive instructions as described in the following paragraphs: 
     (1) Load-transactional (LT) reads the value of a shared memory location into a private register (e.g., register C and cache 15). The set of locations read by LT is called the transactions&#39;s read set (e.g., set 28 of FIG. 1). 
     (2) Store-transactional (ST) tentatively writes the value in a private register (e.g., register C and cache 15) to a shared memory location (main memory 12). This new value in cache 15 does not become visible to other processors 13 until the transaction successfully commits (see below). The set of locations tentatively updated by ST is called the transaction&#39;s write set (e.g., set 29 of FIG. 1). 
     (3) Load-transactional-exclusive (LTX) reads the value of a shared memory location into a private register (e.g., register C and cache 15). Although this operation does not modify memory 12, the location read is considered part of the transaction&#39;s write set 29. LTX is more efficient than LT for reading locations that are likely to be modified. 
     (4) Commit (COMMIT) attempts to make the transactions&#39;s tentative changes permanent (e.g., write back is permitted to memory 12). It succeeds only if no other transaction has updated any location in the transaction&#39;s read or write set, and no other transaction has read any location in this transaction&#39;s write set (i.e., status bit 26 still set). If it succeeds, the transaction&#39;s changes to its write set become visible to other processes (transaction bit 25 is cleared and write-back permitted). If it fails, all changes to the write set are discarded. Either way, COMMIT returns an indication of success or failure (the status bit 30 or a signal). 
     (5) Abort (ABORT) discards all updates to the write set (e.g., invalidates the cache line holding location A data by resetting the valid bit 21 and clearing the transaction bit 25). 
     (6) Validate (VALIDATE) tests the current transaction status (status bit 26). A successful VALIDATE returns True, indicating that the current transaction may proceed. An unsuccessful VALIDATE returns False, indicating that the current transaction has aborted, and it discards the transaction&#39;s tentative updates (invalidates all cache lines with transactional bit 25 set). 
     These transactional instructions are summarized in FIG. 2. Here, LOAD and STORE are usually part of any processor&#39;s instruction set. The register r of FIG. 2 is in the CPU&#39;s internal register set in the FIG. 1 embodiment. These instructions may be implemented in any of several ways in a given platform (combination of CPU and operating system). First, the instructions of FIG. 2 may be part of an instruction set of a computer architecture. Second, the instructions may be macro instructions built up from the processor&#39;s native instruction set and reached by a trap or a so-called PALcode function, as set forth in said application Ser. No. 547,618, in which case the code to implement the transactional instructions is stored in firmware on the processor board, for example. Third, the transactional instructions may be implemented by the operating system, in which case the status bits 25, 26 and 30 may not actually be hardware but instead merely memory locations referenced by the software. Fourth, the transactional instructions might be implemented in an applications program, where again the status bits may be software defined. Of course, higher performance is obtained by implementing the transactional instructions using hardware for the status bits. Software implementations are more likely based on the directory model described below, rather than on the write-back cache with snoop bus model, because of the difficulty in simulating the invalidate-type functions without hardware support. 
     By combining these primitives of FIG. 2, the programmer has the ability to define customized read-modify-write operations that operate on arbitrary regions of memory, not just single words. Non-transactional instructions are also supported, such as LOAD and STORE, which do not affect a transaction&#39;s read and write sets. 
     Transactional memory implemented as in FIGS. 1 and 2 guarantees that (1) if a transaction by the CPU 10 aborts, then none of the values it wrote with ST instructions will be visible to other processors 13, and (2) if it commits, then its sequence of LT and ST instructions will not appear to be interleaved with any other committed transaction&#39;s sequence. The first property guarantees atomicity, and the second serializability. As described in more detail below, this property is implemented by aborting an active transaction if: 
     (1) any process applies a STORE to any location in its read or write sets 28 and 29, 
     (2) any process applies a LOAD to any location in its write set 29, 
     (3) another active transaction applies a ST to any location in its read or write sets 28 and 29, or 
     (4) another active transaction applies a LT to any location in its write set 29. 
     A transaction may also occasionally be aborted for implementation-specific reasons as described below. 
     The VALIDATE instruction is motivated by considerations of software engineering. A set of values in memory is inconsistent if it could not have been produced by any serial execution of transactions. An orphan is a transaction that continues to execute after it has been aborted (i.e., after another transaction has updated its read set). Under certain circumstances, it is impractical to guarantee that every orphan will observe a consistent read set. Although any such transaction will never commit, it may be difficult to ensure that a long or complex transaction, when confronted with unexpected input, does not store into out-of-range locations, divide by zero, or perform some other illegal action. The VALIDATE instruction addresses this problem by allowing programmers to ensure that values read are consistent before using them. A transaction is defined to be well-formed if it executes a VALIDATE instruction before computing with any value read by LT. A well-formed transaction will never observe an inconsistent read set, even if it becomes an orphan. For example, a simple well-formed transaction might: 
     (1) use a sequence of LT instructions to load its read set 28, 
     (2) use VALIDATE to ensure that the read set 28 is consistent, 
     (3) in the course of a computation, issue a sequence of ST instructions to update its write set 29, and 
     (4) call COMMIT to make these updates permanent. 
     A more complex transaction, such as one that chains down a linked list, might have to alternate LT and VALIDATE instructions. In the example implementation, the VALIDATE instruction is local--it does not generate any processor-to-processor or processor-to-memory traffic, but instead merely checks the status bit 26. 
     An exemplary embodiment of the invention, as shown in the attached Appendix A may be used to implement a concurrent FIFO queue using the transactional memory and instructions of FIG. 2. The Appendix A includes a listing of C-language programming lines, shown in order of execution. The Appendix A is hereby incorporated by reference in its entirety. The queue is a structure with three fields: enqs and deqs count the number of enqueues and dequeues that have occurred (these values can be kept bounded by careful use of modular arithmetic), and items is a fixed-size array of items. The body of the queue -  deq operation is a loop that repeats until the operation&#39;s changes are committed. The operation reads the dequeue count, which is used to locate the head of the queue, and the enqueue count, which is used to check whether the queue is empty. Both counters are read using LTX to reduce the number of transaction aborts. The procedure then validates the values read, and if the queue is non-empty, it reads the value from the queue and tentatively updates the dequeue count. The queue -  enq procedure has a similar structure as seen in FIG. 3. 
     A transaction is said to starve if it is never able to commit. For example, a dequeuer may starve if it is infinitely often overtaken by other dequeuers. Starvation is believed to be best handled at the software level. For example, adaptive backoff techniques proposed by Anderson (see &#34;The performance of spin lock alternatives for shared-memory multiprocessors) and Graunke et al (cited above) to reduce contention can also be used to avoid starvation. Each time a transaction aborts, it waits for a random duration before trying again, doubling the expected delay each time. Operation combining is a deterministic technique for avoiding starvation in which transactions &#34;help&#34; other transactions by executing their operations (see Herlihy, &#34;:A method for implementing highly concurrent data objects,&#34; cited above). 
     A method used to extend a certain class of cache consistency protocols to support the transactional memory primitives will now be described. Below are given detailed and specific protocols for a bus-based architecture and for an architecture employing an arbitrary interconnection network. Here, however, the basic principles are explained. 
     Standard cache consistency protocols fall into two classes as described by Smith. In write-through protocols, any modification to an entry in cache memory 16 immediately results in a modification to memory 12 (and to other cached copies, if they exist). In write-back protocols (also called copy-back), a CPU 10 may modify an entry in cache memory 16 in place, without making an immediate change to main memory 12. The focus here is on write-back protocols, which are the most common in practice. An entry in cache memory 16 is dirty (bit 20 is set) if it has been modified without updating main memory 12, and clean otherwise. Before a process can update a value, it must typically acquire exclusive access to that location, invalidating any cached copies held by other processors 13. Conversely, before a process can read an uncached location, it must acquire a shared copy of that value, revoking any exclusive access held by another processor. 
     Transactional memory is implemented by extending any standard write-back protocol in the following way. Using the bit 25, each cache entry is marked either transactional (TRANS) or non-transactional (TRANS), and using the dirty bit 20 an entry is marked either shared or exclusive (exclusive means the same as dirty, in that this processor has the only valid copy of this data). An entry cached by LT is marked shared and transactional, by ST exclusive and transactional, by LOAD shared and non-transactional, and by STORE exclusive and non-transactional. If a cache entry is marked exclusive and transactional, then that value is tentative, and will not be released to any other processor. In such a case, the protocol ensures that the previous (committed) value is either in memory or in another processor&#39;s cache. 
     Each processor has a transaction state, either ACTIVE or ABORTED, and in the embodiment of FIG. 1 this is the status bit 26. Initially, the transaction state is ACTIVE. It becomes ABORTED if any transactional cache entry is invalidated, as detected by the snoop circuit in the example of FIG. 1. Such invalidation can happen in several ways: 
     (1) If processor P writes to a location in processor Q&#39;s read or write set, then P acquires exclusive access to that location, invalidating Q&#39;s entry, and forcing Q&#39;s transaction to abort. 
     (2) If P reads a location in Q&#39;s write set, then it revokes Q&#39;s exclusive access, invalidating Q&#39;s entry and forcing Q&#39;s transaction to abort. 
     (3) If a non-transactional operation discovers that its operand is cached in transactional mode, it will invalidate that entry before proceeding. It is assumed that such a situation represents a programmer error. 
     (4) If a process empties its cache when it performs a context switch. 
     The COMMIT instruction tests the current transaction state. If it is ACTIVE, then the transaction commits, and its modifications are made visible to the other processes by marking them as non-transactional. If it is ABORTED, then the transaction aborts, and its modifications are discarded by invalidating all transactional cache entries. The VALIDATE instruction tests whether the current transaction state is ACTIVE or ABORTED, which in the embodiment of FIG. 1 is represented by the status bit 26. If it is ACTIVE, the instruction returns True, otherwise it returns False and invalidates the transactional entries. The ABORT instruction invalidates all transactional entries. The COMMIT, ABORT, and VALIDATE instructions all leave the transaction in the ACTIVE state. Notice that a transaction validates, commits, or aborts without communicating with the memory 12 or with other processors 13. 
     A straightforward implementation of a transactional memory may suffer from the problem of cyclic restart. By this is meant that a transaction P may abort transaction Q, and Q in turn may restart and abort P before it can finish, and so on. The following technique alleviates this problem. Each transaction P is given a number of &#34;grace points&#34; which allow it to execute for a fixed duration without being aborted by other transactions. If transaction Q tries to invalidate a cache entry of P, P can postpone Q&#39;s request if it has grace points left. Each time P postpones a request, it reduces its number of grace points by one. When P has used up its grace points, then it can no longer postpone such invalidations, and must abort. The issue is presented of how many grace points a transaction should have. An adaptive strategy can be used to determine the number. Each transaction starts with g grace points. Each time it is aborted by another transaction, it restarts with twice as many grace points, When it commits, it compares its current stock of grace points with g. If it has used up fewer than half its points, it starts the next transaction with g/2 grace points, otherwise it starts with g. Each time Q&#39;s invalidation is postponed, it waits for some duration, and then repeats the request. To avoid saturating the bus or network with repeated requests, Q should undertake an exponential backoff (doubling the pause after each unsuccessful request). 
     A transaction may abort even in the absence of conflicts with other transactions. For example, a transaction may never commit if it repeatedly runs longer than its scheduled quantum, or if it repeatedly accesses more memory locations than its cache can hold. Such coarse-grained transactions reflect an inappropriate use of transactional memory. 
     Transactions may also abort because of false sharing. Cache lines typically encompass more than one word, and logically unrelated variables may be mapped to the same cache line. For example, if P accesses variable p, and Q variable q, and if p and q are mapped to the same cache line, then one transaction may invalidate the other&#39;s cache entry, even though there is no logical conflict between them. It is believed that false sharing between transactions is unlikely to be a serious problem in practice, both because it is likely to be rare, and because it is likely to be transient. False sharing within a transaction is a more serious matter, since a transaction may continually abort itself. Such internal false sharing may be detectable by a static program analysis. 
     Finally, a transaction may abort because of cache set overflow. Most caches are not fully associative. Instead, the cache is implemented as a collection of small, full-associative memories called sets. Each address is mapped onto a particular set, perhaps by hashing. If a transaction&#39;s variables are laid out in such a way that the number of variables that map on to a particular set exceeds the set size, then that transaction might abort even if it runs in isolation. This problem should also be rare, and perhaps detectable by static analysis. 
     One way to avoid such problems is to provide a small transactional cache in addition to the regular cache. The transactional cache should be fully-associative with a line size of one. One possible scheme is the following. Both caches can hold transactional and non-transactional entries, but transactional entries would be placed in the regular cache only in the exceptional event that the transactional cache becomes full. Of course, the replacement algorithm for the transactional cache would evict non-transactional entries first. To cache an entry in exclusive mode in either cache may require invalidating an entry in the other. 
     An alternative embodiment has similarities to a so-called LimitLESS directory-based cache consistency scheme described by Chaiken et al, &#34;LimitLESS directories: a scalable cache coherence scheme,&#34; Proc. 4th Int&#39;l Conf. on Architectural support for Programming Languages and Operating Systems, pp. 224-234, ACM, April 1991. This scheme uses a fast, fixed-size hardware implementation for directories. If a directory overflows, the protocol traps into software, and the software emulates a larger directory. A similar approach is used in this embodiment to respond to cache set overflow. Whenever a cache is forced to evict a transactional entry, it traps into software and emulates a fully-associative cache with line size one. This approach has many of the same advantages as the original LimitLESS scheme: the common case is handled in hardware, and the exceptional case in software. 
     In the example of FIG. 1, only one transactional memory operation can be pending at CPU 10 at a given time. Now, there can be several transactional instructions ST or LT pending, as in the FIG. 3 example, but these just add to the read or write set, and all are terminated upon issuance of a COMMIT or ABORT. Thus, only one &#34;transaction&#34; is pending. When another process starts executing on a given CPU, usually cache lines with dirty bit set are written back and the cache is flushed, so this would abort any pending transaction. An alternative embodiment would allow a transaction to survive a process switch by providing a mechanism for saving the state of the transaction, but this would also require a mechanism for detecting any accesses to the locations in shared memory in the read and write sets, which could be implemented based on the directory model. 
     A Snoopy-Cache Protocol will now be described as an example of a detailed implementation of transactional memory for a bus-based architecture, generally as illustrated in FIG. 1. This scheme is based on a conventional &#34;snoopy cache&#34; scheme, such as that described by Goodman in Proc. 12th Int&#39;l Symp. on Computer Arch., pp. 124-131, pub. by IEEE, June 1983. For simplicity, it is assumed the cache 15 is fully associative and has line size one, although changes necessary to accommodate different structures are discussed. It is also assumed the bus 11 allows processors to inhibit memory 12 from responding to bus requests, i.e., when a hit is detected by the snoop mechanism in response to a read request on the bus. 
     As described above, each entry is either transactional (TRANS) or non-transactional (TRANS). In addition to the transactional/non-transactional status, a cache entry has four states: 
     
         ______________________________________                                    
Name       Meaning                                                        
______________________________________                                    
INVALID    Nothing of interest (bit 21 not set)                           
VALID      Possible shared, not modified (bit 21 set).                    
DIRTY      In one cache only, modified (bit 20 set).                      
RESERVED   In one cache only, not modified (bit 20 not                    
           set)                                                           
______________________________________                                    
 
    
     The following bus cycles on bus 11 initiated by the CPU 10 are used: 
     
         ______________________________________                                    
Name        Meaning                                                       
______________________________________                                    
READ        Read without acquiring ownership.                             
WRITE       Write back value, relinquish ownership.                       
RFO         Read, acquire ownership.                                      
INV         Invalidate.                                                   
DATA(data)  Block Value.                                                  
______________________________________                                    
 
    
     The ownership feature is implemented by having an &#34;owned&#34; bit associated with each cache line, in conventional manner. 
     Tables A through S referred to below are located in Appendix B. 
     A processor may have to do cache replacement before a LOAD, STORE, LT, or ST operation. If a cache entry is VALID or RESERVED, no action is necessary. If it is DIRTY and TRANS, then the processor issues a write cycle, and if it is TRANS, the processor sets its transaction state to ABORTED. 
     The operations in the snoopy-cache protocol will be described, then the bus cycles. A LT or ST instruction issued by an aborted transaction causes no bus cycles, has no effect on the cache, and the LT may return an arbitrary value. The Tables A and B describe how LT and ST behave when the transaction state is ACTIVE. In all cases, the final transaction state is ACTIVE. Notice that if an entry is dirty and non-transactional, then it must be written to memory to ensure that the dirty value is not lost if the transaction aborts. 
     A processor executing the ST instruction acquires an exclusive cached copy of its operand. If the processor already has a non-transactional dirty entry for that location, it is written back to ensure that value will not be lost if the transaction aborts. If a cache line encompasses multiple locations, then a transaction replacing an INVALID entry should issue a RFO bus cycle instead of the INV cycle shown below. 
     If a processor applies a LOAD to a dirty transactional entry or a STORE to any transactional entry, then the transaction state becomes ABORTED and the cache entry is invalidated. The Tables C and D describe how these operations behave for non-transactional entries. 
     If the cache line size exceeds a single word, then a cache in the INVALID state would issue a RFO instead of an INV in response to a STORE instruction. 
     If the COMMIT instruction succeeds, it simply marks all TRANS entries as TRANS, otherwise it marks them INVALID and TRANS. ABORT invalidates all TRANS entries, and VALIDATE checks the transaction state: if it is ACTIVE it returns True otherwise it returns False and invalidates all TRANS entries. All three operations leave the transaction state ACTIVE. 
     The manner in which the caches respond to bus cycles are described in Tables E, E and G. 
     When the memory observes a READ or RFO cycle, and if it is not inhibited from responding by a processor, then it responds with the value at that location. When it observes a DATA cycle, it updates that location. 
     Another example of an implementation according to an embodiment of the invention is a Directory Protocol. A directory-based cache consistency protocol is intended for a multiprocessor architecture where it is impractical for processors to communicate by broadcasts (i.e., no invalidates on the bus 11). How transactional memory can be implemented using a simple directory-based protocol will be described. This protocol is based loosely on Chaiken et al (cited above). For simplicity, it is assumed here that messages are delivered in the order they are sent, although the protocol can easily be adjusted to cope with out-of-order messages. 
     Each directory entry has a state and a set of pointers to caches, and each processor has a cache state and a transaction state. The SHARED-WAIT and EXCL-WAIT states are parameterized by an integer i that indicates the number of outstanding acknowledgments. Table H defines directory and cache, and Table I gives the messages used. 
     The CHECKP message is used to checkpoint the old (committed) value before ST makes a tentative change. 
     As before, a LT instruction issued when the transaction state is ABORTED will have no effect on the cache or transaction state, and may return an arbitrary value. The Table J describes how LT behaves when the transaction state is ACTIVE. 
     If a cache line encompasses multiple locations, then a transaction replacing an INVALID entry should send an XREQ message instead of the INV message shown in Table K. 
     As before, if a processor applies a LOAD to a dirty transactional entry or a STORE to any transactional entry, then the transaction is aborted and the cache entry is invalidated. The Tables L and M describe how these operations behave for non-transactional entries. 
     The COMMIT, ABORT, and VALIDATE instructions behave exactly as in the protocol of the previous example. 
     When a process receives BUSY in response to a SREQ or XREQ message, it simply retransmits. The DATA message arrives only in response to SREQ or XREQ. 
     The manner in which the caches respond to messages is described in Table N. 
     The Directory is defined in Tables O, P, Q, and R, where the shorthand &#34;P→M&#34; is used for &#34;P sends m,&#34; and &#34;M→P for &#34;M is sent to P.&#34; 
     As shown in Table S, an UPDATE means either that the process is voluntarily giving up ownership perhaps due to a cache flush (first case), or it is giving up ownership in response to any INV message. 
     While the invention has been described with reference to specific embodiments, the description is not meant to be construed in a limiting sense. Various modifications of the disclosed embodiments, as well as other embodiments of the invention, will be apparent to persons skilled in the art upon reference to this description. It is therefore contemplated that the appended claims will cover any such modifications or embodiments which fall within the true scope of the invention. 
     
                                           APPENDIX A                              
__________________________________________________________________________
typedef struct {                                                          
   unsigned engs;                                                         
   unsigned degs;                                                         
   unsigned items [QUEUE.sub.-- SIZE];                                    
} queue                                                                   
unsigned queue.sub.-- deg(queue *q) {                                     
   unsigned head, tail, result;                                           
   while (1) {                                                            
    result = QUEUE.sub.-- EMPTY;                                          
    head = LTX(&amp;q@&gt;deqs);                                                 
    tail = LTX(&amp;q@&gt;enqs);                                                 
     if (VALIDATE( )) {  /* everything ok?                                
                                     /*                                   
      if (head != tail) {                                                 
                         /* queue not empty?                              
                                     /*                                   
result = LT(&amp;q@&gt;items[head % QUEUE.sub.-- SIZE])                          
                         /* read result                                   
                                     /*                                   
ST(&amp;q@&gt;deqs, head + 1);  /* advance counter                               
                                     /*                                   
   }                                                                      
   if (Commit( )) return result;                                          
  }                                                                       
 }                                                                        
unsigned queue.sub.-- enq(queue *q, unsigned value) {                     
  unsigned head, tail, result;                                            
  while (1) {                                                             
     result = QUEUE.sub.-- FULL;                                          
    head = LTX(&amp;q@&gt;deqs);                                                 
    tail = LTX(&amp;q@&gt;enqs);                                                 
    if (VALIDATE( )) {                                                    
     if (tail - head &lt; QUEUE.sub.-- SIZE) {                               
                         /* queue not full?                               
                                     /*                                   
ST(&amp;q@&gt;items[head % QUEUE.sub.-- SIZE], value);                           
                         /* insert value                                  
                                     /*                                   
ST(&amp;q@&gt;enqs, tail + 1);  /* advance counter                               
                                     /*                                   
result = QUEUE.sub.-- OK;                                                 
                         /* return code                                   
                                     /*                                   
   }                                                                      
   if (Commit( )) return result;                                          
  }                                                                       
 }                                                                        
-.                                                                        
__________________________________________________________________________
 
    
     
                       TABLE A                                                     
______________________________________                                    
LT                                                                        
Old Cache      Cycle    New Cache   Result                                
______________________________________                                    
INVALID        READ     VALID &amp;     DATA                                  
                        TRANS       value                                 
VALID &amp;  TRANS none     VALID &amp;     cache                                 
                        TRANS       contents                              
VALID &amp; TRANS  none     VALID &amp;     cache                                 
                        TRANS       contents                              
RESERVED &amp;  TRANS                                                         
               none     RESERVED &amp;  cache                                 
                        TRANS       contents                              
RESERVED &amp; TRANS                                                          
               none     RESERVED &amp;  cache                                 
                        TRANS       contents                              
DIRTY &amp;  TRANS WRITE    RESERVED &amp;  cache                                 
                        TRANS       contents                              
DIRTY &amp; TRANS  none     DIRTY &amp;     cache                                 
                        TRANS       contents                              
______________________________________                                    
 
    
     
                       TABLE B                                                     
______________________________________                                    
ST                                                                        
Old Cache      Cycle       New Cache                                      
______________________________________                                    
INVALID        INV         DIRTY &amp; TRANS                                  
VALID &amp;  TRANS none        DIRTY &amp; TRANS                                  
VALID &amp; TRANS  none        DIRTY &amp; TRANS                                  
RESERVED &amp;  TRANS                                                         
               none        DIRTY &amp; TRANS                                  
RESERVED &amp; TRANS                                                          
               none        DIRTY &amp; TRANS                                  
DIRTY &amp;  TRANS WRITE(data) DIRTY &amp; TRANS                                  
DIRTY &amp; TRANS  none        DIRTY &amp; TRANS                                  
______________________________________                                    
 
    
     
                       TABLE C                                                     
______________________________________                                    
LOAD                                                                      
Old Cache   Cycle    New Cache   Result                                   
______________________________________                                    
INVALID     READ     VALID       DATA value                               
VALID       none     VALID       cache contents                           
RESERVED    none     RESERVED    cache contents                           
DIRTY       none     DIRTY       cache contents                           
______________________________________                                    
 
    
     
                       TABLE D                                                     
______________________________________                                    
STORE                                                                     
Old Cache       Cycle       New Cache                                     
______________________________________                                    
INVALID         INV         DIRTY                                         
Valid           INV         DIRTY                                         
RESERVED        none        DIRTY                                         
DIRTY           none        DIRTY                                         
______________________________________                                    
 
    
     
                       TABLE E                                                     
______________________________________                                    
READ                                                                      
              Old                     New                                 
Old Cache     Trans   Send    New Cache                                   
                                      Trans                               
______________________________________                                    
VALID &amp;  TRANS                                                            
              any     DATA    unchanged                                   
                                      un-                                 
                                      changed                             
VALID &amp; TRANS any     DATA    unchanged                                   
                                      un-                                 
                                      changed                             
RESERVED &amp;    any     DATA    VALID &amp; un-                                 
 TRANS                         TRANS  changed                             
RESERVED &amp; TRANS                                                          
              any     DATA    VALID &amp; un-                                 
                              TRANS   changed                             
DIRTY &amp;  TRANS                                                            
              any     DATA    VALID &amp; un-                                 
                               TRANS  changed                             
DIRTY &amp; TRANS any     none    DIRTY &amp; ABOR-                               
                              TRANS   TED                                 
______________________________________                                    
 
    
     
                       TABLE F                                                     
______________________________________                                    
RFO                                                                       
              Old                     New                                 
Old Cache     Trans   Send    New Cache                                   
                                      Trans                               
______________________________________                                    
VALID &amp;  TRANS                                                            
              any     none    INVALID un-                                 
                                      changed                             
VALID &amp; TRANS any     none    INVALID ABOR-                               
                                      TED                                 
RESERVED &amp;    any     DATA    INVALID un-                                 
 TRANS                                changed                             
RESERVED &amp; TRANS                                                          
              any     DATA    INVALID ABOR-                               
                                      TED                                 
DIRTY &amp;  TRANS                                                            
              any     DATA    INVALID un-                                 
                                      changed                             
DIRTY &amp; TRANS any     none    DIRTY &amp; ABOR-                               
                              TRANS   TED                                 
______________________________________                                    
 
    
     
                       TABLE G                                                     
______________________________________                                    
INV                                                                       
Old Cache  Old Trans Send   New Cache                                     
                                    New Trans                             
______________________________________                                    
any &amp;  TRANS                                                              
           any       none   INVALID unchanged                             
any &amp; TRANS                                                               
           any       none   INVALID ABORTED                               
______________________________________                                    
 
    
     
                       TABLE H                                                     
______________________________________                                    
Component                                                                 
        State         Meaning                                             
______________________________________                                    
Directory                                                                 
        SHARED        Multiple read-only copies                           
                      cached.                                             
        EXCLUSIVE     Single modifiable copy cached.                      
        SHARED-WAIT(i)                                                    
                      Awaiting i acks to enter                            
                      SHARED state.                                       
        EXCL-WAIT(i)  Awaiting i acks to enter                            
                      EXCLUSIVE state.                                    
Cache   INVALID       Not read or written.                                
        VALID         Read but not written.                               
        DIRTY         Written.                                            
______________________________________                                    
 
    
     
                       TABLE I                                                     
______________________________________                                    
Type   Symbol      Name                                                   
______________________________________                                    
Cache to                                                                  
       SREQ        Request shared access.                                 
Memory XREQ        Request exclusive access.                              
       CHECKP(data)                                                       
                   Write back block, keep ownership.                      
       UPDATE(data)                                                       
                   Write back block, give up ownership.                   
       ACKC        Give up owneriship.                                    
Memory DATA(data)  Block value.                                           
to Cache                                                                  
       INV         Invalidate.                                            
       BUSY        Busy Signal.                                           
______________________________________                                    
 
    
     
                       TABLE J                                                     
______________________________________                                    
LT                                                                        
Old Cache    Send      New Cache     Result                               
______________________________________                                    
INVALID      SREQ      VALID &amp; TRANS DATA                                 
                                     value                                
VALID &amp;  TRANS                                                            
             none      VALID &amp; TRANS cached                               
                                     value                                
VALID &amp; TRANS                                                             
             none      VALID &amp; TRANS cached                               
                                     value                                
DIRTY &amp;  TRANS                                                            
             CHECKP    VALID &amp; TRANS cached                               
                                     value                                
DIRTY &amp; TRANS                                                             
             none      DIRTY &amp; TRANS cached                               
                                     value                                
______________________________________                                    
 
    
     
                       TABLE K                                                     
______________________________________                                    
ST                                                                        
Old Cache     Send        New Cache                                       
______________________________________                                    
INVALID       INV         DIRTY &amp; TRANS                                   
VALID &amp;  TRANS                                                            
              INV         DIRTY &amp; TRANS                                   
VALID &amp; TRANS INV         DIRTY &amp; TRANS                                   
DIRTY &amp;  TRANS                                                            
              CHECKP      DIRTY &amp; TRANS                                   
DIRTY &amp; TRANS none        DIRTY &amp; TRANS                                   
______________________________________                                    
 
    
     
                       TABLE L                                                     
______________________________________                                    
LOAD                                                                      
Old Cache  Send      New Cache  Result                                    
______________________________________                                    
INVALID    SREQ      VALID      DATA value                                
VALID      none      SHARED     cached value                              
DIRTY      none      DIRTY      cached value                              
______________________________________                                    
 
    
     
                       TABLE M                                                     
______________________________________                                    
STORE                                                                     
Old Cache       Send       New Cache                                      
______________________________________                                    
INVALID         XREQ       DIRTY                                          
VALID           XREQ       DIRTY                                          
DIRTY           none       DIRTY                                          
______________________________________                                    
 
    
     
                       TABLE N                                                     
______________________________________                                    
INV                                                                       
Old Cache                                                                 
        Old Trans Send      New Cache                                     
                                    New Trans                             
______________________________________                                    
INVALID any       none      INVALID unchanged                             
VALID &amp; any       ACKC      INVALID unchanged                             
 TRANS                                                                    
VALID &amp; any       ACKC      INVALID ABORTED                               
TRANS                                                                     
DIRTY &amp; any       UPDATE    INVALID unchanged                             
 TRANS                                                                    
DIRTY &amp; any       none      INVALID ABORTED                               
TRANS                                                                     
______________________________________                                    
 
    
     
                       TABLE O                                                     
______________________________________                                    
P → SREQ                                                           
Old     Old                 New                                           
State   Pointers Send       State   New Pointers                          
______________________________________                                    
SHARED  S        DATA → P                                          
                            SHARED  S ∪ {P}                        
EXCLU-  {Q}      INV → Q                                           
                            SHARED- {P}                                   
SIVE                        WAIT(1)                                       
SHARED- {Q}      BUSY → P                                          
                            SHARED- {Q}                                   
WAIT(i)                     WAIT(i)                                       
EXCL-   {Q}      BUSY → P                                          
                            EXCL-   {Q}                                   
WAIT(i)                     WAIT(i)                                       
______________________________________                                    
 
    
     
                       TABLE P                                                     
______________________________________                                    
P → XREQ                                                           
Old                          New                                          
State   Pointers Send        State    Pointers                            
______________________________________                                    
SHARED  {P}      DATA → P                                          
                             EXCLU-   {P}                                 
                             SIVE                                         
SHARED  S ≠ {P}                                                     
                  Q ε S - {P},                                    
                             EXCL-    {P}                                 
                 INV → Q                                           
                             WAIT                                         
                             (|S - {P}|)                
                                      {P}                                 
EXCLU-  {Q}      INV → Q                                           
                             EXCL-    {P}                                 
SIVE                         WAIT(1)                                      
SHARED- S        BUSY → P                                          
                             SHARED-  S                                   
WAIT(i)                      WAIT(i)                                      
EXCL-   S        BUSY → P                                          
                             EXCL-    S                                   
WAIT(i)                      WAIT(i)                                      
______________________________________                                    
 
    
     
                       TABLE Q                                                     
______________________________________                                    
P → CHECKP                                                         
Old State                                                                 
       Pointers  Send   New State                                         
                                Pointers                                  
                                        Result                            
______________________________________                                    
EXCLU- {P}       none   EXCLU-  {P}     replaces                          
SIVE                    SIVE            value                             
______________________________________                                    
 
    
     
                       TABLE R                                                     
______________________________________                                    
P → UPDATE                                                         
Old     Poin-              New     Poin-                                  
State   ters    Send       State   ters Result                            
______________________________________                                    
EXCLU-  {P}     none       SHARED  .0.  replaces                          
SIVE                                    value                             
SHARED- {Q}     DATA → Q                                           
                           SHARED  {Q}  replaces                          
WAIT(1)                                 value                             
EXCL-   {Q}     DATA → Q                                           
                           EXCLU-  {Q}  replaces                          
WAIT(1)                    SIVE         value                             
______________________________________                                    
 
    
     
                       TABLE S                                                     
______________________________________                                    
P → ACKC                                                           
Old                         New                                           
State   pointers Send       State   Pointers                              
______________________________________                                    
SHARED- {Q}      DATA → Q                                          
                            SHARED  {Q}                                   
WAIT(1)                                                                   
SHARED- {Q}      none       SHARED- {Q}                                   
WAIT                        WAIT                                          
(i &gt; 1)                     (i - 1)                                       
EXCL-   {Q}      DATA → Q                                          
                            EXCLU-  {Q}                                   
WAIT(1)                     SIVE                                          
EXCL-   {Q}      DATA → Q                                          
                            EXCL-   {Q}                                   
WAIT                        WAIT                                          
(i &gt; 1)                     (i - 1)                                       
______________________________________