857 research outputs found
Soundness of the Quasi-Synchronous Abstraction
We study the link between real-time quasi-periodic architectures where computing units execute 'almost periodically' and the discrete-time quasi-synchronous abstraction that P. Caspi proposed for analyzing them. The simplicity of the abstraction is appealing: the only events are node activations; logical steps account for transmission delays; and no node may be activated more than twice between two successive activations of any other. The motivation is to verify properties of real-time distributed systems in the simpler discrete model.By formalizing the relation between quasi-periodic architectures and the quasi-synchronous abstraction using L. Lamport's happened before relation, we show that the abstraction is sound for systems of two nodes. After showing that the abstraction is not sound for general systems with three or more nodes, we give necessary and sufficient restrictions on communication topologies to recover soundness.Lâabstraction quasi-synchrone proposeÌe par P. Caspi permet de faciliter lâanalyse de systeÌmes dits quasi-peÌriodiques ouÌ des uniteÌs de calcul sâexeÌcutent de manieÌre presque peÌriodique. La simpliciteÌ de cette abstraction est prometteuse: les seuls eÌveÌnements consideÌreÌs sont les activations des nĆuds; les pas de temps logique repreÌsentent les deÌlais de transmission; un nĆud ne peut pas eÌtre activeÌ plus de deux fois entre deux activations dâun autre nĆud. Cette abstraction permet de veÌrifier des proprieÌteÌs dâun systeÌme distribueÌ temps-reÌel en utilisant un modeÌle discret plus simple.Dans cet article nous formalisons la relation entre les architectures quasi-peÌriodiques et lâabstraction quasi-synchrone en utilisant la relation happened before introduite par L. Lam- port. Nous montrons que lâabstraction est valide pour des systeÌmes composeÌs de deux nĆuds, mais que ce nâest en geÌneÌral pas le cas pour des systeÌmes de trois nĆuds ou plus. Nous donnons ensuite les restrictions neÌcessaires et suffisantes sur les topologies de communication pour assurer la validiteÌ de cette abstraction
Soundness of the Quasi-Synchronous Abstraction
International audienceMany critical real-time embedded systems are implemented as a set of processes that execute periodically with bounded jitter and communicate with bounded transmission delay. The quasi-synchronous abstraction was introduced by P. Caspi for model-checking the safety properties of applications running on such systems. The simplicity of the abstraction is appealing: the only events are process activations; logical steps account for transmission delays; and no process may be activated more than twice between two successive activations of any other.We formalize the relation between the real-time model and the quasi-synchronous abstraction by introducing the notion of a unitary discretisation. Even though the abstraction has been applied several times in the literature, we show, surprisingly, that it is not sound for general systems of more than two processes. Our central result is to propose necessary and sufficient conditions on both communication topologies and timing parameters to recover soundness
The design and implementation of a verification technique for GPU Kernels
We present a technique for the formal verification of GPU kernels, addressing two classes of correctness properties: data races and barrier divergence. Our approach is founded on a novel formal operational semantics for GPU kernels termed synchronous, delayed visibility (SDV) semantics, which captures the execution of a GPU kernel by multiple groups of threads. The SDV semantics provides operational definitions for barrier divergence and for both inter- and intra-group data races. We build on the semantics to develop a method for reducing the task of verifying a massively parallel GPU kernel to that of verifying a sequential program. This completely avoids the need to reason about thread interleavings, and allows existing techniques for sequential program verification to be leveraged. We describe an efficient encoding of data race detection and propose a method for automatically inferring the loop invariants that are required for verification. We have implemented these techniques as a practical verification tool, GPUVerify, that can be applied directly to OpenCL and CUDA source code. We evaluate GPUVerify with respect to a set of 162 kernels drawn from public and commercial sources. Our evaluation demonstrates that GPUVerify is capable of efficient, automatic verification of a large number of real-world kernels
Denotational Fixed-Point Semantics for Constructive Scheduling of Synchronous Concurrency
The synchronous model of concurrent computation (SMoCC) is well established for programming languages in the domain of safety-critical reactive and embedded systems. Translated into mainstream C/Java programming, the SMoCC corresponds to a cyclic execution model in which concurrent threads are synchronised on a logical clock that cuts system computation into a sequence of macro-steps. A causality analysis verifies the existence of a schedule on memory accesses to ensure each macro-step is deadlock-free and determinate. We introduce an abstract semantic domain I(D, P) and an associated denotational fixed point semantics for reasoning about concurrent and sequential variable accesses within a synchronous cycle-based model of computation. We use this domain for a new and extended behavioural definition of Berryâs causality analysis in terms of approximation intervals. The domain I(D, P) extends the domain I(D) from our previous work and fixes a mistake in the treatment of initialisations. Based on this fixed point semantics the notion of Input Berry-constructiveness (IBC) for synchronous programs is proposed. This new IBC class lies properly between strong (SBC) and normal Berry-constructiveness (BC) defined in previous work. SBC and BC are two ways to interpret the standard constructive semantics of synchronous programming, as exemplified by imperative SMoCC languages such as Esterel or Quartz. SBC is often too restrictive as it requires all variables to be initialised by the program. BC can be too permissive because it initialises all variables to a fixed value, by default. Where the initialisation happens through the memory, e.g., when carrying values from one synchronous tick to the next, then IBC is more appropriate. IBC links two levels of execution, the macro-step level and the micro-step level. We prove that the denotational fixed point analysis for IBC, and hence Berryâs causality analysis, is sound with respect to operational micro-level scheduling. The denotational model can thus be viewed as a compositional presentation of a synchronous scheduling strategy that ensures reactiveness and determinacy for imperative concurrent programming
Recommended from our members
Modular and Safe Event-Driven Programming
Asynchronous event-driven systems are ubiquitous across domains such as device drivers, distributed systems, and robotics. These systems are notoriously hard to get right as the programmer needs to reason about numerous control paths resulting from the complex interleaving of events (or messages) and failures. Unsurprisingly, it is easy to introduce subtle errors while attempting to fill in gaps between high-level system specifications and their concrete implementations.This dissertation proposes new methods for programming safe event-driven asynchronous systems.In the first part of the thesis, we present ModP, a modular programming framework for compositional programming and testing of event-driven asynchronous systems.The ModP module system supports a novel theory of compositional refinement for assume-guarantee reasoning of dynamic event-driven asynchronous systems. We build a complex distributed systems software stack using ModP.Our results demonstrate that compositional reasoning can help scale model-checking (both explicit and symbolic) to large distributed systems.ModP is transforming the way asynchronous software is built at Microsoft and Amazon Web Services (AWS). Microsoft uses ModP for implementing safe device drivers and other software in the Windows kernel.AWS uses ModP for compositional model checking of complex distributed systems. While ModP simplifies analysis of such systems, the state space of industrial-scale systems remains extremely large.In the second part of this thesis, we present scalable verification and systematic testing approaches to further mitigate this state-space explosion problem.First, we introduce the concept of a delaying explorer to perform prioritized exploration of the behaviors of an asynchronous reactive program. A delaying explorer stratifies the search space using a custom strategy (tailored towards finding bugs faster), and a delay operation that allows deviation from that strategy. We show that prioritized search with a delaying explorer performs significantly better than existing approaches for finding bugs in asynchronous programs.Next, we consider the challenge of verifying time-synchronized systems; these are almost-synchronous systems as they are neither completely asynchronous nor synchronous.We introduce approximate synchrony, a sound and tunable abstraction for verification of almost-synchronous systems. We show how approximate synchrony can be used for verification of both time-synchronization protocols and applications running on top of them.Moreover, we show how approximate synchrony also provides a useful strategy to guide state-space exploration during model-checking.Using approximate synchrony and implementing it as a delaying explorer, we were able to verify the correctness of the IEEE 1588 distributed time-synchronization protocol and, in the process, uncovered a bug in the protocol that was well appreciated by the standards committee.In the final part of this thesis, we consider the challenge of programming a special class of event-driven asynchronous systems -- safe autonomous robotics systems.Our approach towards achieving assured autonomy for robotics systems consists of two parts: (1) a high-level programming language for implementing and validating the reactive robotics software stack; and (2) an integrated runtime assurance system to ensure that the assumptions used during design-time validation of the high-level software hold at runtime.Combining high-level programming language and model-checking with runtime assurance helps us bridge the gap between design-time software validation that makes assumptions about the untrusted components (e.g., low-level controllers), and the physical world, and the actual execution of the software on a real robotic platform in the physical world. We implemented our approach as DRONA, a programming framework for building safe robotics systems.We used DRONA for building a distributed mobile robotics system and deployed it on real drone platforms. Our results demonstrate that DRONA (with the runtime-assurance capabilities) enables programmers to build an autonomous robotics software stack with formal safety guarantees.To summarize, this thesis contributes new theory and tools to the areas of programming languages, verification, systematic testing, and runtime assurance for programming safe asynchronous event-driven across the domains of fault-tolerant distributed systems and safe autonomous robotics systems
Comparing Process Calculi Using Encodings
Encodings or the proof of their absence are the main way to compare process
calculi. To analyse the quality of encodings and to rule out trivial or
meaningless encodings, they are augmented with encodability criteria. There
exists a bunch of different criteria and different variants of criteria in
order to reason in different settings. This leads to incomparable results.
Moreover, it is not always clear whether the criteria used to obtain a result
in a particular setting do indeed fit to this setting. This paper provides a
short survey on often used encodability criteria, general frameworks that try
to provide a unified notion of the quality of an encoding, and methods to
analyse and compare encodability criteria.Comment: In Proceedings EXPRESS/SOS 2019, arXiv:1908.0821
Improved Algorithms for Parity and Streett objectives
The computation of the winning set for parity objectives and for Streett
objectives in graphs as well as in game graphs are central problems in
computer-aided verification, with application to the verification of closed
systems with strong fairness conditions, the verification of open systems,
checking interface compatibility, well-formedness of specifications, and the
synthesis of reactive systems. We show how to compute the winning set on
vertices for (1) parity-3 (aka one-pair Streett) objectives in game graphs in
time and for (2) k-pair Streett objectives in graphs in time
. For both problems this gives faster algorithms for dense
graphs and represents the first improvement in asymptotic running time in 15
years
- âŠ