Algorithmic verification of asynchronous programs

The model of asynchronous programming arises in many contexts, from low-level systems software to high-level web programming. We take a language-theoretic perspective and show general decidability and undecidability results for asynchronous programs that capture all known results as well as show decidability of new and important classes. As a main consequence, we show decidability of safety, termination and boundedness verification for higher-order asynchronous programs -- such as OCaml programs using Lwt -- and undecidability of liveness verification already for order-2 asynchronous programs. We show that under mild assumptions, surprisingly, safety and termination verification of asynchronous programs with handlers from a language class are decidable iff emptiness is decidable for the underlying language class. Moreover, we show that configuration reachability and liveness (fair termination) verification are equivalent, and decidability of these problems implies decidability of the well-known equal-letters problem on languages. Our results close the decidability frontier for asynchronous programs.

Asynchronous programming is a standard approach for designing responsive applications. Modern languages such as C# provide async/await primitives for the disciplined use of asynchrony. In spite of this, programs can deadlock because of incorrect use of blocking operations along with non-blocking (asynchronous) operations. While developers are aware of this problem, there is no automated technique to detect deadlocks in asynchronous programs.

What's does a mouse drag event have in common with an Array of numbers?

Asynchronous programming is a standard approach for designing responsive applications. Modern languages such as C# provide async/await primitives for the disciplined use of asynchrony. In spite of this, programs can deadlock because of incorrect use of blocking operations along with non-blocking (asynchronous) operations. While developers are aware of this problem, there is no automated technique to detect deadlocks in asynchronous programs. We present a novel representation of control flow and scheduling of asynchronous programs, called continuation scheduling graph and formulate necessary conditions for a deadlock to occur in a program. We design static analyses to construct continuation scheduling graphs of asynchronous C# programs and to identify deadlocks in them. We have implemented the static analyses in a tool called DeadWait. Using DeadWait, we found 43 previously unknown deadlocks in 11 asynchronous C# libraries. We reported the deadlocks to the library developers. They have confirmed and fixed 40 of them.

Developing interactive and distributive softwares is a complicated task for many reasons including the nature of this technique of programming; asynchronous programming. In this style of programming, there is no synchronization between running processes concerning message-posting communications. Therefore the presence of nonterminating executions for asynchronous programs, as a result of simple programming errors, is common.

Asynchronous programming is generally one of the hardest programming concepts to grasp. It is even harder to understand what it means when it comes to dealing with server applications, notably web applications. Besides the general concept, the asynchronous programming model in the .NET Framework was also hard to grasp in the early days of the framework. With the introduction of Task Parallel Library (TPL) in .NET version 4.0, it became easier, but the programming model was still not ideal. With the new asynchronous programming language features of C# in .NET 4.5, it got easier still. It now may be said to offer the ideal programming model as well.

Tarragon is an actor-based programming model and library for implementing latency tolerant asynchronous event driven simulations. It is novel in its support for meta data describing run time virtualized process structures, which may be optimized as a free-standing object. We demonstrate early results with a synthetic benchmark, and observe that Tarragon can mask communication costs with ongoing computation

Verification of Concurrent Assembly Programs with a Petri Net Based Safety Policy

In the article, we consider verification of programs with mutual recursion in the data driven functional parallel language Pifagor. In this language the program could be represented as a data flow graph, that has no control connections, and only has data relations. Under these conditions it is possible to simplify the process of formal verification, since there is no need to analyse resource conflicts, which are present in the systems with ordinary architectures. The proof of programs correctness is based on the elimination of mutual recursions by program transformation. The universal method of mutual recursion of an arbitrary number of functions elimination consists in constructing the universal recursive function that simulates all the functions in mutual recursion. A natural number is assigned to each function in mutual recursion. The universal recursive function takes as its argument the number of a function to be simulated and the arguments of this function. In some cases of the indirect recursion it is possible to use a simpler method of program transformation, namely, the merging of the functions code into a single function. To remove mutual recursion of an arbitrary number of functions, it is suggested to construct a graph of all connected functions and transform this graph by removing functions that are not connected with the target function, then by merging functions with indirect recursion and finally by constructing the universal recursive function. It is proved that in the Pifagor language such transformations of functions as code merging and universal recursive function construction do not change the correctness of the initial program. The example of partial correctness proof is given for the program that parses a simple arithmetic expression. We construct the graph of all connected functions and demonstrate two methods of proofs: by means of code merging and by means of the universal recursive function.

