Promising 2.0: global optimizations in relaxed memory concurrency

Lee, Sung-Hwan; Cho, Minki; Podkopaev, Anton; Chakraborty, Soham; Hur, Chung-Kil; Lahav, Ori; Vafeiadis, Viktor

doi:10.1145/3385412.3386010

Cited by 35 publications

(26 citation statements)

References 13 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…Both have a pair of accesses (o r , o w ∈ {rel, acq, rlx}) to the same location -a read followed by a write. Following [22], FADD(x, v) stores the value of x into a register $r, and adds v to x, while CAS(x, v 1 , v 2 ) compares an expected value v 1 to the value in x, and if the values are same, sets the value of x to v 2 . The old value of x is then stored in $r.…”

Section: Preliminariesmentioning

confidence: 99%

“…In this section, we recall the promising semantics [22]. We present here PS 2.0 with three memory accesses, relaxed, release writes (rel) and acquire reads (acq).…”

Section: The Promising Semanticsmentioning

confidence: 99%

“…Consistency. According to Lee et al [22], there is one final requirement on machine states called consistency, which roughly states that, from every encountered machine state, all the messages promised by a process p can be certified (i.e., made fulfillable) by executing p on its own from a certain future memory (called capped memory), i.e., extension of the memory with additional reservation. Before defining consistency, we need to introduce capped memory.…”

Section: The Promising Semanticsmentioning

confidence: 99%

“…To address these concerns, Lee et al developed a new version of the promising semantics, PS 2.0 [22] PS 2.0 simplifies the consistency check and instead of checking the promise fulfilment from all future memories, PS 2.0 checks for promise fulfilment only from a specially crafted extension of the current memory called capped memory. PS 2.0 also introduces the notion of reservations, which allows a process to secure a timestamp interval in order to perform a future atomic read-modify-write instruction.…”

Section: Introductionmentioning

confidence: 99%

See 3 more Smart Citations

The Decidability of Verification under PS 2.0

Abdulla

Atig

Godbole

et al. 2021

Programming Languages and Systems

Self Cite

View full text Add to dashboard Cite

We consider the reachability problem for finite-state multi-threaded programs under the promising semantics () of Lee et al., which captures most common program transformations. Since reachability is already known to be undecidable in the fragment of with only release-acquire accesses (-), we consider the fragment with only relaxed accesses and promises (). We show that reachability under is undecidable in general and that it becomes decidable, albeit non-primitive recursive, if we bound the number of promises.Given these results, we consider a bounded version of the reachability problem. To this end, we bound both the number of promises and of “view-switches”, i.e., the number of times the processes may switch their local views of the global memory. We provide a code-to-code translation from an input program under (with relaxed and release-acquire memory accesses along with promises) to a program under SC, thereby reducing the bounded reachability problem under to the bounded context-switching problem under SC. We have implemented a tool and tested it on a set of benchmarks, demonstrating that typical bugs in programs can be found with a small bound.

show abstract

Section: Preliminariesmentioning

confidence: 99%

“…In this section, we recall the promising semantics [22]. We present here PS 2.0 with three memory accesses, relaxed, release writes (rel) and acquire reads (acq).…”

Section: The Promising Semanticsmentioning

confidence: 99%

Section: The Promising Semanticsmentioning

confidence: 99%

Section: Introductionmentioning

confidence: 99%

See 2 more Smart Citations

The Decidability of Verification under PS 2.0

Abdulla

Atig

Godbole

et al. 2021

Programming Languages and Systems

Self Cite

View full text Add to dashboard Cite

show abstract

“…For various hardware memory models, operational semantics are also used [34]- [36]. Some recent works about the "promising" semantics [36], [37] propose a relatively more economical way to eliminate the "thin-air-read" problem without sacrificing too many possible optimisations. Its usefulness has been demonstrated in the formalisation of the ARMv8 memory model [38].…”

Section: Related Workmentioning

confidence: 99%

A Program Logic for Reasoning About C11 Programs With Release-Sequences

Qin

2020

IEEE Access

View full text Add to dashboard Cite

With the popularity of weak/relaxed memory models widely used in modern hardware architectures, the C11 standard introduced a language level weak memory model, A.K.A the C11 memory model, that allows C/C++ programs to exploit the optimisation provided by the hardware platform in memory ordering and gain benefits in efficiency. On the other hand, with the weakened memory ordering allowed, more program behaviours are introduced, among which some are counterintuitive and make it even more challenging for programmers to understand or to formally reason about C11 multithread programs. To support the formal verification of the C11 weak memory programs, several program logics, e.g. RSL, GPS, FSL, and GPS+, have been developed during the last few years. However, due to the complexity of the weakened memory model, some intricate C11 features still cannot be handled in these logics. A notable example is the lack of supporting to the reasoning about a highly flexible C11 synchronisation mechanism, the release-sequence. Recently, the FSL++ logic proposed by Doko and Vafeiadis moves one step forward to address this problem, but FSL++ only considers the scenarios with atomic update operations in a release-sequence. In this article, we propose a new program logic, GPS++, that supports the reasoning about C11 programs with fully featured release-sequences. We also introduce fractional read permissions to GPS++, which are essential to the reasoning about a large number of real-world concurrent programs. GPS++ is a successor of our previous program logic GPS+, but it comes with much finer control over the resource transmission with the newly introduced restricted-shareable assertions and an enhanced protocol system. A more sophisticated resource model is devised to support the soundness proof of our new program logic. We also demonstrate GPS++ in action by verifying C11 programs with release-sequences that could not be handled by existing program logics.

show abstract

High‐coverage metamorphic testing of concurrency support in C compilers

Windsor

Donaldson

Wickerson

2022

Software Testing Verif & Rel

View full text Add to dashboard Cite

SummaryWe present a technique and automated toolbox for randomized testing of C compilers. Unlike prior compiler‐testing approaches, we generate concurrent test cases in which threads communicate using fine‐grained atomic operations, and we study actual compiler implementations rather than abstract mappings. Our approach is (1) to generate test cases with precise oracles directly from an axiomatization of the C concurrency model; (2) to apply metamorphic fuzzing to each test case, aiming to amplify the coverage they are likely to achieve on compiler codebases; and (3) to execute each fuzzed test case extensively on a range of real machines. Our tool, C4, benefits compiler developers in two ways. First, test cases generated by C4 can achieve line coverage of parts of the LLVM C compiler that are reached by neither the LLVM test suite nor an existing (sequential) C fuzzer. This information can be used to guide further development of the LLVM test suite and can also shed light on where and how concurrency‐related compiler optimizations are implemented. Second, C4 can be used to gain confidence that a compiler implements concurrency correctly. As evidence of this, we show that C4 achieves high strong mutation coverage with respect to a set of concurrency‐related mutants derived from a recent version of LLVM and that it can find historic concurrency‐related bugs in GCC. As a by‐product of concurrency‐focused testing, C4 also revealed two previously unknown sequential compiler bugs in recent versions of GCC and the IBM XL compiler.

show abstract

Promising 2.0: global optimizations in relaxed memory concurrency

Cited by 35 publications

References 13 publications

The Decidability of Verification under PS 2.0

The Decidability of Verification under PS 2.0

A Program Logic for Reasoning About C11 Programs With Release-Sequences

High‐coverage metamorphic testing of concurrency support in C compilers

Contact Info

Product

Resources

About