scispace - formally typeset
Journal ArticleDOI

Safe nondeterminism in a deterministic-by-default parallel language

TLDR
A language together with a type and effect system that supports nondeterministic computations with a deterministic-by-default guarantee, which provides a static semantics, dynamic semantics, and a complete proof of soundness for the language, both with and without the barrier removal feature.
Abstract
A number of deterministic parallel programming models with strong safety guarantees are emerging, but similar support for nondeterministic algorithms, such as branch and bound search, remains an open question. We present a language together with a type and effect system that supports nondeterministic computations with a deterministic-by-default guarantee: nondeterminism must be explicitly requested via special parallel constructs (marked nd), and any deterministic construct that does not execute any nd construct has deterministic input-output behavior. Moreover, deterministic parallel constructs are always equivalent to a sequential composition of their constituent tasks, even if they enclose, or are enclosed by, nd constructs. Finally, in the execution of nd constructs, interference may occur only between pairs of accesses guarded by atomic statements, so there are no data races, either between atomic statements and unguarded accesses (strong isolation) or between pairs of unguarded accesses (stronger than strong isolation alone). We enforce the guarantees at compile time with modular checking using novel extensions to a previously described effect system. Our effect system extensions also enable the compiler to remove unnecessary transactional synchronization. We provide a static semantics, dynamic semantics, and a complete proof of soundness for the language, both with and without the barrier removal feature. An experimental evaluation shows that our language can achieve good scalability for realistic parallel algorithms, and that the barrier removal techniques provide significant performance gains.

read more

Citations
More filters
Proceedings ArticleDOI

DeNovo: Rethinking the Memory Hierarchy for Disciplined Parallelism

TL;DR: DeNovo is presented, a hardware architecture motivated by a disciplined shared-memory programming model that allows DeNovo to seamlessly integrate message passing-like interactions within a global address space for improved design complexity, performance, and efficiency.
Proceedings ArticleDOI

Internally deterministic parallel algorithms can be fast

TL;DR: The main contribution is to demonstrate that for this wide body of problems, there exist efficient internally deterministic algorithms, and moreover that these algorithms are natural to reason about and not complicated to code.
Proceedings ArticleDOI

Uniqueness and reference immutability for safe parallelism

TL;DR: This paper presents a type system to restrict the updates to memory to prevent these unintended side-effects of concurrent programming, and provides a novel combination of immutable and unique types that ensures safe parallelism and deterministic execution.
Proceedings ArticleDOI

Regent: a high-productivity programming language for HPC with logical regions

TL;DR: An optimizing compiler is presented that translates Regent programs into efficient implementations for Legion, an asynchronous task-based model and it is demonstrated that Regent achieves performance comparable to hand-tuned Legion.
Book ChapterDOI

Ownership types: a survey

TL;DR: This article surveys the various flavours of ownership types that have been developed over the years, along with the many applications and other developments.
References
More filters
Journal ArticleDOI

Cilk: An Efficient Multithreaded Runtime System

TL;DR: It is shown that on real and synthetic applications, the “work” and “critical-path length” of a Cilk computation can be used to model performance accurately, and it is proved that for the class of “fully strict” (well-structured) programs, the Cilk scheduler achieves space, time, and communication bounds all within a constant factor of optimal.
Proceedings ArticleDOI

Cilk: an efficient multithreaded runtime system

TL;DR: This paper shows that on real and synthetic applications, the “work” and “critical path” of a Cilk computation can be used to accurately model performance, and proves that for the class of “fully strict” (well-structured) programs, the Cilk scheduler achieves space, time and communication bounds all within a constant factor of optimal.
Journal ArticleDOI

The problem with threads

TL;DR: For concurrent programming to become mainstream, threads must be discarded as a programming model, and nondeterminism should be judiciously and carefully introduced where needed, and it should be explicit in programs.
Journal Article

Transactional locking II

TL;DR: This paper introduces the transactional locking II (TL2) algorithm, a software transactional memory (STM) algorithm based on a combination of commit-time locking and a novel global version-clock based validation technique, which is ten-fold faster than a single lock.
Book ChapterDOI

Transactional locking II

TL;DR: TL2 as mentioned in this paper is a software transactional memory (STM) algorithm based on a combination of commit-time locking and a novel global version-clock based validation technique, which is ten times faster than a single lock.
Related Papers (5)