Abstract:
PROBLEM TO BE SOLVED: To prevent false contention and serialized execution which may be posed because a capability for executing a plurality of software threads is constantly increasing. SOLUTION: The apparatus and method are for handling shared memory accesses between multiple processors utilizing lock-free synchronization through transactional-execution. A transaction demarcated in software is speculatively executed. During execution invalidating remote accesses/requests to addresses loaded from and to be written to shared memory are tracked by a transactional buffer. If an invalidating access is encountered, the transaction is re-executed. After a pre-determined number of times re-executing the transaction, the transaction may be re-executed non-speculatively with locks/semaphores. COPYRIGHT: (C)2011,JPO&INPIT
Abstract:
PROBLEM TO BE SOLVED: To handle shared memory accesses between a plurality of processors, using lock-free synchronization through transactional execution. SOLUTION: A transaction demarcated in software is speculatively executed. During execution invalidating remote accesses/requests to addresses loaded from and to be written to share memory are tracked by a transactional buffer (605). If an invalidating access is encountered, the transaction is re-executed (610). After a pre-determined number of times re-executing the transaction (615), the transaction may be re-executed non-speculatively with locks/semaphores (620). COPYRIGHT: (C)2011,JPO&INPIT
Abstract:
In one embodiment, a method includes receiving a read request from a first caching agent, determining whether a directory entry associated with the memory location indicates that the information is not present in a remote caching agent, and if so, transmitting the information from the memory location to the first caching agent before snoop processing with respect to the read request is completed. Other embodiments are described and claimed.
Abstract:
Disclosed is a multiprocessor core or multi threaded processor, consisting of logic for executing transactions, a shared memory to hold an input data element used by the transaction, a storage element coupled to the logic and the shared memory, a transaction buffer and logic to abort the transaction. The storage element is biased against receiving new data elements during the pendancy of the transaction. The transaction buffer tracks invaliding requests to the shared memory during the execution of the transaction. The transaction abort logic aborts the transaction in response to the transaction buffer tracking an invaliding request during the execution of the transaction. The apparatus may have a second storage element to hold a locking predicate value. When set to a locked value the execution logic is to execute the transaction non-speculatively using a semaphore to provide exclusive access to the data element in the shred memory. The execution logic may evaluate the count variable in response to aborting the transaction and set the locking predicate to the locking value, if the count variable represents that the transaction has been re-executed a predetermined number of times.
Abstract:
The apparatus and method described herein are for handling shared memory accesses between multiple processors utilizing lock-free synchronization through transactional-execution. A transaction demarcated in software is speculatively executed. During execution invalidating remote accesses/requests to addresses loaded from and to be written to shared memory are tracked by a transaction buffer. If an invalidating access is encountered, the transaction is re-executed. After a pre-determined number of times re-executing the transaction, the transaction may be re-executed non-speculatively with locks/semaphores.
Abstract:
The apparatus and method described herein are for handling shared memory accesses between multiple processors utilizing lock-free synchronization through transactional-execution. A transaction demarcated in software is speculatively executed. During execution invalidating remote accesses/requests to addresses loaded from and to be written to shared memory are tracked by a transaction buffer. If an invalidating access is encountered, the transaction is re-executed. After a pre-determined number of times re-executing the transaction, the transaction may be re-executed non-speculatively with locks/semaphores.
Abstract:
A method and apparatus for selecting and updating a replacement candidate in a cache is disclosed. In one embodiment, a cache miss may initiate the eviction of a present replacement candidate in a last-level cache. The cache miss may also initiate the selection of a future replacement candidate. Upon the selection of the future replacement candidate, the corresponding cache line may be invalidated in lower-level caches but remain resident in the last-level cache. The future replacement candidate may be updated by subsequent hits to the replacement candidate in the last-level cache prior to a subsequent cache miss.
Abstract:
The apparatus and method described herein are for handling shared memory accesses between multiple processors utilizing lock-free synchronization through transactional-execution. A transaction demarcated in software is speculatively executed. During execution invalidating remote accesses/requests to addresses loaded from and to be written to shared memory are tracked by a transaction buffer. If an invalidating access is encountered, the transaction is re-executed. After a pre-determined number of times re-executing the transaction, the transaction may be re-executed non-speculatively with locks/semaphores.