Synchronized-by-Default Concurrency for Shared-Memory Systems

Abstract

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%.

swSpTRSV

“…Traditional data layouts, such as CSR 4 and CSC, are unaware of data reuse. As shown in line 4 of Alg.1, methods based on the CSC layout traverse the nonzeros in the column (vertical) direction, which leads to perfect data reuse of x but makes the reuse of b handled by hardware.…”

“…The performance is presented in Fig.10, and a statistics about the number of best performance achieved by each method is listed in Tab. 4.…”

“…Because of the serial nature, algorithm optimization for parallel SpTRSV have been mainly developed on top of the level-set methods by Anderson and Saad [2] and Saltz [45] and color-set methods by Schreiber and Tang [46] for various parallel architectures [25,29,39,40,51]. Despite their effectiveness, the barrier synchronization (where itself is a well-known bottleneck for parallel program [4,14,20,21,38,65]) often limits the performance of parallel SpTRSV. To address this problem, Park et al [40] sparsified synchronization through pruning unneeded dependencies, and Liu et al replaced synchronization with atomic operations [29] and developed a implementation for further parallelizing multiple right-hand sides [30].…”

PVcon: Localizing Hidden Concurrency Errors With Prediction and Verification

“…Concurrency problems are nasty, and many techniques [40]- [46] have been developed to prevent and repair them. For instance, Martin et al [40] present a programming ap-proach to present concurrency errors. Their approach synchronizes all access events in atomic sections and a programmer manually splits the atomic sections to increase threads.…”