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 having syntax for both open and closed nested transactions, and boosting, 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.
Thu 3 NovDisplayed time zone: Amsterdam, Berlin, Bern, Rome, Stockholm, Vienna change
13:30 - 15:10
|Efficient and Thread-Safe Objects for Dynamically-Typed Languages|
Benoit Daloze JKU Linz, Austria, Stefan Marr Johannes Kepler University Linz, Daniele Bonetta Oracle Labs, Hanspeter Mössenböck JKU Linz, AustriaDOI Pre-print Media Attached
|Hybrid STM/HTM for Nested Transactions on OpenJDK|
Keith Chapman Purdue University, Tony Hosking Australian National University, Data61, and Purdue University, Eliot Moss University of Massachusetts AmherstLink to publication DOI Pre-print Media Attached
|Makalu: Fast Recoverable Allocation of Non-volatile Memory|
OOPSLADOI Pre-print Media Attached
|Prioritized Garbage Collection: Explicit GC Support for Software Caches|
Diogenes Nunez Tufts University, Sam Guyer Tufts University, Emery D. Berger University of Massachusetts, AmherstDOI Pre-print Media Attached