Verifying Robustness of Event-Driven Asynchronous Programs Against Concurrency

Abstract

We define a correctness criterion, called robustness against concurrency, for a class of event-driven asynchronous programs that are at the basis of modern UI frameworks in Android, iOS, and Javascript. A program is robust when all possible behaviors admitted by the program under arbitrary procedure and event interleavings are admitted even if asynchronous procedures (respectively, events) are assumed to execute serially, one after the other, accessing shared memory in isolation. We characterize robustness as a conjunction of two correctness criteria: event-serializability (i.e., events can be seen as atomic) and event-determinism (executions within each event are insensitive to the interleavings between concurrent tasks dynamically spawned by the event). Then, we provide efficient algorithms for checking these two criteria based on polynomial reductions to reachability problems in sequential programs. This result is surprising because it allows to avoid explicit handling of all concurrent executions in the analysis, which leads to an important gain in complexity. We demonstrate via case studies on Android apps that the typical mistakes programmers make are captured as robustness violations, and that violations can be detected efficiently using our approach.

On the Completeness of Verifying Message Passing Programs Under Bounded Asynchrony

“…The approach we adopt in this work is related to robustness checking [5,8]. The general paradigm is to decide that a program has the same behaviors under two semantics, one being weaker than the other, by showing a polynomial reduction to a state reachability problem under the stronger semantics, i.e., by avoiding the consideration of the weak semantics that is in general far more complex to deal with than the strong one.…”

“…For instance, in the case of our work, the class of message passing programs with unbounded FIFO channels is Turing powerful, but still, surprisingly, k-synchronizability of these programs is decidable and PSPACE-complete (i.e., as hard as state reachability in programs with bounded channels). However, the results in [5,8] can not be applied to solve the question of synchronizability we consider in this paper; in each of [5], [8], and our work, the considered classes of programs and their strong/weak semantics are very different (shared-memory concurrent programs running over a relaxed memory model in [5], and shared-memory concurrent programs with dynamic asynchronous process creation in [8]), and the corresponding robustness checking algorithms are based on distinct concepts and techniques. As a proof of concept, we have applied our procedure for checking ksynchronizability to a set of examples extracted from the distribution of the P language 6 .…”

Model‐based design of IoT systems with the BIP component framework

“…As future work, it is worth to consider the extension of our domain specific language toward supporting message queue telemetry transport clients and servers, as in the work of Patel and Cassou . To this respect, a publish‐subscribe model has to be integrated, such as the BIP model described in the wok of Bliudze et al An interesting direction is the detection of compute‐bound event loops and the analysis of their robustness, which is defined as conjunction of two correctness properties, ie, event serializability and event determinism (executions within each event are insensitive to the interleavings between concurrent tasks dynamically spawned by the event). Finally, we intend to provide support for additional nonfunctional requirements related to energy consumption() and security aspects.…”

Smali+: An Operational Semantics for Low-Level Code Generated from Reverse Engineering Android Applications

“…Multi-threading programming semantics in applications have lately drawn increasing attention. Some combine it with event handling [23][24][25], others consider the main API methods relating to it [26]. In [24], Kanade proposes a semantic of a combined concurrency model of threads and events.…”