Deadlock detection for actor-based coroutines

The actor-based language studied in this paper features asynchronous method calls and supports coroutines which allow for the cooperative scheduling of the method invocations belonging to an actor. We model the local behavior of an actor as a well-structured transition system by means of predicate abstraction and derive the decidability of the occurrence of deadlocks caused by the coroutine mode of method execution

Deadlock detection of active objects with synchronous and asynchronous method calls

Open distributed systems are essential in today’s softwaresolutions. However, not all programming paradigms providenatural support for such systems. The setting of concurrentobjects is attractive since it supports independent units ofcomputation. In particular we consider concurrent objectscommunicating by asynchronous method calls supporting non-blocking as well as blocking method calls. In this settingwaiting time can be reduced, allowing efficient cooperationbetween objects. With this concurrency model, deadlock isavoided if blocking calls are avoided. However, blocking callsare sometimes needed to control the order of computation. Thenon-hierarchical nature of concurrent objects systems gives riseto non-trivial deadlock situations. Deadlocks may occur if thereis a call chain with at least one blocking call.We propose amethod for static detection of deadlocks, and demonstrate itsuse on a non-trivial example

A framework for deadlock detection in core ABS

We present a framework for statically detecting deadlocks in a concurrent object-oriented language with asynchronous method calls and cooperative scheduling of method activations. Since this language features recursion and dynamic resource creation, deadlock detection is extremely complex and state-of-the-art solutions either give imprecise answers or do not scale. In order to augment precision and scalability we propose a modular framework that allows several techniques to be combined. The basic component of the framework is a front-end inference algorithm that extracts abstract behavioural descriptions of methods, called contracts, which retain resource dependency information. This component is integrated with a number of possible different back-ends that analyse contracts and derive deadlock information. As a proof-of-concept, we discuss two such back-ends: (i) an evaluator that computes a fixpoint semantics and (ii) an evaluator using abstract model checking.Comment: Software and Systems Modeling, Springer Verlag, 201

Behavioural Models for Distributed Fractal Components

This paper presents a formal behavioural specification framework together with its applications in different contexts for specifying and verifying the correct behaviour of distributed Fractal components. Our framework allows us to build behavioural models for applications ranging from sequential Fractal components, to distributed objects, and finally distributed components. Our models are able to characterise both functional and non-functional behaviours, and the interaction between the two concerns. Finally, this work has resulted in the development of tools allowing the non-expert programmer to specify the behaviour of his components, and automatically, or semi-automatically verify properties of his application

Analysis of Synchronisations in Stateful Active Objects

International audienceThis paper presents a static analysis technique based on effects and behavioural types for deriving synchronisation patterns of stateful active objects and verifying the absence of deadlocks in this context. This is challenging because active objects use futures to refer to results of pending asynchronous invocations and because these futures can be stored in object fields, passed as method parameters, or returned by invocations. Our effect system traces the access to object fields, thus allowing us to compute behavioural types that express synchronisation patterns in a precise way. The behavioural types are thereafter analysed by a solver that discovers potential deadlocks

Analysis of synchronisation patterns in stateful active objects

This paper presents a static analysis technique based on effect and behavioural types for deriving synchronisation patterns of stateful active objects and verifying their safety -- e.g.~absence of deadlocks. This is challenging because active objects use futures to refer to results of pending asynchronous invocations and because these futures can be stored in object fields, passed as method parameters, or returned by invocations.Our effect system traces the access to object fields, thus allowing us to compute behavioural types that express synchronisation patterns in a precise way.The behavioural types are thereafter analysed by a solver that discovers potential deadlocks

Asynchronous programming in the abstract behavioural specification language

Chip manufacturers are rapidly moving towards so-called manycore chips with thousands of independent processors on the same silicon real estate. Current programming languages can only leverage the potential power by inserting code with low level concurrency constructs, sacrificing clarity. Alternatively, a programming language can integrate a thread of execution with a stable notion of identity, e.g., in active objects.Abstract Behavioural Specification (ABS) is a language for designing executable models of parallel and distributed object-oriented systems based on active objects, and is defined in terms of a formal operational semantics which enables a variety of static and dynamic analysis techniques for the ABS models.The overall goal of this thesis is to extend the asynchronous programming model and the corresponding analysis techniques in ABS.Algorithms and the Foundations of Software technolog

Behavioural models for distributed Fractal components

International audienc

The Symmetry Method for Coloured Petri Nets

This booklet is the author's PhD-dissertation