A language based on the Pi-calculus

The exponential increase in the volume and sensitivity of data transmitted over electronic media has resulted in a corresponding increase in attempts to secure these inherently insecure transmissions. Numerous networking protocols and associated mechanisms have been used but implementing distributed systems is a notoriously error prone exercise. Attempts to ensure the relevant properties are present in distributed systems can be made by the application of formal methods. However this application of formal methods is made to the specification of a distributed system, not its actual implementation. Typically, a wide gulf exists between the specification of a distributed system and its actual implementation, and this gulf can result in the introduction of potentially devastating errors. A method of bridging this gulf is required in order that the application of formal methods to distributed systems can become more widespread and more accessible. We propose a general purpose programming language that is based on one of the more popular formal notations used to specify distributed systems, the 7r-calculus With this approach we allow the integration of complex sequential computations into 7r-calculus specifications of distributed systems to produce systems that are capable of execution in a distributed and concurrent fashion. The implementation of this proposal is facilitated by designing the language such that fragments of Java code can be integrated into a 7r-calculus framework

A Roadmap to Pervasive Systems Verification

yesThe complexity of pervasive systems arises from the many different aspects that such systems possess. A typical pervasive system may be autonomous, distributed, concurrent and context-based, and may involve humans and robotic devices working together. If we wish to formally verify the behaviour of such systems, the formal methods for pervasive systems will surely also be complex. In this paper, we move towards being able to formally verify pervasive systems and outline our approach wherein we distinguish four distinct dimensions within pervasive system behaviour and utilise different, but appropriate, formal techniques for verifying each one.EPSR

An Investigation and evaluation of promela/spin as a validation tool for asynchronous concurrent systems

Historically, the consequences of implementing faulty designs of concurrent/ distributed systems have been well known. There have many documented occasions where the little-known and unaccounted-for situations have caused the loss of human life and limb. This problem can be generalized, nowadays, to systems termed as mission critical. This term has arisen because individuals, businesses, and governments have come to depend on their correct operation. Failures in these systems can have such an adverse impact, that they are simply unacceptable. Although, due to the inherent complexity of these systems, preventing such failures can prove to be a very difficult task. PROMELA/SPIN is a validation environment that was developed to address the issue of correctness in concurrent systems by means of formal verification. PROMELA is a specification language used to model the systems to be analyzed, while SPIN is a model-checking tool used to perform the analysis. The modeling language, PROMELA, was specifically designed and intended for specifying communications protocols. The tool, SPIN, has the ability to perform both simulations and verifications of a given PRO MELA model. It also can perform a bit-state space analysis for maximum coverage of large systems that would otherwise be unable to be exhaustively verified. This document is the result of an analysis of PROMELA/SPIN as a practical formal verification method. Formal methods have been slow in their development and acceptance because of both the complexity of the problems that they have tried to solve, and the knowledge of formal methods needed to use them practically. With these points in mind, the analysis will explore the types and sizes of systems that can be verified with PROMELA/SPIN effectively, and just how much knowledge of the tool and formal methods are needed to do so

Identifying Implicit Component Interactions in Distributed Cyber-Physical Systems

Modern distributed systems and networks, like those found in cyber-physical system domains such as critical infrastructures, contain many complex interactions among their constituent software and/or hardware components. Despite extensive testing of individual components, security vulnerabilities resulting from unintended and unforeseen component interactions (so-called implicit interactions) often remain undetected. This paper presents a method for identifying the existence of implicit interactions in designs of distributed cyber-physical systems using the algebraic modeling framework known as Communicating Concurrent Kleene Algebra (C²KA). Experimental results verifying the applicability of C²KA for identifying dependencies in system designs that would otherwise be very hard to find are also presented. More broadly, this research aims to advance the specification, design, and implementation of distributed cyber-physical systems with improved cybersecurity assurance by providing a new way of thinking about the problem of implicit interactions through the application of formal methods

Extending Rebeca with synchronous messages and reusable components

In this paper, we propose extended Rebeca as a tool-supported actor-based language for modeling and verifying of concurrent and distributed systems. We enrich Rebeca with a formal concept of components which integrates the message-driven computational model of actor-based languages with synchronous message passing. Components are used to encapsulate a set of internal active objects which react asynchronously to messages by means of methods and which additionally interact via a synchronous message passing mechanism. Components themselves interact only via asynchronous and anonymous messages. We present our compositional verification approach and abstraction techniques, and the theory corresponding to it, based on formal semantics of Rebeca. These techniques are exploited to overcome state explosion problem in model checkin

Algorithms and Implementation

