Race Detection and Reachability in Nearly Series-Parallel DAGs

Abstract

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.

Efficient race detection with futures

“…Multi-Bags focuses on structured use of futures and incurs very little overhead -a multiplicative overhead in the inverse Ackermann's function, which is upper bounded by 4 for all practical purposes [16]. MultiBags+ is an extension of Multi-Bags, which handles general use of futures and has overhead comparable to the state-of-the-art theoretical algorithm [1] (i.e., multiplicative overhead of the inverse Ackermann's function) and can be implemented efficiently. We have implemented both algorithms and empirically evaluated them.…”

“…Again, since the inverse Ackermann's function is slow growing function, the running time is O(T 1 +k 2 ) for all intents and purposes. Compared to the state-of-the-art proposed by Agrawal et al [1], Multi-Bags+'s running time has a multiplicative overhead of the inverse Ackermann's function. Unlike the state-of-the-art, however, MultiBags+'s relative simplicity allows it to be implemented efficiently in practice.…”

“…Unlike the state-of-the-art, however, MultiBags+'s relative simplicity allows it to be implemented efficiently in practice. We provide a more detailed comparison between our MultiBags+ algorithm and the state-of-the-art [1] in Section 5. • FutureRD: We have built a prototype race detector called FutureRD based on MultiBags and MultiBags+.…”

“…In particular, for the purposes of this paper, function F can spawn off a child function G, invoking G without suspending the continuation of F , thereby creating parallelism; similarly, F can invoke sync, joining together all previously spawned children within the functional scope. 1 We assume create_fut and get_fut primitives are used to create and join futures, respectively. Like spawn, one can precede a function call to G in F with create_fut, which allows G to execute without suspending F .…”

“…That is, the running time of the race detection algorithm increases quadratically with the total number of futures used in the program. More recently, Agrawal et al [1] present a sequential algorithm to perform race detection on SP dags with k added non-series-parallel edges in O(T 1 + k 2 ) time, which is the best known running time. The algorithm is difficult to implement however, since it requires storing all the nodes in the computation graph and traversing the graph during execution to update labels.…”