Petri net paradigm of computing is concerned discussing basic types of Petri net computers and their relations. We developed a technique of parametric specification of Petri nets, built of a few connected components which are repeated depending on a parameter or a set of parameters, and composition of software to generate automatically the corresponding models in a vivid graphical form. We construct explicitly a Petri net that is a strong computer of double exponent after R.J. Lipton. Its nondeterministic computation is represented by a Petri net reachability graph to which a successful branch belongs. Then we minimise and transform the net to obtain twice smaller construct than the original one. Moreover, the obtained net possesses such a marvellous property that addingto it four priority arcs makes it an exact (deterministic) computer having a single firable sequence only. Same as the Lipton’s net, the minimized net allows the proof that the Petri net reachability problem is exponential in space. Besides, it represents an example when simple transformations allow guessing the successful branch of a nondeterministic computation. The practical significance of the approach in applications consists in a state-of-art heuristic technique of solving some NP problems in polynomial time.

The coverability problem for Petri nets plays a central role in the verification of concurrent shared-memory programs. However, its high EXPSPACE-complete complexity poses a challenge when encountered in real-world instances. In this paper, we develop a new approach to this problem which is primarily based on applying forward coverability in continuous Petri nets as a pruning criterion inside a backward coverability framework. A cornerstone of our approach is the efficient encoding of a recently developed polynomial-time algorithm for reachability in continuous Petri nets into SMT. We demonstrate the effectiveness of our approach on standard benchmarks from the literature, which shows that our approach decides significantly more instances than any existing tool and is in addition often much faster, in particular on large instances.

The relationship between system independent logic controller programs (IEC standard 1131-3, Programmable Controllers, part 3: programming languages) and rule-based formal specifications is discussed. The Petri net and knowledge base theories can be joined together in the one context (Gentzen Logic). It combines the advantages taken from mathematical logic with the analysis power of Petri nets. The declarative specification, which is extracted from the description given in the initial standard IEC language (for example from structured text), can increase the efficiency of the logic controller program development. The well-structured specification, which is represented in the human-readable logic language, has direct impact on validation, formal verification and implementation of logic controller programs. The formality is introduced into the design technique, but it also can be used for post-design validations and maintenance. The symbolic deduction technique for PLC declarative program development appears very attractive. The CAD environment for application specific logic controllers is part of a research project at the University of Minho. The specification in the form of symbolic logic expressions may be verified, and then transformed into a format accepted by standard CAD tools (FPLD and FPGA compilers, VHDL tools).

An issue in self-managed systems is that different abstractions and programming models are used on different architectural layers, leading to systems that are harder to build and understand. To alleviate this, we introduce a self-management approach which combines high-level Petri nets with the capability of distributed communication among nets. Organized in a three-layer goal management, change management, and component control architecture this allows for self-management in distributed systems. We validate the approach through the Flamenco/CPN middleware that allows for self-management of service-oriented pervasive computing systems through the runtime interpretation of colored Petri nets. The current work focuses on the change management and component control layers.

Given an initial marking and final marking for a Petri net model, an optimal firing sequence problem is defined as the problem to find an optimal transition firing sequence to minimize the objective function. For the purpose of analysis of general integer programming problems, we propose a Petri net representation and reachability analysis of integer programming problems. In the proposed method, an integer programming problem is converted into the optimal firing sequence problem of Petri nets. By utilizing the proposed algorithm, integer programming problems can be visualized and analyzed by the Petri net theory. We apply the proposed methodology to the scheduling problems of dual armed cluster tools. The valid inequalities are derived from the reachability analysis. Numerical results show that those valid inequalities can significantly reduce the computational time of the original integer programming problem.

This article is devoted to the problem of verifying parallel programs that may contain special types of errors associated with the synchronization of parallel executed threads and access to shared memory. Such errors include deadlocks and data races. There is a division of parallel program verification methods into static and dynamic. The second ones require running the code and allow to check only the current implementation of the program for races, which, if there are a large number of branches, can lead to missing races. Among static methods, analytical methods (for example, based on deductive analysis) and model checking methods are most widely used. However, they are difficult to implement, and model checking still require a significant amount of manual work from the programmer to build such a model. In this regard, it is necessary to use models that can be built automatically. Previously, the authors developed a model based on an extension of Petri nets, which allows automatic creation based on sequential code and its conversion into parallel code. Automatic creation of a model of a parallel program introduces new, previously unused requirements related to the interaction of parallel threads. Thus, this article discusses the features of modeling using extended Petri nets with semantic relations of the main synchronization primitives implemented in most languages and parallel programming technologies for shared memory systems. In the future, these models will be used to search for data races and deadlocks in parallel programs.