Static Detection of Race Conditions in Erlang

Christakis, Maria; Sagonas, Konstantinos

doi:10.1007/978-3-642-11503-5_11

Cited by 17 publications

(21 citation statements)

References 17 publications

(18 reference statements)

Supporting

Mentioning

Contrasting

Unclassified

Order By: Relevance

“…In particular, the analysis of the defect database revealed a remarkable set of issues that could be detected by static code analysis. So issues of the following categories can be detected by employing different static analysis techniques: (1) naming conventions, (2) program complexity, (3) bad code smells, (4) incompatible configuration settings, (5) problematic task interleaving and race conditions, (6) possible performance problems, and (7) dynamic statement dependencies. In the following we illustrate those issues and discuss the solution methods required to detect them.…”

Section: Common Issues and Solution Methodsmentioning

confidence: 99%

“…Since these timing conditions are typically hard to reproduce, the resulting data races are often not detected in software testing. Therefore, revealing data races with static code analysis has received much attention and resulted in several specialized tools like Chord [24], Dialyzer [6] and RacerX [11].…”

Section: Static Code Analysismentioning

confidence: 99%

Opportunities and challenges of static code analysis of IEC 61131-3 programs

Prähofer

Angerer

Ramler³

et al. 2012

Proceedings of 2012 IEEE 17th International Conference on Emerging Technologies &Amp; Factory Automation (ETFA 2012)

View full text Add to dashboard

Static code analysis techniques analyze programs by examining the source code without actually executing them. The main benefits lie in improving software quality by detecting potential defects and problematic code constructs in early development stages. Today, static code analysis is widely used and numerous tools are available for established programming languages like C/C++, Java, C# and others. However, in the domain of PLC programming, static code analysis tools are still rare. In this paper we present an approach and tool support for static code analysis of PLC programs. The paper discusses opportunities static code analysis can offer for PLC programming, it reviews techniques for static analysis, and it describes our tool that implements a rule-based analysis approach for IEC 61131-3 programs.

show abstract

“…This condition is similar to traditional deadlocks known from thread-based programs. We base the terminology on the work of [15] in Erlang concurrency bugs.…”

Section: Lack Of Progress Issuesmentioning

confidence: 99%

A Study of Concurrency Bugs and Advanced Development Support for Actor-based Programs

López

Marr

Boix

et al. 2018

Lecture Notes in Computer Science

View full text Add to dashboard

The actor model is an attractive foundation for developing concurrent applications because actors are isolated concurrent entities that communicate through asynchronous messages and do not share state. Thereby, they avoid concurrency bugs such as data races, but are not immune to concurrency bugs in general. This study taxonomizes concurrency bugs in actor-based programs reported in literature. Furthermore, it analyzes the bugs to identify the patterns causing them as well as their observable behavior. Based on this taxonomy, we further analyze the literature and find that current approaches to static analysis and testing focus on communication deadlocks and message protocol violations. However, they do not provide solutions to identify livelocks and behavioral deadlocks. The insights obtained in this study can be used to improve debugging support for actor-based programs with new debugging techniques to identify the root cause of complex concurrency bugs. 1 play() -> 2 Ping = spawn(fun ping/0), 3 spawn(fun() -> pong(Ping) end). 4 5 ping() -> 6 receive 7 pong_msg -> ok 8 end. 9 10 pong(Ping) -> 11 Ping ! pong_msg, 12 receive 13 ping_msg -> ok 14 end.Listing 1.1. Communication deadlock example in Erlang (from [15]). Line 12 has a blocking receive causing the pong process to deadlock because the expected message is never sent.

show abstract

“…Analysing Erlang programs for concurrency bugs is extremely cumbersome: while in theory a data race free actor-based language, the runtime's scheduler and global data dictionary (i.e. a kind of table-based memory heavily used in Erlang software) introduce various possibilities for race conditions in real world Erlang programs [CS10]. Thus, understanding Erlang's semantics is a crucial task for programmers, language designers, and runtime developers-i.e.…”

Section: Models Beyondmentioning

confidence: 99%

A semantics comparison workbench for a concurrent, asynchronous, distributed programming language

2018

View full text Add to dashboard

Abstract. A number of high-level languages and libraries have been proposed that offer novel and simple to use abstractions for concurrent, asynchronous, and distributed programming. The execution models that realise them, however, often change over time-whether to improve performance, or to extend them to new language features-potentially affecting behavioural and safety properties of existing programs. This is exemplified by Scoop, a message-passing approach to concurrent object-oriented programming that has seen multiple changes proposed and implemented, with demonstrable consequences for an idiomatic usage of its core abstraction. We propose a semantics comparison workbench for Scoop with fully and semiautomatic tools for analysing and comparing the state spaces of programs with respect to different execution models or semantics. We demonstrate its use in checking the consistency of properties across semantics by applying it to a set of representative programs, and highlighting a deadlock-related discrepancy between the principal execution models of Scoop. Furthermore, we demonstrate the extensibility of the workbench by generalising the formalisation of an execution model to support recently proposed extensions for distributed programming. 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, how the visual yet algebraic nature of the model can be used to ascertain soundness, and highlight how the approach could be applied to similar languages.

show abstract

“…Modelling asynchronous Erlang programs as CCS or CSP, which presume synchronous communication, is impractical because it requires the explicit modelling of associated buffer and carrier processes [7]. Several static source code analysis approaches have been devised to detect deadlocks [8], [9], however these can be highly inaccurate. More recently, several testing approaches have emerged such as PULSE [10] and Concuerror [11], however these can only be used to reason about the executed program behaviour (i.e.…”

Section: Motivation: Communication Errorsmentioning

confidence: 99%

Choreography-Based Analysis of Distributed Message Passing Programs

Taylor

Tuosto²,

Walkinshaw

et al. 2016

2016 24th Euromicro International Conference on Parallel, Distributed, and Network-Based Processing (PDP)

View full text Add to dashboard

Abstract-Distributed programs are vulnerable to subtle communication faults (e.g. deadlocks, lost messages). Although the behaviour of individual processes can be relatively straightforward, faults can still be hard to detect because the macroscopic behaviour emerging from interactions can easily become very complex. This paper reports the analysis of gen_server, an Erlang popular library to build client-server applications. Our analysis uses a tool based on choreographic models of communicating finite state machines (CFSMs). We discuss how, once the library has been modelled in terms of CFSMs, an automated analysis can be used to detect potential communication errors. The results of our analysis suggest how to properly use gen_server in order to guarantee the absence of communication errors.

show abstract

Static Detection of Race Conditions in Erlang

Cited by 17 publications

References 17 publications

Opportunities and challenges of static code analysis of IEC 61131-3 programs

A Study of Concurrency Bugs and Advanced Development Support for Actor-based Programs

A semantics comparison workbench for a concurrent, asynchronous, distributed programming language

Choreography-Based Analysis of Distributed Message Passing Programs

Contact Info

Product

Resources

About