Verification Techniques for Concurrent Systems

Author(s):  
Eric Y. T. Juan ◽  
Jeffrey J. P. Tsai
10.29007/7lrd ◽  
2018 ◽  
Author(s):  
Ian Cassar ◽  
Adrian Francalanza ◽  
Duncan Attard ◽  
Luca Aceto ◽  
Anna Ingolfsdottir

Ensuring formal correctness for actor-based, concurrent systems is a difficult task, pri- marily because exhaustive, static analysis verification techniques such as model checking quickly run into state-explosion problems. Runtime monitoring techniques such as Run- time Verification and Adaptation circumvent this limitation by verifying the correctness of a program by dynamically analysing its executions. This paper gives an overview of a suite of monitoring tools available for verifying and adapting actor-based Erlang programs.


Author(s):  
NOURA BOUDIAF ◽  
FARID MOKHATI ◽  
MOURAD BADRI

Model Checking based verification techniques represent an important issue in the field of concurrent systems quality assurance. The lack of formal semantics in the existing formalisms describing multi-agents models combined with multi-agents systems complexity are sources of several problems during their development process. The Maude language, based on rewriting logic, offers a rich notation supporting formal specification and implementation of concurrent systems. In addition to its modeling capacity, the Maude environment integrates a Model Checker based on Linear Temporal Logic (LTL) for distributed systems verification. In this paper, we present a formal and generic framework (DIMA-Maude) supporting formal description and verification of DIMA multi-agents models.


Author(s):  
Mark Batty

There is a broad design space for concurrent computer processors: they can be optimized for low power, low latency or high throughput. This freedom to tune each processor design to its niche has led to an increasing diversity of machines, from powerful pocketable devices to those responsible for complex and critical tasks, such as car guidance systems. Given this context, academic concurrency research sounds notes of both caution and optimism. Caution because recent work has uncovered flaws in the way we explain the subtle memory behaviour of concurrent systems: specifications have been shown to be incorrect, leading to bugs throughout the many layers of the system. And optimism because our tools and methods for verifying the correctness of concurrent code—although built above an idealized model of concurrency—are becoming more mature. This paper looks at the way we specify the memory behaviour of concurrent systems and suggests a new direction. Currently, there is a siloed approach, with each processor and programming language specified separately in an incomparable way. But this does not match the structure of our programs, which may use multiple processors and languages together. Instead we propose a compositional approach, where program components carry with them a description of the sort of concurrency they rely on, and there is a mechanism for composing these. This will support not only components written for the multiple varied processors found in a modern system but also those that use idealized models of concurrency, providing a sound footing for mature verification techniques. This article is part of the themed issue ‘Verified trustworthy software systems’.


Informatica ◽  
2017 ◽  
Vol 28 (3) ◽  
pp. 525-545 ◽  
Author(s):  
Marcin Szpyrka ◽  
Grzegorz J. Nalepa ◽  
Krzysztof Kluza

Author(s):  
Pierre-Loïc Garoche

The verification of control system software is critical to a host of technologies and industries, from aeronautics and medical technology to the cars we drive. The failure of controller software can cost people their lives. This book provides control engineers and computer scientists with an introduction to the formal techniques for analyzing and verifying this important class of software. Too often, control engineers are unaware of the issues surrounding the verification of software, while computer scientists tend to be unfamiliar with the specificities of controller software. The book provides a unified approach that is geared to graduate students in both fields, covering formal verification methods as well as the design and verification of controllers. It presents a wealth of new verification techniques for performing exhaustive analysis of controller software. These include new means to compute nonlinear invariants, the use of convex optimization tools, and methods for dealing with numerical imprecisions such as floating point computations occurring in the analyzed software. As the autonomy of critical systems continues to increase—as evidenced by autonomous cars, drones, and satellites and landers—the numerical functions in these systems are growing ever more advanced. The techniques presented here are essential to support the formal analysis of the controller software being used in these new and emerging technologies.


Author(s):  
Michele Loporcaro

The book addresses grammatical gender in Romance, and its development from Latin. It works with the toolbox of current linguistic typology, and asks the fundamental question of how the Latin grammatical gender system gradually changed into those of the Romance languages. To answer this question, the book capitalizes on the pervasive dialect variation of which the better-known standard Romance languages only represent a fragment. Indeed, inspection of dialect variation across time and space forces one to dismiss the handbook account proclaiming that the neuter gender, contrasting with masculine and feminine in Latin, was eradicated from spoken Latin by late Empire times. Both Late Latin evidence and data from several modern dialects show that this never happened, and that the vulgate account proceeds from unwarranted back-projection of the data from modern languages like French and Italian. Rather, the neuter underwent transformations which are the main culprit for the differences in the gender system observed today between, say, Romanian, Sursilvan, Neapolitan, and Asturian, to cite just a few types of system which turn out to differ significantly. A precondition for establishing the database for diachronic investigation is a detailed description of many such systems, which reveals data whose interest transcends the diachronic issue under consideration: the book thus addresses systems where ‘husbands’ are feminine and others where ‘wives’ are masculine; discusses dialects where nouns overtly mark gender, but only in certain syntactic contexts; and proposes an analysis according to which one Romance language (Asturian) has split inherited grammatical gender into two concurrent systems.


2021 ◽  
Vol 178 (3) ◽  
pp. 229-266
Author(s):  
Ivan Lanese ◽  
Adrián Palacios ◽  
Germán Vidal

Causal-consistent reversible debugging is an innovative technique for debugging concurrent systems. It allows one to go back in the execution focusing on the actions that most likely caused a visible misbehavior. When such an action is selected, the debugger undoes it, including all and only its consequences. This operation is called a causal-consistent rollback. In this way, the user can avoid being distracted by the actions of other, unrelated processes. In this work, we introduce its dual notion: causal-consistent replay. We allow the user to record an execution of a running program and, in contrast to traditional replay debuggers, to reproduce a visible misbehavior inside the debugger including all and only its causes. Furthermore, we present a unified framework that combines both causal-consistent replay and causal-consistent rollback. Although most of the ideas that we present are rather general, we focus on a popular functional and concurrent programming language based on message passing: Erlang.


Sign in / Sign up

Export Citation Format

Share Document