Skip to main content


Hybrid STM/HTM for nested transactions on OpenJDK


Keith Chapman, Tony Hosking and Eliot Moss

Purdue University


Australian National University

University of Massachusetts


Transactional memory (TM) has long been advocated as a promising pathway to more automated concurrency control for scaling concurrent programs running on parallel hardware. Software TM (STM) has the benefit of being able to run general transactional programs, but at the significant cost of overheads imposed to log memory accesses, mediate access conflicts, and maintain other transaction metadata. Recently, hardware manufacturers have begun to offer commodity hardware TM (HTM) support in their processors wherein the transaction metadata is maintained “for free” in hardware. However, HTM approaches are only best-effort: they cannot successfully run all transactional programs, whether because of hardware capacity issues (causing large transactions to fail), or compatibility restrictions on the processor instructions permitted within hardware transactions (causing transactions that execute those instructions to fail). In such cases, programs must include failure-handling code to attempt the computation by some other software means, since retrying the transaction would be futile. Thus, a canonical use of HTM is lock elision: replacing lock regions with transactions, retrying some number of times in the case of conflicts, but falling back to locking when HTM fails for other reasons.

Here, we describe how software and hardware schemes can combine seamlessly into a hybrid system in support of transactional programs, allowing use of low-cost HTM when it works, but reverting to STM when it doesn’t. We describe heuristics used to make this choice dynamically and automatically, but allowing the transition back to HTM opportunistically. Our implementation is for an extension of Java with both open and closed nested transactions, running on the OpenJDK, with dynamic injection of STM mechanisms (into code variants used under STM) and HTM instructions (into code variants used under HTM). Both schemes are compatible to allow different threads to run concurrently with either mechanism, while preserving transaction safety. Using a standard synthetic benchmark we demonstrate that HTM offers significant acceleration of both closed and open nested transactions, while yielding parallel scaling up to the limits of the hardware, whereupon scaling in software continues but with the penalty to throughput imposed by software mechanisms.

BibTeX Entry

    doi              = {10.1145/2983990.2984029},
    author           = {Chapman, Keith and Hosking, Tony and Moss, Eliot},
    month            = oct,
    year             = {2016},
    keywords         = {transactional memory, hardware transactional memory, software transactional memory, java},
    title            = {Hybrid {STM}/{HTM} for Nested Transactions on {OpenJDK}},
    booktitle        = {Conference on Object-Oriented Programming Systems, Languages, and Applications (OOPSLA)},
    pages            = {660-676},
    address          = {Amsterdam, The Netherlands}