Symbolic reasoning for automatic signal placement

Abstract

Explicit signaling between threads is a perennial cause of bugs in concurrent programs. While there are several runtime techniques to automatically notify threads upon the availability of some shared resource, such techniques are not widely-adopted due to their run-time overhead. This paper proposes a new solution based on static analysis for automatically generating a performant explicit-signal program from its corresponding implicit-signal implementation. The key idea is to generate verification conditions that allow us to minimize the number of required signals and unnecessary context switches, while guaranteeing semantic equivalence between the source and target programs. We have implemented our method in a tool called Expresso and evaluate it on challenging benchmarks from prior papers and open-source software. Expresso-generated code significantly outperforms past automatic signaling mechanisms (avg. 1.56x speedup) and closely matches the performance of hand-optimized explicit-signal code. CCS Concepts • Software and its engineering → Concurrent programming languages; Concurrent programming structures;

Synthesizing Fine-Grained Synchronization Protocols for Implicit Monitors (Extended Version)

“…A solution of the generated MaxSAT instance determines (a) which fragments should hold which locks, (b) which fields should be implemented using atomic types, and (c) which locks should be associated with which condition variables. Thus, together with the output of the signal placement technique [Ferles et al 2018], a model of the MaxSAT problem can be automatically translated into the target monitor implementation. For our running example, Cortado synthesizes precisely the implementation in Figure 1b given the implicit monitor of Figure 1a.…”

“…to implement the monitor in a way that respects the semantics of the implicit monitor. However, automatically deriving an efficient explicit monitor from its implicit specification is a challenging problem, and there have been several recent research efforts, including both run-time techniques like AutoSynch [Hung and Garg 2013] and compile-time tools like Expresso [Ferles et al 2018], to support implicit-synchronization monitors.…”

“…• Signal placement: First, we use an off-the-shelf technique [Ferles et al 2018] to infer a signaling regime which determines where to insert signaling operations on condition variables. While the output of this tool is sufficient to synthesize a single-lock implementation, it does not admit any additional concurrency wherein different threads can perform monitor operations simultaneously.…”

“…Given only the implicit monitor as input, Cortado synthesizes explicitsynchronization monitors that perform as well as, or better than, hand-written explicit implementations by expert developers. Compared to state-of-the-art automated tools for synthesizing explicit monitors [Ferles et al 2018], Cortado-synthesized monitors extract more concurrency and therefore perform much better (up to 39.1×) on heavily contended workloads.…”

“…Implicit monitors are much easier to program but typically not as efficient. To address this gap, there has been recent research on automatically synthesizing explicit-signal monitors from an implicit specification [Ferles et al 2018], but prior work does not exploit all paralellization opportunities due to the use of a single lock for the entire monitor. This paper presents a new technique for synthesizing fine-grained explicit-synchronization protocols from implicit monitors.…”