Provably Good and Practically Efficient Parallel Race Detection for Fork-Join Programs

Utterback, Robert; Agrawal, Kunal; Fineman, Jeremy T.; Lee, I-Ting Angelina

doi:10.1145/2935764.2935801

Cited by 37 publications

(29 citation statements)

References 37 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…Tools such as Cilkview [17] and Cilkprof [36] analyze the execution of a Cilk program and report on the program's parallel scalability, which reflects how much speedup the program might achieve using different numbers of parallel processors. Several other tools analyze parallel memory accesses in a task-parallel program that might exhibit nondeterministic behavior between runs of the program [5,13,15,32,33,41]. Like Cilkmem, the analyses performed by these tools do not depend on how the program was scheduled for a particular run, and instead provide insight into the behavior or performance of all parallel executions of the program.…”

Section: Related Theoretical Workmentioning

confidence: 99%

“…Many dynamic-analysis tools (e.g., [15,17,36,41,44]) have been developed that exploit structural properties of fork-join programs to analyze a program efficiently. Specifically, these tools often leverage the fact that the execution of a fork-join program can be modeled as a series-parallel computation DAG (directed acyclic graph) [7,15], where the edges model executed instructions, and the vertices model parallel-control dependencies.…”

Section: Introductionmentioning

confidence: 99%

See 1 more Smart Citation

Cilkmem: Algorithms for Analyzing the Memory High-Water Mark of Fork-Join Parallel Programs

Kaler¹,

Kuszmaul²,

Schardl³

et al. 2020

Symposium on Algorithmic Principles of Computer Systems

View full text Add to dashboard Cite

Software engineers designing recursive fork-join programs destined to run on massively parallel computing systems must be cognizant of how their program's memory requirements scale in a many-processor execution. Although tools exist for measuring memory usage during one particular execution of a parallel program, such tools cannot bound the worst-case memory usage over all possible parallel executions. This paper introduces Cilkmem, a tool that analyzes the execution of a deterministic Cilk program to determine its p-processor memory high-water mark (MHWM), which is the worst-case memory usage of the program over all possible p-processor executions. Cilkmem employs two new algorithms for computing the p-processor MHWM. The first algorithm calculates the exact p-processor MHWM in O(T1·p) time, where T1 is the total work of the program. The second algorithm solves, in O(T1) time, the approximate threshold problem, which asks, for a given memory threshold M, whether the p-processor MHWM exceeds M/2 or whether it is guaranteed to be less than M. Both algorithms are memory efficient, requiring O(p·D) and O(D) space, respectively, where D is the maximum call-stack depth of the program's execution on a single thread.Our empirical studies show that Cilkmem generally exhibits low overheads. Across ten application benchmarks from the Cilkbench suite, the exact algorithm incurs a geometric-mean multiplicative overhead of 1.54 for p=128, whereas the approximationthreshold algorithm incurs an overhead of 1.36 independent of p. In addition, we use Cilkmem to reveal and diagnose a previously unknown issue in a large image-alignment program contributing to unexpectedly high memory usage under parallel executions.

show abstract

Section: Related Theoretical Workmentioning

confidence: 99%

Section: Introductionmentioning

confidence: 99%

Cilkmem: Algorithms for Analyzing the Memory High-Water Mark of Fork-Join Parallel Programs

Kaler¹,

Kuszmaul²,

Schardl³

et al. 2020

Symposium on Algorithmic Principles of Computer Systems

View full text Add to dashboard Cite

show abstract

“…Prior works show that one can race detect computations that are SP dags efficiently by exploiting the nice structural properties. In particular, the reachability data structure can be maintained and queried with no asymptotic overhead for both serial [6,21] and parallel executions [56]. Moreover, the access history needs to store only a constant number of accessors per memory location to correctly race detect for such computations [19,20,38].…”

Section: Introductionmentioning

confidence: 99%

Efficient race detection with futures

Utterback

Agrawal

Fineman

et al. 2019

Proceedings of the 24th Symposium on Principles and Practice of Parallel Programming

Self Cite

View full text Add to dashboard Cite

This paper addresses the problem of provably efficient and practically good on-the-fly determinacy race detection in task parallel programs that use futures. Prior works on determinacy race detection have mostly focused on either task parallel programs that follow a series-parallel dependence structure or ones with unrestricted use of futures that generate arbitrary dependences. In this work, we consider a restricted use of futures and show that we can detect races more efficiently than with general use of futures.Specifically, we present two algorithms: MultiBags and MultiBags+. MultiBags targets programs that use futures in a restricted fashion and runs in time O(T 1 α(m, n)), where T 1 is the sequential running time of the program, α is the inverse Ackermann's function, m is the total number of memory accesses, n is the dynamic count of places at which parallelism is created. Since α is a very slowly growing function (upper bounded by 4 for all practical purposes), it can be treated as a close-to-constant overhead. MultiBags+ is an extension of MultiBags that target programs with general use of futures. It runs in time O((T 1 + k 2 )α(m, n)) where T 1 , α, m and n are defined as before, and k is the number of future operations in the computation. We implemented both algorithms and empirically demonstrate their efficiency.

show abstract

“…Over the years, researchers have proposed several algorithms [6,20,21,36,41,42,48] for performing race detection "on the fly" as the program executes. These race detectors perform a single execution of the program, augmented with a race-detection algorithm, and they generally provide a fairly strong correctness guarantee -for the given input, the race detector reports a race if and only if the program contains a race on that input.…”

Section: Introductionmentioning

confidence: 99%

“…Restricting the race detector to SP dags greatly simplifies the reachability data structure, giving rise to extremely efficient race detectors with only a constant-factor overhead for both sequential [6,21] and parallel executions [48] of the program being tested.…”

Section: Introductionmentioning

confidence: 99%

Race Detection and Reachability in Nearly Series-Parallel DAGs

Agrawal

Devietti

Fineman

et al. 2018

Proceedings of the Twenty-Ninth Annual ACM-SIAM Symposium on Discrete Algorithms

Self Cite

View full text Add to dashboard Cite

A program is said to have a determinacy race if logically parallel parts of a program access the same memory location and one of the accesses is a write. These races are generally bugs in the program since they lead to non-deterministic program behavior -different schedules of the program can lead to different results. Most prior work on detecting these races focuses on a subclass of programs with series-parallel or nested parallelism.This paper presents a race-detection algorithm for detecting races in a more general class of programs, namely programs that include arbitrary ordering constraints in additional to the series-parallel constructs. The algorithm performs a serial execution of the program, augmented to detect races, in O(T 1 + k 2 ) time, where T 1 is the sequential running time of the original program and k is the number of non series-parallel constraints.The main technical novelty of this paper is a new data structure, R-Sketch, for answering reachability queries in nearly series-parallel (SP) directed acyclic graphs (DAGs). Given as input a graph comprising an n-node series parallel graph and k additional non-SP edges, the total construction time of the data structure is O(n + k 2 ), and each reachability query can be answered in O(1) time. The data structure is traversally incremental, meaning that it supports the insertion of nodes/edges, but only as they are discovered through a graph traversal.

show abstract

Provably Good and Practically Efficient Parallel Race Detection for Fork-Join Programs

Cited by 37 publications

References 37 publications

Cilkmem: Algorithms for Analyzing the Memory High-Water Mark of Fork-Join Parallel Programs

Cilkmem: Algorithms for Analyzing the Memory High-Water Mark of Fork-Join Parallel Programs

Efficient race detection with futures

Race Detection and Reachability in Nearly Series-Parallel DAGs

Contact Info

Product

Resources

About