Emmanuel Haucourt

A practical application of geometric semantics to static analysis of concurrent programs

In this paper we show how to compress efficiently the state-space of a concurrent system (here applied to a simple shared memory model, but this is no way limited to that model). The technology used here is based on research on geometric semantics by the authors and collaborators. It has been implemented in a abstract interpretation based static analyzer (ALCOOL), and we show some preliminary results and benchmarks.

Directed Algebraic Topology and Concurrency

This monograph presents an application of concepts and methods from algebraic topology to models of concurrent processes in computer science and their analysis. Taking well-known discrete models for concurrent processes in resource management as a point of departure, the book goes on to refine combinatorial and topological models. In the process, it develops tools and invariants for the new discipline directed algebraic topology, which is driven by fundamental research interests as well as by applications, primarily in the static analysis of concurrent programs. The state space of a concurrent program is described as a higher-dimensional space, the topology of which encodes the essential properties of the system. In order to analyse all possible executions in the state space, more than just the topological properties have to be considered: Execution paths need to respect a partial order given by the time flow. As a result, tools and concepts from topology have to be extended to take privileged directions into account. The target audience for this book consists of graduate students, researchers and practitioners in the field, mathematicians and computer scientists alike.

Rigorous evidence of freedom from concurrency faults in industrial control software

In the power generation industry, digital control systems may play an important role in plant safety. Thus, these systems are the object of rigorous analyzes and safety assessments. In particular, the quality, correctness and dependability of control systems software need to be justified. This paper reports on the development of a tool-based methodology to address the demonstration of freedom from intrinsic software faults related to concurrency and synchronization, and its practical application to an industrial control software case study. We describe the underlying theoretical foundations, the main mechanisms involved in the tools and the main results and lessons learned from this work. An important conclusion of the paper is that the used verification techniques and tools scale efficiently and accurately to industrial control system software, which is a major requirement for real-life safety assessments.

A geometric approach to the problem of unique decomposition of processes

This paper proposes a geometric solution to the problem of prime decomposability of concurrent processes first explored by R. Milner and F. Moller in [MM93]. Concurrent programs are given a geometric semantics using cubical areas, for which a unique factorization theorem is proved. An effective factorization method which is correct and complete with respect to the geometric semantics is derived from the factorization theorem. This algorithm is implemented in the static analyzer ALCOOL.

Future Path-components in Directed Topology

The global states of complex systems often form pospaces, topological spaces equipped with compatible partial orders reflecting causal relationships between the states. The calculation of tractable invariants on such pospaces can reveal critical system behavior unseen by ordinary invariants on the underlying spaces, thereby sometimes cirumventing the state space problem bedevilling static analysis. We introduce a practical technique for calculating future path-components, algebraic invariants on pospaces of states and hence tractable descriptions of the qualitative behavior of concurrent processes.

Directed Topological Models of Concurrency

We study topological models for concurrent programs with the aim of importing tools and techniques coming from algebraic topology to ease verification of concurrent programs. In those models, the state space of a program is described as a topological space, and an execution corresponds naturally to a path in this space. To rensure that models reflect order properties, we are led to enrich the concept of a topological space so that it takes causality into account. We shall focus our attention on directed paths, i.e., the ones respecting causality.

Truly Concurrent Models of Programs with Resources

The graph-based semantics introduced in the previous chapter is often not informative enough, because it does not take into account whether two actions commute or not. In this chapter, we introduce truly concurrent models which incorporate this information. We begin by extending our programming languages with resources and restrict ourselves to conservative programs, in which resource consumption only depends on the current state. We then generalize the semantics to asynchronous graphs, which explicitly describe the commutation of two actions and to precubical sets, which can more generally express the commutation of n actions. Finally, links with other classical models for concurrency are mentioned.

The Category of Components

The components of a directed space are not easy to define. We explain what the problem is and why some obvious ideas fail. Then the components of a d-space without loops is defined. It is a quotient of the fundamental category. It is defined for a general category without non-trivial isomorphisms. The component category is the quotient under a system of morphisms, the weak isomorphisms. Another construction, which gives an isomorphic fundamental category, is obtained by inverting the weak isomorphisms. An algorithm which determines a less “quotiented” category, precomponents, for simple programs is given, as well as several examples.

A Toy Language for Concurrency

Since the aim of this book is to introduce models and verification techniques for programming languages, our first task is to introduce the programming language through which we demonstrate the main ideas of this book. We begin by introducing the language. We then describe its operational semantics, which formalizes the way programs are to be executed. Finally, we describe the correctness properties that we will be interested in.

Algorithmics on Directed Spaces

In this section, we explain algorithms which are based on the geometric semantics of programs. In order to ease the presentation, those algorithms are formulated for simple programs, and we only hint at generalizations: programs with branchings can generally be handled by adapting the algorithms, and loops can be handled up to a finite depth by unrolling the programs. We illustrate the wide variety of applications of the geometric point of view by presenting a compact way of representing regions in the geometric semantics, an algorithm for detecting deadlocks, and an algorithm for factoring programs into independent parallel processes.