연락처 : ER 이메일 : changdeshotel@yahoo.com

In computer science and engineering, transactional memory attempts to simplify concurrent programming by allowing a bunch of load and store directions to execute in an atomic manner. It is a concurrency control mechanism analogous to database transactions for Memory Wave memory booster controlling access to shared memory in concurrent computing. Transactional memory techniques present excessive-stage abstraction instead to low-level thread synchronization. This abstraction permits for coordination between concurrent reads and writes of shared information in parallel methods. In concurrent programming, synchronization is required when parallel threads try to access a shared useful resource. Low-degree thread synchronization constructs comparable to locks are pessimistic and prohibit threads that are outside a important section from working the code protected by the critical section. The means of making use of and releasing locks typically capabilities as a further overhead in workloads with little conflict among threads. Transactional memory provides optimistic concurrency control by permitting threads to run in parallel with minimal interference. The objective of transactional memory methods is to transparently assist regions of code marked as transactions by implementing atomicity, consistency and isolation.

A transaction is a collection of operations that may execute and commit modifications as long as a battle will not be current. When a battle is detected, a transaction will revert to its initial state (previous to any adjustments) and can rerun till all conflicts are removed. Earlier than a successful commit, the result of any operation is purely speculative inside a transaction. In distinction to lock-based synchronization where operations are serialized to forestall data corruption, transactions allow for added parallelism as long as few operations attempt to change a shared useful resource. Because the programmer isn't liable for explicitly identifying locks or the order in which they're acquired, packages that utilize transactional memory can not produce a deadlock. With these constructs in place, transactional memory provides a high-level programming abstraction by allowing programmers to enclose their strategies inside transactional blocks. Appropriate implementations ensure that knowledge can't be shared between threads with out going through a transaction and produce a serializable final result. Within the code, the block outlined by "transaction" is guaranteed atomicity, consistency and isolation by the underlying transactional memory implementation and is clear to the programmer.

The variables throughout the transaction are protected from exterior conflicts, ensuring that both the proper quantity is transferred or no action is taken at all. Note that concurrency related bugs are still doable in programs that use a large number of transactions, especially in software implementations where the library provided by the language is unable to enforce correct use. Bugs introduced by means of transactions can usually be tough to debug since breakpoints cannot be positioned within a transaction. Transactional memory is limited in that it requires a shared-memory abstraction. Though transactional Memory Wave memory booster programs cannot produce a deadlock, applications should still undergo from a livelock or useful resource starvation. For example, longer transactions may repeatedly revert in response to multiple smaller transactions, losing each time and energy. The abstraction of atomicity in transactional memory requires a hardware mechanism to detect conflicts and undo any adjustments made to shared information. Hardware transactional memory systems might comprise modifications in processors, cache and bus protocol to assist transactions.

Speculative values in a transaction must be buffered and stay unseen by other threads until commit time. Large buffers are used to store speculative values whereas avoiding write propagation by way of the underlying cache coherence protocol. Traditionally, buffers have been carried out utilizing completely different structures inside the memory hierarchy equivalent to store queues or caches. Buffers additional away from the processor, such because the L2 cache, can hold more speculative values (up to a couple megabytes). The optimal size of a buffer remains to be underneath debate due to the restricted use of transactions in commercial packages. In a cache implementation, the cache traces are typically augmented with learn and write bits. When the hardware controller receives a request, the controller makes use of these bits to detect a conflict. If a serializability conflict is detected from a parallel transaction, then the speculative values are discarded. When caches are used, the system could introduce the danger of false conflicts due to the use of cache line granularity.

Load-hyperlink/store-conditional (LL/SC) provided by many RISC processors may be viewed as essentially the most primary transactional memory assist; however, LL/SC normally operates on data that's the size of a native machine phrase, so only single-word transactions are supported. Although hardware transactional memory provides maximal performance in comparison with software options, limited use has been seen at this time. Because the downside, software implementations normally include a performance penalty, when in comparison with hardware options. Hardware acceleration can cut back a few of the overheads related to software transactional memory. Owing to the extra limited nature of hardware transactional memory (in current implementations), software utilizing it could require pretty in depth tuning to completely benefit from it. For instance, the dynamic memory allocator may have a major influence on performance and likewise construction padding may affect performance (owing to cache alignment and false sharing points); within the context of a virtual machine, numerous background threads might trigger unexpected transaction aborts. One of many earliest implementations of transactional memory was the gated store buffer utilized in Transmeta's Crusoe and Efficeon processors.