English (United Kingdom)

https://curated-unify.zendy.io/wp-json/zendy-region/v1/featured_content/oa?rat=en

https://curated-unify.zendy.io/wp-json/zendy-region/v1/highlighted_journal/

Global: Zendy Plus annual

Presents the access of premium content as premium feature

Premium Content

Presents the keyphrase highlighting as premium feature

Keyphrase Highlighting

Presents the summarisation as premium feature

Summarisation

Insights

Presents the pdf analysis as premium feature

PDF Analysis

Presents the zaia usage as premium feature

ZAIA

Global: Zendy Plus monthly

Global: Zendy Tools annual

Global: Zendy Tools monthly

Global: Zendy Free Plan

Transaction Memory (TM) is a concurrency control abstraction that allows theprogrammer to specify blocks of code to be executed atomically as transactions.However, since transactional code can contain just about any operationattention must be paid to the state of shared variables at any given time.E.g., contrary to a database transaction, if a TM transaction reads a stalevalue it may execute dangerous operations, like attempt to divide by zero,access an illegal memory address, or enter an infinite loop. Thusserializability is insufficient, and stronger safety properties are required inTM, which regulate what values can be read, even by transactions that abort.Hence, a number of TM safety properties were developed, including opacity, andTMS1 and TMS2. However, such strong properties preclude using early release asa technique for optimizing TM, because they virtually forbid reading from livetransactions. On the other hand, properties that do allow early release areeither not strong enough to prevent any of the problems mentioned above(recoverability), or add additional conditions on transactions with earlyrelease that limit their applicability (elastic opacity, live opacity, virtualworld consistency). This paper introduces last-use opacity, a new TM safetyproperty that is meant to be a compromise between strong properties likeopacity and serializability. The property eliminates all but a small class ofinconsistent views and poses no stringent conditions on transactions. Forillustration, we present a last-use opaque TM algorithm and show that itsatisfies the new safety property.

Last-use Opacity: A Strong Safety Property for Transactional Memory with Early Release Support