2,261 research outputs found
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
Deadlock detection of Java Bytecode
This paper presents a technique for deadlock detection of Java programs. The
technique uses typing rules for extracting infinite-state abstract models of
the dependencies among the components of the Java intermediate language -- the
Java bytecode. Models are subsequently analysed by means of an extension of a
solver that we have defined for detecting deadlocks in process calculi. Our
technique is complemented by a prototype verifier that also covers most of the
Java features.Comment: Pre-proceedings paper presented at the 27th International Symposium
on Logic-Based Program Synthesis and Transformation (LOPSTR 2017), Namur,
Belgium, 10-12 October 2017 (arXiv:1708.07854
PLACES'10: The 3rd Workshop on Programmng Language Approaches to concurrency and Communication-Centric Software
Paphos, Cyprus. March 201
A technique for detecting wait-notify deadlocks in Java
Deadlock analysis of object-oriented programs that dynamically create threads and objects is complex, because these programs may have an infinite number of states.
In this thesis, I analyze the correctness of wait - notify patterns (e.g. deadlock freedom) by using a newly introduced technique that consists in an analysis model that is a basic concurrent language with a formal semantic. I detect deadlocks by associating a Petri Net graph to each process of the input program. This model allows to check if a deadlock occur by analysing the reachability tree.
The technique presented is a basic step of a more complex and complete project, since in my work I only consider programs with one object
Bounded LTL Model Checking with Stable Models
In this paper bounded model checking of asynchronous concurrent systems is
introduced as a promising application area for answer set programming. As the
model of asynchronous systems a generalisation of communicating automata,
1-safe Petri nets, are used. It is shown how a 1-safe Petri net and a
requirement on the behaviour of the net can be translated into a logic program
such that the bounded model checking problem for the net can be solved by
computing stable models of the corresponding program. The use of the stable
model semantics leads to compact encodings of bounded reachability and deadlock
detection tasks as well as the more general problem of bounded model checking
of linear temporal logic. Correctness proofs of the devised translations are
given, and some experimental results using the translation and the Smodels
system are presented.Comment: 32 pages, to appear in Theory and Practice of Logic Programmin
Automatic detection and resolution of deadlocks in Go programs
The Go programming language is acquiring momentum in the development of concurrent
software. Even though Go supports the shared-memory model, the message-passing
alternative is the favoured idiomatic approach. Naturally, this practice is not exempt of
the usual difficulties: programs may deadlock and the language run-time has only very
basic support for deadlock detection. Previous research on deadlock detection mainly
focused on shared-memory concurrency models. For mainstream languages, tools and
approaches specific to the message-passing paradigm are scarce and incipient. There is
however a large body of work on models of concurrency that only recently started to be
applied to languages like Go. Since the Go run-time lets many deadlocks pass unnoticed,
and the existing solutions provided by third party tools detect many deadlocks but only
try to fix a limited set of specific patterns, imposing severe conditions to do so, there is a
clear need for more general deadlock resolution strategies, going beyond prevention and
avoidance. To gain insight on real-world deadlock bugs, we first built and categorized a
collection of bugs sourced from high-profile open-source Go projects. Next, we extended
and implemented an algorithm that takes an abstraction of the communication behaviour
of the program and, when all the communication operations on channels necessary for
progress are present, but a deadlock is possible, presents the problem and offers a possible
resolution for the error. The extensions allows our approach to analyse a much wider
range of real world programs. We conclude with an evaluation, comparing with two other
state-of-the-art solutions.A linguagem de programação Go tem ganhado tração no desenvolvimento de software
concorrente. Apesar de o Go suportar o modelo de partilha de memória, o modelo
alternativo de partilha de mensagens é a abordagem idiomática. Naturalmente, esta
prática não está isenta das dificuldades usuais: os programas podem bloquear e o runtime
da linguagem só possui um suporte muito básico para a deteção destes bloqueios.
Investigação anterior na deteção de bloqueios focou principalmente no modelo de partilha
de memória. Para linguagens convencionais, ferramentas e abordagens dedicadas ao
paradigma de passagem de mensagens são escassas e incipientes. No entanto, existe
um grande conjunto de trabalhos sobre modelos de concorrência que só recentemente
começou a ser aplicado em linguagens como o Go. Visto que o run-time do Go deixa
muitos bloqueios passar despercebidos e as soluções existentes detetam muitos bloqueios,
mas só tentam resolver um conjunto muito pequeno de padrões. De modo a ganhar
conhecimento sobre erros de bloqueio reais, nós começámos por construir e categorizar
uma coleção de erros obtidos a partir de projetos Go open-source de alto perfil. De
seguida, nós estendemos e implementámos um algoritmo que recebe uma abstração
do comportamento da comunicação de um programa e quando todas as operações de
comunicação nos canais necessários para o progresso estão presentes, mas um bloqueio
é possível, apresenta o erro e oferece uma possível resolução do erro. A nossa extensão
permite analisar um conjunto muito maior de programas reais. Concluímos com uma
avaliação, comparando com duas outras soluções do estado da arte
Recursive Decomposition of Progress Graphs
Search of a state transition system is traditionally how deadlock detection for concurrent programs has been accomplished. This paper examines an approach to deadlock detection that uses geometric semantics involving the topo-logical notion of dihomotopy to partition the state space into components; after that the reduced state space is exhaustively searched. Prior work partitioned the state space inductively. in this paper we show that a recursive technique provides greater reduction of the size of the state transition system and therefore more efficient deadlock detection. If the preprocessing can be done efficiently, then for large problems we expect to see more efficient deadlock detection and eventually more efficient verification of some temporal properties. © 2009 IEEE
A Graph-Based Semantics Workbench for Concurrent Asynchronous Programs
A number of novel programming languages and libraries have been proposed that
offer simpler-to-use models of concurrency than threads. It is challenging,
however, to devise execution models that successfully realise their
abstractions without forfeiting performance or introducing unintended
behaviours. This is exemplified by SCOOP---a concurrent object-oriented
message-passing language---which has seen multiple semantics proposed and
implemented over its evolution. We propose a "semantics workbench" with fully
and semi-automatic tools for SCOOP, that can be used to analyse and compare
programs with respect to different execution models. We demonstrate its use in
checking the consistency of semantics by applying it to a set of representative
programs, and highlighting a deadlock-related discrepancy between the principal
execution models of the language. Our workbench is based on a modular and
parameterisable graph transformation semantics implemented in the GROOVE tool.
We discuss how graph transformations are leveraged to atomically model
intricate language abstractions, and how the visual yet algebraic nature of the
model can be used to ascertain soundness.Comment: Accepted for publication in the proceedings of FASE 2016 (to appear
Deadlock Analysis of Wait-Notify Coordination
International audienceDeadlock analysis of concurrent programs that contain coordination primitives (wait, notify and notifyAll) is notoriously challenging. Not only these primitives affect the scheduling of processes, but also notifications unmatched by a corresponding wait are silently lost. We design a behavioral type system for a core calculus featuring shared objects and Java-like coordination primitives. The type system is based on a simple language of object protocols-called usages-to determine whether objects are used reliably, so as to guarantee deadlock freedom
- …