The tasks with effects model for safe concurrency

Heumann, Stephen; Adve, Vikram; Wang, Shengjie

doi:10.1145/2442516.2442540

Cited by 21 publications

(7 citation statements)

References 49 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…Although some have argued that hardware coherence is here to stay [Martin et al 2012] and continue to work on even more complex extensions [Aisopos and Peh 2011], others are proposing systems that use software-directed coherence [Borkar 2011;Choi et al 2011;Howard et al 2010;IntelSCC 2009;Kelm et al 2009]. This article adds objective results from a concrete case study to this debate.…”

Section: Resultsmentioning

confidence: 99%

“…There is an ongoing debate about whether we have tamed the complexity of hardware coherence protocols or whether we should abandon them and replace them with their software counterparts. While some predict that hardware cache coherence is here to stay [Martin et al 2012] and continue to extend such protocols in newer, more complex ways [Aisopos and Peh 2011;Zhao et al 2013], others propose and build systems with software-directed coherence [Borkar 2011;Choi et al 2011;Howard et al 2010;IntelSCC 2009;Kelm et al 2009]. Our work offers an objective case study to show that hardware coherence remains quite complex and that a hardware-software co-design approach can provide a simpler alternative.…”

Section: Related Workmentioning

confidence: 98%

“…DPJ and DeNovo are ongoing projects that continue to incorporate support for increasingly wider classes of programs Heumann et al 2013;Sung et al 2013Sung et al , 2014. We discuss this ongoing work and implications for general codes in Section 5.…”

Section: Denovomentioning

confidence: 99%

See 2 more Smart Citations

Revisiting the Complexity of Hardware Cache Coherence and Some Implications

Komuravelli

Adve

Chou

2014

ACM Trans. Archit. Code Optim.

View full text Add to dashboard Cite

Cache coherence is an integral part of shared-memory systems but is also widely considered to be one of the most complex parts of such systems. Much prior work has addressed this complexity and the verification techniques to prove the correctness of hardware coherence. Given the new multicore era with increasing number of cores, there is a renewed debate about whether the complexity of hardware coherence has been tamed or whether it should be abandoned in favor of software coherence. This article revisits the complexity of hardware cache coherence by verifying a publicly available, state-of-the-art implementation of the widely used MESI protocol, using the Murϕ model checking tool. To our surprise, we found six bugs in this protocol, most of which were hard to analyze and took several days to fix. To compare the complexity, we also verified the recently proposed DeNovo protocol, which exploits disciplined software programming models. We found three relatively easy to fix bugs in this less mature protocol. After fixing these bugs, our verification experiments showed that, compared to DeNovo, MESI had 15X more reachable states leading to a 20X increase in verification (model checking) time. Although we were eventually successful in verifying the protocols, the tool required making several simplifying assumptions (e.g., two cores, one address). Our results have several implications: (1) they indicate that hardware coherence protocols remain complex;(2) they reinforce the need for protocol designers to embrace formal verification tools to demonstrate correctness of new protocols and extensions; (3) they reinforce the need for formal verification tools that are both scalable and usable by non-expert; and (4) they show that a system based on hardware-software co-design can offer a simpler approach for cache coherence, thus reducing the overall verification effort and allowing verification of more detailed models and protocol extensions that are otherwise limited by computing resources.

show abstract

Section: Resultsmentioning

confidence: 99%

Section: Related Workmentioning

confidence: 98%

See 1 more Smart Citation

Revisiting the Complexity of Hardware Cache Coherence and Some Implications

Komuravelli

Adve

Chou

2014

ACM Trans. Archit. Code Optim.

View full text Add to dashboard Cite

show abstract

“…In principle, task independence can be guaranteed by the type system [4] or by explicit assignment of "ownership" [15], but we believe the resulting complexity to be inappropriate for scriptinghence the desire for dynamic data race detection. Similarly, both false negatives and false positives may be acceptable when searching for suspected bugs in a complex system, but for DPR we aim to transparently confirm the absence of races; for this task we take as given that the detector must be precise: it should identify all (and only) those conflicting operations that are logically concurrent (unordered by happens-before) in a given program execution-even if those operations occur in the same worker thread.…”

Section: Log-based Data Race Detectionmentioning

confidence: 99%

Dynamic enforcement of determinism in a parallel scripting language

Lü

Scott

2014

Proceedings of the 35th ACM SIGPLAN Conference on Programming Language Design and Implementation

View full text Add to dashboard Cite

Determinism is an appealing property for parallel programs, as it simplifies understanding, reasoning and debugging. It is particularly appealing in dynamic (scripting) languages, where ease of programming is a dominant design goal. Some existing parallel languages use the type system to enforce determinism statically, but this is not generally practical for dynamic languages. In this paper, we describe how determinism can be obtained-and dynamically enforced/verified-for appropriate extensions to a parallel scripting language. Specifically, we introduce the constructs of Determinis-tic Parallel Ruby (DPR), together with a run-time system (TARDIS) that verifies properties required for determinism, including correct usage of reductions and commutative operators, and the mutual independence (data-race freedom) of concurrent tasks. Experimental results confirm that DPR can provide scalable performance on mul-ticore machines and that the overhead of TARDIS is low enough for practical testing. In particular, TARDIS significantly outperforms alternative data-race detectors with comparable functionality. We conclude with a discussion of future directions in the dynamic enforcement of determinism.

show abstract

“…K's ability to express truly concurrent computations has been used in researching safe models for concurrency [20], synchronization of agent systems [21], models for P-Systems [22], [23], and for the x86-TSO relaxed memory model [24]. K has been used for designing type checkers/inferencers [25], for model checking executions with predicate abstraction [26], [27] and heap awareness [28], for symbolic execution [29]- [31], computing worst case execution times [32], [33], studying program equivalence [34], and runtime verification [24], [35].…”

Section: Current Progress Applications Further Readingmentioning

confidence: 99%

Specifying Languages and Verifying Programs with K

Roşu

2013

2013 15th International Symposium on Symbolic and Numeric Algorithms for Scientific Computing

View full text Add to dashboard Cite

K is a rewrite-based executable semantic framework for defining languages. The K framework is designed to allow implementing a variety of generic tools that can be used with any language defined in K, such as parsers, interpreters, symbolic execution engines, semantic debuggers, test-case generators, state-space explorers, model checkers, and even deductive program verifiers. The latter are based on matching logic for expressing static properties, and on reachability logic for expressing dynamic properties. Several large languages have been already defined or are being defined in K, including C, Java, Python, Javascript, and LLVM.

show abstract

The tasks with effects model for safe concurrency

Cited by 21 publications

References 49 publications

Revisiting the Complexity of Hardware Cache Coherence and Some Implications

Revisiting the Complexity of Hardware Cache Coherence and Some Implications

Dynamic enforcement of determinism in a parallel scripting language

Specifying Languages and Verifying Programs with K

Contact Info

Product

Resources

About