[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.
[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.
14th International Conference on Formal Engineering Methods (ICFEM'12); 01/2012
[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.
Intelligent Robots and Systems (IROS), 2010 IEEE/RSJ International Conference on; 11/2010
[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.
Formal Methods and Software Engineering - 12th International Conference on Formal Engineering Methods, ICFEM 2010, Shanghai, China, November 17-19, 2010. Proceedings; 01/2010