[Show abstract][Hide abstract] ABSTRACT: Making threaded programs safe and easy to reason about is one of the chief
difficulties in modern programming. This work provides an efficient execution
model for SCOOP, a concurrency approach that provides not only data race
freedom but also pre/postcondition reasoning guarantees between threads. The
extensions we propose influence both the underlying semantics to increase the
amount of concurrent execution that is possible, exclude certain classes of
deadlocks, and enable greater performance. These extensions are used as the
basis an efficient runtime and optimization pass that improve performance 15x
over a baseline implementation. This new implementation of SCOOP is also 2x
faster than other well-known safe concurrent languages. The measurements are
based on both coordination-intensive and data-manipulation-intensive benchmarks
designed to offer a mixture of workloads.
Preview · Article · May 2014 · ACM SIGPLAN Notices
[Show abstract][Hide abstract] ABSTRACT: When program verification fails, it is often hard to understand what went wrong in the absence of concrete executions that expose parts of the implementation or specification responsible for the failure. Automatic generation of such tests would require “executing” the complex specifications typically used for verification (with unbounded quantification and other expressive constructs), something beyond the capabilities of standard testing tools.
This paper presents a technique to automatically generate executions of programs annotated with complex specifications, and its implementation for the Boogie intermediate verification language. Our approach combines symbolic execution and SMT constraint solving to generate small tests that are easy to read and understand. The evaluation on several program verification examples demonstrates that our test case generation technique can help understand failed verification attempts in conditions where traditional testing is not applicable, thus making formal verification techniques easier to use in practice.
[Show abstract][Hide abstract] ABSTRACT: Parallel programming is often regarded as one of the hardest programming disciplines. On the one hand, parallel programs are notoriously prone to concurrency errors; and, while trying to avoid such errors, achieving program performance becomes a significant challenge. As a result of the multicore revolution, parallel programming has however ceased to be a task for domain experts only. And for this reason, a large variety of languages and libraries have been proposed that promise to ease this task. This paper presents a study to investigate whether such approaches succeed in closing the gap between domain experts and mainstream developers. Four approaches are studied: Chapel, Cilk, Go, and Threading Building Blocks (TBB). Each approach is used to implement a suite of benchmark programs, which are then reviewed by notable experts in the language. By comparing original and revised versions with respect to source code size, coding time, execution time, and speedup, we gain insights into the importance of expert knowledge when using modern parallel programming approaches.
[Show abstract][Hide abstract] ABSTRACT: Developers face a wide choice of programming languages and libraries
supporting multicore computing. Ever more diverse paradigms for expressing
parallelism and synchronization become available while their influence on
usability and performance remains largely unclear. This paper describes an
experiment comparing four markedly different approaches to parallel
programming: Chapel, Cilk, Go, and Threading Building Blocks (TBB). Each
language is used to implement sequential and parallel versions of six benchmark
programs. The implementations are then reviewed by notable experts in the
language, thereby obtaining reference versions for each language and benchmark.
The resulting pool of 96 implementations is used to compare the languages with
respect to source code size, coding time, execution time, and speedup. The
experiment uncovers strengths and weaknesses in all approaches, facilitating an
informed selection of a language under a particular set of requirements. The
expert review step furthermore highlights the importance of expert knowledge
when using modern parallel programming approaches.
[Show abstract][Hide abstract] ABSTRACT: The development of concurrent applications is challenging because of the
complexity of concurrent designs and the hazards of concurrent programming.
Architectural modeling using the Unified Modeling Language (UML) can support
the development process, but the problem of mapping the model to a concurrent
implementation remains. This paper addresses this problem by defining a scheme
to map concurrent UML designs to a concurrent object-oriented program. Using
the COMET method for the architectural design of concurrent object-oriented
systems, each component and connector is annotated with a stereotype indicating
its behavioral design pattern. For each of these patterns, a reference
implementation is provided using SCOOP, a concurrent object-oriented
programming model. We evaluate this development process using a case study of
an ATM system, obtaining a fully functional implementation based on the
systematic mapping of the individual patterns. Given the strong execution
guarantees of the SCOOP model, which is free of data races by construction,
this development method eliminates a source of intricate concurrent programming
[Show abstract][Hide abstract] ABSTRACT: Testing presents a daunting challenge for concurrent programs, as non-deterministic scheduling defeats reproducibility. The problem is even harder if, rather than testing entire systems, one tries to test individual components, for example to assess them for thread-safety. We present demonic testing, a technique combining the tangible results of unit testing with the rigour of formal rely-guarantee reasoning to provide deterministic unit testing for concurrent programs. Deterministic execution is provided by abstracting threads away via rely-guarantee reasoning, and replacing them with "demonic" sequences of interfering instructions that drive the program to break invariants. Demonic testing reuses existing unit tests to drive the routine under test, using the execution to discover demonic interference. Programs carry contract-based rely-guarantee style specifications to express what sort of thread interference should be tolerated. Aiding the demonic testing technique is an interference synthesis tool we have implemented based on SMT solving. The technique is shown to find errors in contracted versions of several benchmark applications.
[Show abstract][Hide abstract] ABSTRACT: Concurrency is an integral part of many robotics applications, due to the need for handling inherently parallel tasks such as motion control and sensor monitoring. Writing programs for this complex domain can be hard, in particular because of the difficulties of retaining a robust modular design. We propose to use SCOOP, an object-oriented programming model for concurrency which by construction is free of data races, therefore excluding a major class of concurrent programming errors. Synchronization requirements are expressed by waiting on routine preconditions, which turns out to provide a natural framework for implementing coordination requirements in robotics applications. As demonstration application, we describe a control program for hexapod locomotion, whose implementation closely follows the corresponding behavioral specification given by the biological model. We compare the architecture with solutions expressed in more traditional approaches to robotic control applications.
[Show abstract][Hide abstract] ABSTRACT: Despite the advancements of concurrency theory in the past decades, practical concurrent programming has remained a challenging
activity. Fundamental problems such as data races and deadlocks still persist for programmers since available detection and
prevention tools are unsound or have otherwise not been well adopted. In an alternative approach, programming models that
exclude certain classes of errors by design can address concurrency problems at a language level. In this paper we review
SCOOP, an existing race-free programming model for concurrent object-oriented programming, and extend it with a scheme for
deadlock prevention based on locking orders. The scheme facilitates modular reasoning about deadlocks by associating annotations
with the interfaces of routines. We prove deadlock-freedom of well-formed programs using a rigorous formalization of the locking
semantics of the programming model. The scheme has been implemented and we demonstrate its usefulness by applying it to the
example of a simple web server.