Efficient system-enforced deterministic parallelism

@article{Aviram2010EfficientSD,
  title={Efficient system-enforced deterministic parallelism},
  author={Amittai Aviram and Shu-Chun Weng and Sen Hu and Bryan Ford},
  journal={Communications of the ACM},
  year={2010},
  volume={55},
  pages={111 - 119}
}
Deterministic execution offers many benefits for debugging, fault tolerance, and security. Current methods of executing parallel programs deterministically, however, often incur high costs, allow misbehaved software to defeat repeatability, and transform time-dependent races into input-or path-dependent races without eliminating them. We introduce a new parallel programming model addressing these issues, and use Determinator, a proof-of-concept OS, to demonstrate the model's practicality… 
Exploring Deterministic Shared Memory Programming Model
  • Yu Zhang, Wei Hu
  • Computer Science
    2012 13th International Conference on Parallel and Distributed Computing, Applications and Technologies
  • 2012
TLDR
Preliminary results suggest that DetSM atop the SPMC maybe realistic and useful, achieving better run-time than Dthreads for dedup, and better performance than the original Determinator for quick sort and merge sort.
Efficient, Practical Dynamic Program Analyses for Concurrency Correctness
TLDR
This thesis explores several efficient and practical dynamic program analyses that aim to overcome two key limitations in handling racy executions in weak memory models, advancing the state of the art for detecting, enforcing, and exposing issues related to concurrency correctness.
Making User-Level VMM for Deterministic Parallelism Nonblocking and Efficient
  • Yu Zhang, Jiange Zhang, Qiliang Zhang
  • Computer Science
    2016 17th International Conference on Parallel and Distributed Computing, Applications and Technologies (PDCAT)
  • 2016
TLDR
To reduce SPMC page fault overhead and suspend/resume overhead which severely degrade the performance of DLinux, the S PMC model with nonblocking test and direct read and write primitives is enhanced, and the implementation of upper programming abstractions are improved.
DOMP: Deterministic OpenMP
TLDR
A deterministic version of the well-established OpenMP parallel programming API is proposed: DOMP (Deterministic OpenMP), to provide both race-free determinism and programming expressiveness.
A virtual memory foundation for scalable deterministic parallelism
TLDR
A single-producer multiple- consumer (SPMC) virtual memory foundation for deterministic parallelism, which supports non-hierarchical synchronization without serialized thread scheduling, and DetMP, a deterministic userlevel message passing API modeled on MPI, illustrates one way to build convenient application-level parallel programming abstractions atop the SPMC foundation.
The Case For Merging Execution- and Language-level Determinism with MELD
TLDR
A simple qualifier-based type checker that ensures isolation for code written in a deterministic language and extends MELD to incorporate nondeterministic operations without compromising the determinism of the rest of the program.
Efficient deterministic multithreading without global barriers
TLDR
This paper implemented a DMT system based on an execution model called deterministic lazy release consistency (DLRC), which guarantees that programs execute deterministically even when they contain data races, and evaluated it using 16 parallel applications.
Determinism at Standard-Library Level in TM-Based Applications
TLDR
DeTrans-lib is presented, the first standard C library that provides deterministic execution of TM-based applications at application and standard-library level and avoids deadlocks by performing transaction serialization in deterministic order.
RCDC: a relaxed consistency deterministic computer
TLDR
RCDC is introduced, a deterministic multiprocessor architecture that takes advantage of relaxed memory orderings to provide high-performance deterministic execution with low hardware complexity and is evaluated using PARSEC benchmarks and shows that relaxing memory ordering leads to performance and scalability close to nondeterministic execution without requiring any form of speculation.
Efficient Deterministic Replay of Multithreaded Executions in a Managed Language Virtual Machine
TLDR
An approach for multithreaded record & replay based on tracking and reproducing shared-memory dependences accurately and efficiently is introduced and the performance of both recorded and replayed executions compares favorably with performance reported by prior work for competing record& replay approaches.
...
1
2
3
4
5
...

References

SHOWING 1-10 OF 92 REFERENCES
CoreDet: a compiler and runtime system for deterministic multithreaded execution
TLDR
This work develops a compiler and runtime system that runs arbitrary multithreaded C/C++ POSIX Threads programs deterministically but resorts to serialization rarely, for handling interthread communication and synchronization.
Deterministic Consistency: A Programming Model for Shared Memory Parallelism
TLDR
Deterministic consistency is proposed, a parallel programming model as easy to understand as the “parallel assignment” construct in sequential languages such as Perl and JavaScript, where concurrent threads always read their inputs before writing shared outputs.
Asserting and checking determinism for multithreaded programs
TLDR
This work proposes an assertion framework for specifying that regions of a parallel program behave deterministically despite non-deterministic thread interleaving, and allows programmers to write assertions involving pairs of program states arising from different parallel schedules.
SingleTrack: A Dynamic Determinism Checker for Multithreaded Programs
TLDR
This paper introduces a new non-interference specification for deterministically-parallel code, and presents a dynamic analysis to enforce it, and describes SingleTrack, a prototype implementation of this analysis.
A type and effect system for deterministic parallel Java
TLDR
It is demonstrated that a practical type and effect system can simplify parallel programming by guaranteeing deterministic semantics with modular, compile-time type checking even in a rich, concurrent object-oriented language such as Java.
Deterministic Process Groups in dOS
TLDR
The goal of this work is to provide fully deterministic execution of arbitrary, unmodified, multithreaded programs as an OS service and to make all sources of intentional nondeterminism, such as network I/O, be explicit and controllable.
Grace: safe multithreaded programming for C/C++
TLDR
Grace is presented, a software-only runtime system that eliminates concurrency errors for a class of multithreaded programs: those based on fork-join parallelism, and can achieve high scalability and performance while preventing concurrence errors.
Kendo: efficient deterministic multithreading in software
TLDR
Kendo is a new software-only system that provides deterministic multithreading of parallel applications that is easier to develop, debug, and test and can run on today's commodity hardware while incurring only a modest performance cost.
Workspace Consistency : A Programming Model for Shared Memory Parallelism
TLDR
Workspace consistency is a new synchronization and memory consistency model that offers a “naturally deterministic,” race-free programming model that can be adopted in both new or existing languages.
Scheduling-independent threads and exceptions in SHIM
TLDR
This paper proposes SHIM, the core of a deterministic concurrent language, meaning the behavior of a program is independent of the scheduling of concurrent operations, and provides the formal semantics of SHIM and a pre-liminary implementation.
...
1
2
3
4
5
...