Low-overhead software transactional memory with progress guarantees and strong semantics

Zhang, Minjia; Huang, Juan; Cao, Man; Bond, Michael D.

doi:10.1145/2688500.2688510

Cited by 14 publications

(7 citation statements)

References 61 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…Dice et al show that such an STM can outperform a TL2 global-clock based STM [10,11] on single-chip multicore processors. Zhang et al show that a STM using RW locks performs well for low-contention workloads [36], similar to those we used in our experiments. Our approach displays a usage for STMs using RW locks.…”

Section: Related Worksupporting

confidence: 82%

“…To realize atomic sections with the above semantics, we use a special-purpose STM. The reason is that currently available HTM systems (e.g., Intel TSX), or fast STM systems [8,11,29,36] do either not support the combination of the following TM properties, or are not optimized for them:…”

Section: Atomic Sectionsmentioning

confidence: 99%

“…An alternative is to use a software transactional memory (STM) [30] as it runs on existing hardware. However, even fast STM implementations [8,11,29,36] are optimized for language integration using the atomic block model [19], i.e., only a fraction of the memory accesses requires synchronization, thus such STMs can tolerate a higher overhead than is acceptable by the SBD approach. A r ti fact * Scalability.…”

Section: Introductionmentioning

confidence: 99%

See 2 more Smart Citations

Synchronized-by-Default Concurrency for Shared-Memory Systems

Bättig

Groß

2017

Proceedings of the 22nd ACM SIGPLAN Symposium on Principles and Practice of Parallel Programming

View full text Add to dashboard Cite

We explore a programming approach for concurrency that synchronizes all accesses to shared memory by default. Synchronization takes place by ensuring that all program code runs inside atomic sections even if the program code has external side effects. Threads are mapped to atomic sections that a programmer must explicitly split to increase concurrency.A naive implementation of this approach incurs a large amount of overhead. We show how to reduce this overhead to make the approach suitable for realistic application programs on existing hardware. We present an implementation technique based on a special-purpose software transactional memory system. To reduce the overhead, the technique exploits properties of managed, object-oriented programming languages as well as intraprocedural static analyses and uses field-level granularity locking in combination with transactional I/O to provide good scaling properties.We implemented the synchronized-by-default (SBD) approach for the Java language and evaluate its performance for six programs from the DaCapo benchmark suite. The evaluation shows that, compared to explicit synchronization, the SBD approach has an overhead between 0.4% and 102% depending on the benchmark and the number of threads, with a mean (geom.) of 23.9%.

show abstract

Section: Related Worksupporting

confidence: 82%

Section: Atomic Sectionsmentioning

confidence: 99%

Section: Introductionmentioning

confidence: 99%

See 1 more Smart Citation

Synchronized-by-Default Concurrency for Shared-Memory Systems

Bättig

Groß

2017

Proceedings of the 22nd ACM SIGPLAN Symposium on Principles and Practice of Parallel Programming

View full text Add to dashboard Cite

show abstract

“…As an example, several implementations of software transactional memory (STM) reduce the overhead of the STM runtime by avoiding or minimizing unnecessary operations. One notable example is the LarkTM STM [37], which assumes every object to be readonly until a transaction attempts to modify it. Similarly, there are examples of STMs that have been integrated with language runtimes and JIT compilers [1,18] to apply common techniques such as escape analysis to reduce the overhead of STM read and write barriers.…”

Section: Minimizing Synchronization and Avoiding It At Run Timementioning

confidence: 99%

Efficient and thread-safe objects for dynamically-typed languages

DalozeBenoit¹,

MarrStefan²,

BonettaDaniele³

et al. 2016

SIGPLAN Not.

View full text Add to dashboard Cite

We are in the multi-core era. Dynamically-typed languages are in widespread use, but their support for multithreading still lags behind. One of the reasons is that the sophisticated techniques they use to efficiently represent their dynamic object models are often unsafe in multithreaded environments. This paper defines safety requirements for dynamic object models in multithreaded environments. Based on these requirements, a language-agnostic and thread-safe object model is designed that maintains the efficiency of sequential approaches. This is achieved by ensuring that field reads do not require synchronization and field updates only need to synchronize on objects shared between threads. Basing our work on JRuby+Truffle, we show that our safe object model has zero overhead on peak performance for thread-local objects and only 3% average overhead on parallel benchmarks where field updates require synchronization. Thus, it can be a foundation for safe and efficient multithreaded VMs for a wide range of dynamic languages.

show abstract

“…LarkTM [24], a Software Transactional Memory implementation uses VM safepoints for coordinating the resolution of lock conflicts with their biased reader-writer locks [2]. They partition the threads into two categories: threads executing a blocking operation (waiting, I/O, running native code, etc) and all others threads.…”

Section: Biased Reader-writer Locksmentioning

confidence: 99%

Techniques and applications for guest-language safepoints

Daloze

Seaton

Bonetta

et al. 2015

Proceedings of the 10th Workshop on Implementation, Compilation, Optimization of Object-Oriented Languages, Programs and System

View full text Add to dashboard Cite

Safepoints are a virtual machine mechanism that allows one thread to suspend other threads in a known state so that runtime actions can be performed without interruption and with data structures in a consistent state. Many virtual machines use safepoints as a mechanism to provide services such as stop-the-world garbage collection, debugging, and modification to running code such as installing or replacing classes. Languages implemented on these virtual machines may have access to these services, but not directly to the safepoint mechanism itself. We show that safepoints have many useful applications for the implementation of guest languages running on a virtual machine. We describe an API for using safepoints in languages that were implemented under the Truffle language implementation framework on the Java Virtual Machine and show several applications of the API to implement useful guest-language functionality. We present an efficient implementation of this API, when running in combination with the Graal dynamic compiler. We also demonstrate that our safepoints cause zero overhead with respect to peak performance and statistically insignificant overhead with respect to compilation time. We compare this to other techniques that could be used to implement the same functionality and demonstrate the large overhead that they incur.

show abstract

Low-overhead software transactional memory with progress guarantees and strong semantics

Cited by 14 publications

References 61 publications

Synchronized-by-Default Concurrency for Shared-Memory Systems

Synchronized-by-Default Concurrency for Shared-Memory Systems

Efficient and thread-safe objects for dynamically-typed languages

Techniques and applications for guest-language safepoints

Contact Info

Product

Resources

About