In the past few years Tabling has emerged as a powerful logic programming model. The integration of concurrent features into the implementation of Tabling systems is demanded by need to use recently developed tabling applications within distributed systems, where a process has to respond concurrently to several requests. The support for sharing of tables among the concurrent threads of a Tabling process is a desirable feature, to allow one of Tabling’s virtues, the re-use of computations by other threads and to allow efficient usage of available memory. However, the incremental completion of tables which are evaluated concurrently is not a trivial problem. In this dissertation we describe the integration of concurrency mechanisms, by the way of multi-threading, in a state of the art Tabling and Prolog system, XSB. We begin by reviewing the main concepts for a formal description of tabled computations, called SLG resolution and for the implementation of Tabling under the SLG-WAM, the abstract machine supported by XSB. We describe the different scheduling strategies provided by XSB and introduce some new properties of local scheduling, a scheduling strategy for SLG resolution. We proceed to describe our implementation work by describing the process of integrating multi-threading in a Prolog system supporting Tabling, without addressing the problem of shared tables. We describe the trade-offs and implementation decisions involved. We then describe an optimistic algorithm for the concurrent sharing of completed tables, Shared Completed Tables, which allows the sharing of tables without incurring in deadlocks, under local scheduling. This method relies on the execution properties of local scheduling and includes full support for negation. We provide a theoretical framework and discuss the implementation’s correctness and complexity. After that, we describe amethod for the sharing of tables among threads that allows parallelism in the computation of inter-dependent subgoals, which we name Concurrent Completion. We informally argue for the correctness of Concurrent Completion. We give detailed performance measurements of the multi-threaded XSB systems over a variety of machines and operating systems, for both the Shared Completed Tables and the Concurrent Completion implementations. We focus our measurements inthe overhead over the sequential engine and the scalability of the system. We finish with a comparison of XSB with other multi-threaded Prolog systems and we compare our approach to concurrent tabling with parallel and distributed methods for the evaluation of tabling. Finally, we identify future research directions

A proof system for lock-free concurrency

Dissertação para obtenção do Grau de Mestre em Engenharia InformáticaSoftware has become widespread, being used and relied upon on nearly every domain. Furthermore, as this globalization of software took place and multi-core architectures became the norm, several programs are now expected to run on a given device at the same time in a timely fashion. Attending this need, concurrent and distributed systems are a well known way of dealing with performance and scalability of computation. Although several such systems exist in the devices and services we depend on, it is frequent for those systems to be exploited or go wrong. Because most complex programs are built in modules and lack a formal specification of what they do, it is hard to prevent the emerging system from failing or being exploited. Therefore, one of the most sought after results by software industry is a way of reasoning about programs that prevents undesired behavior. Formal methods contribute to a rigorous specification, analysis, and verification of programs, having proven to be quite effective in this regard. Program logics,in particular, are able to verify validity of user-specified formulas and are the solution we propose to tackle this issue. Regarding concurrent programs, locks are a mechanism that make reasoning easier by serializing access to shared resources, taming concurrency. Since lock-free programs offer a better way of taking advantage of concurrency, we are especially interested in them. In this context, the LL/SC pair of primitives have proven to be more expressive than their widely used CAS counterpart. The goal of our work is then to develop a proof system capable of proving correctness of lock-free programs based on LL/SC primitives. In this dissertation we present a new program logic, based on those of concurrent separation logic and RGSep, which establishes a solid theoretical basis for reasoning about such programs

A methodology of testing high-level Petri nets

Petri nets have been extensively used in the modelling and analysis of concurrent and distributed systems. The verification and validation of Petri nets are of particular importance in the development of concurrent and distributed systems. As a complement to formal analysis techniques, testing has been proven to be effective in detecting system errors and is easy to apply. An open problem is how to test Petri nets systematically, effectively and efficiently. An approach to solve this problem is to develop test criteria so that test adequacy can be measured objectively and test cases can be generated efficiently, even automatically. In this paper, we present a methodology of testing high-level Petri nets based on our general theory of testing concurrent software systems. Four types of testing strategies are investigated, which include state-oriented testing, transition-oriented testing, flow-oriented testing and specification-oriented testing. For each strategy, a set of schemes toobserve and record testing results and a set of coverage criteria to measure test adequacy are defined. The subsumption relationships and extraction relationships among the proposed testing methods are systematically investigated and formally proved

Formal verification in network of synchronizing FSMs with SPIN.

Concurrent systems are becoming more and more popular. Improving the qualities of these systems is an important issue we are facing. It is well known that developing concurrent software is a challenging task, mainly because of the non-determinism behavior involved in the system. One promising way to help the designer in this task is providing formal verification methods that can detect concurrency-related errors at the design stage. In this thesis, we present our study on model checking concurrency-related correctness of design artifacts for concurrent and distributed systems. We construct our model for design artifacts using a network of synchronizing finite state machines (NSFSM), which provides well known synchronization mechanisms from programming languages. The formal verification is performed by SPIN, which is based on visiting all the global system states reachable from a given initial state to check if some properties hold. The input language of SPIN is PROMELA, which features a C-like syntax, dynamic creation of processes, and various interprocess communication models. In order to apply SPIN, we provide an automatic translation from NSFSMs to PROMELA programs. Paper copy at Leddy Library: Theses & Major Papers - Basement, West Bldg. / Call Number: Thesis2001 .L5. Source: Masters Abstracts International, Volume: 40-03, page: 0724. Adviser: Xiaojun Chen. Thesis (M.Sc.)--University of Windsor (Canada), 2001