Concurrent Object-oriented Programming Research Articles

Dynamic structural operational semantics

We introduce Dynamic Structural Operational Semantics (DSOS or Dynamic SOS) as a framework for describing semantics of programming languages that include dynamic software upgrades, i.e., for upgrading software code during run-time. DSOS is built on top of the Modular SOS of P. Mosses, with an underlying category theory formalization. The idea of Dynamic SOS is to bring out the essential differences between dynamic upgrade constructs and program execution constructs. The important feature of Modular SOS (MSOS) that we exploit in DSOS is the sharp separation of the program execution code from the additional (data) structures needed at run-time. In DSOS we aim to achieve the same modularity and decoupling for dynamic software upgrades. This is partly motivated by the long term goal of having machine-checkable proofs for general results like type safety.We exemplify Dynamic SOS on two languages supporting dynamic software upgrades, namely the C-like Proteus, which supports updating of variables, functions, records, or types at specific program points, and Creol, which supports dynamic class upgrades in the setting of concurrent objects. Existing type analyses for software upgrades can be done on top of DSOS too, as we illustrate for Proteus.As a side contribution we define a general encapsulating construction on Modular SOS useful in situations where a form of encapsulation of the execution is needed. We use encapsulation to give modular semantics to the concurrent object-oriented programming language Creol with active objects and asynchronous method invocations.

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

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 semi-automatic 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.

OrcO: a concurrency-first approach to objects

The majority of modern programming languages provide concurrency and object-orientation in some form. However, object-oriented concurrency remains cumbersome in many situations. We introduce the language OrcO, Orc with concurrent Objects, which enables a flexible style of concurrent object-oriented programming. OrcO extends the Orc programming language by adding abstractions for programming-in-the-large; namely objects, classes, and inheritance. OrcO objects are designed to be orthogonal to concurrency, allowing the concurrent structure and object structure of a program to evolve independently. This paper describes OrcO's goals and design and provides examples of how OrcO can be used to deftly handle events, object management, and object composition.

Design Reusability and Adaptability for Concurrent Software

Developing reusable and adaptable concurrent software are very difficult. Reusability and adaptability in concurrent software become minimal. These collaborations not only perimeter reusability, but also make modification invasive changes to meet new requirements in the design of the concurrent software. The concurrent system has to reengineer, in order to meet the future requirements. A misunderstanding, that a concurrent object-oriented programming generally endorses reusability and adaptability, as none of these problems is imposed. Software developers have to specifically deliberate software making reusability and adaptability. We present a concurrent aspect framework which better supporting reusability and adaptability. In the framework, functional components and system assets are relatively separated. This technique makes concurrent software developing better reusability and adaptability. A framework enables manageable reusability and adaptability for building of concurrent software. Our research focuses on decomposition of contact in concurrent software development and our goal is to demonstrate a better model of concurrent software design.

Channels as Objects in Concurrent Object-Oriented Programming

There is often a sort of a protocol associated to each class, stating when and how certain methods should be called. Given that this protocol is, if at all, described in the documentation accompanying the class, current mainstream object-oriented languages cannot provide for the verification of client code adherence against the sought class behaviour. We have defined a class-based concurrent object-oriented language that formalises such protocols in the form of usage types. Usage types are attached to class definitions, allowing for the specification of (1) the available methods, (2) the tests clients must perform on the result of methods, and (3) the object status - linear or shared - all of which depend on the object's state. Our work extends the recent approach on modular session types by eliminating channel operations, and defining the method call as the single communication primitive in both sequential and concurrent settings. In contrast to previous works, we define a single category for objects, instead of distinct categories for linear and for shared objects, and let linear objects evolve into shared ones. We introduce a standard sync qualifier to prevent thread interference in certain operations on shared objects. We formalise the language syntax, the operational semantics, and a type system that enforces by static typing that methods are called only when available, and by a single client if so specified in the usage type. We illustrate the language via a complete example.

Implicit invocation meets safe, implicit concurrency

Writing correct and efficient concurrent programs still remains a challenge. Explicit concurrency is difficult, error prone, and creates code which is hard to maintain and debug. This type of concurrency also treats modular program design and concurrency as separate goals, where modularity often suffers. To solve these problems, we are designing a new language that we call Panini. In this paper, we focus on Panini's asynchronous, typed events which reconcile the modularity goal promoted by the implicit invocation design style with the concurrency goal of exposing potential concurrency between the execution of subjects and observers. Since modularity is improved and concurrency is implicit in Panini, programs are easier to reason about and maintain. The language incorporates a static analysis to determine potential conflicts between handlers and a dynamic analysis which uses the conflict information to determine a safe order for handler invocation. This mechanism avoids races and deadlocks entirely, yielding programs with a guaranteed deterministic semantics. To evaluate our language design and implementation we show several examples of its usage as well as an empirical study of program performance. We found that not only is developing and understanding Panini programs significantly easier compared to standard concurrent object-oriented programs, butt also performance of Panini programs is comparable to their equivalent hand-tuned versions written using Java's fork-join framework.

Contradictory graph colouring algorithm to compute slice of concurrent object-oriented programs

In this paper, we propose a dynamic program slicing technique for concurrent object-oriented programs. Our technique uses the graph colouring algorithm. But in order to compute the slices, we have contradicted some facts of the traditional graph colouring algorithm. We have used the concurrent system dependence graph as the intermediate representation for the program under consideration. The advantage of our algorithm is that it eliminates the use of trace file. Since we are incorporating graph colouring scheme, we efficiently compute the slices from a graph compared to the other existing algorithms.

A programming model for concurrent object-oriented programs

Reasoning about multithreaded object-oriented programs is difficult, due to the nonlocal nature of object aliasing and data races. We propose a programming regime (or programming model ) that rules out data races, and enables local reasoning in the presence of object aliasing and concurrency. Our programming model builds on the multithreading and synchronization primitives as they are present in current mainstream programming languages. Java or C# programs developed according to our model can be annotated by means of stylized comments to make the use of the model explicit. We show that such annotated programs can be formally verified to comply with the programming model. If the annotated program verifies, the underlying Java or C# program is guaranteed to be free from data races, and it is sound to reason locally about program behavior. Verification is modular: a program is valid if all methods are valid, and validity of a method does not depend on program elements that are not visible to the method. We have implemented a verifier for programs developed according to our model in a custom build of the Spec# programming system, and we have validated our approach on a case study.

Linking Event-B and Concurrent Object-Oriented Programs

The Event-B method is a formal approach to modelling systems, using refinement. Initial specification is done at a high level of abstraction; detail is added in refinement steps as the development proceeds toward implementation. In software systems that use concurrent processing it is necessary to provide details of concurrent features before implementation. Our contribution is to show how Event-B models can be linked to concurrent, object-oriented implementations using an intermediate, object-oriented style specification notation. To validate our approach and gain further insight we automated the translation process with an Eclipse plug-in which produces an Event-B model and Java code. We call the new notation Object-oriented Concurrent-B (OC-B). The notation facilitates specification of the concurrent aspects of a development, and facilitates reasoning about concurrency issues in an abstract manner. We abstract away implementation details, such as locking, and provide the developer with a clear view of atomicity using labelled atomic clauses. We build on techniques introduced in UML-B to model object-oriented developments, introducing non-atomic operations and features for specifying implementation level details.

Approach of concurrent object-oriented program slicing based on LTL property

An approach for slicing concurrent object-oriented programs was presented to reduce the state space in the process of program verification.The dependencies between statements in the given program were defined,and the method of extracting the slicing criterion from linear temporal logic property was introduced.The satisfaction of the verified Linear Temporal Logic(LTL) property was guaranteed for programs both before and after slicing,and the number of states in the state transition graph decreased.

A CSP model of Eiffel’s SCOOP

Abstract The current informal semantics of the simple concurrent object-oriented programming (SCOOP) mechanism for Eiffel is described. We construct and discuss a model using the process algebra CSP. This model gives a more formal semantics for SCOOP than existed previously. We implement the model mechanically via a new tool called CSPsim. We examine two semantic variations of SCOOP: when and how far to pass locks, and when to wait for child calls to complete. We provide evidence that waiting for child calls to complete both unnecessarily reduces parallelism without any increase in safety and increases deadlocks involving callbacks. Through the creation and analysis of the model, we identify a number of ambiguities relating to reservations and the underlying run-time system and propose means to resolve them.

Exceptions in Concurrent Eiffel.

We describe the problem of asynchronous exceptions in Eiffel’s Simple Concurrent Object-Oriented Programming (SCOOP). We discuss a range of possible solutions to further enable dependable computing in concurrent Eiffel. We propose a mechanism to handle aynchronous exceptions via a limited developer choice, including the notion of a failed or dead object, and necessarily introduce a small number of new exceptions. We additionally describe a number of mechanisms that were discarded as unsuitable.

Composing atomic features

SCOOP (Simple Concurrent Object-Oriented Programming) is a model of concurrency that builds on the concept of contracts for synchronizing accesses to objects. This model is based on a pessimistic concurrency control scheme whose reservation semantics avoids race conditions altogether — alas at the expense of parallelism. In this paper we propose to extend the initial SCOOP model by adding transactional semantics, aspiring to an increase of performance but also reliability of distributed object-oriented programs executing in the presence of partial failures. Our solution consists in programming language support for the specification of atomicity properties of particular features (routines or attributes). With such support, the application programmer is assisted by the compiler in composing atomic features, which substantially alleviates the task of constructing reliable distributed software. We investigate the impact of concepts such as nesting, inheritance, polymorphism, and contracts in such a statically typed approach, illustrated in the context of the Eiffel programming language. In particular, we depict how our solution enables the composition of atomic features from not only elementary atomic features (such as updates applied to variables which can be rolled back — backward recovery) but also from non-atomic ones by making use of compensation mechanisms (forward recovery).

Computing dynamic slices of concurrent object-oriented programs

We propose a novel dynamic program slicing technique for concurrent object-oriented programs. Our technique uses a Concurrent System Dependence Graph (CSDG) as the intermediate program representation. We mark and unmark the edges in the CSDG appropriately as and when the dependencies arise and cease during run-time. We mark an edge when its associated dependence exists and unmark an edge when the dependence ceases to exist. Our approach eliminates the use of trace files. Another advantage of our approach is that when a request for a slice is made, it is already available. This appreciably reduces the response time of slicing commands.

Verification and refinement with fine-grained action-based concurrent objects

Action-based concurrent object-oriented programs express autonomous behavior of objects through actions that, like methods, are attached to objects but, in contrast to methods, may execute autonomously whenever their guard is true. The promise is a streamlining of the program structure by eliminating the distinction between processes and objects and a streamlining of correctness arguments. In this paper we illustrate the use of action-based object-oriented programs and study their verification and their refinement from specifications, including the issue of non-atomic operations.

Exploiting Object Escape and Locking Information in Partial-Order Reductions for Concurrent Object-Oriented Programs

Explicit-state model checking tools often incorporate partial-order reductions to reduce the number of system states explored (and thus the time and memory required) for verification. As model checking techniques are scaled up to software systems, it is important to develop and assess partial-order reduction strategies that are effective for addressing the complex structures found in software and for reducing the tremendous cost of model checking software systems. In this paper, we consider a number of reduction strategies for model checking concurrent object-oriented software. We investigate a range of techniques that have been proposed in the literature, improve on those in several ways, and develop five novel reduction techniques that advance the state of the art in partial-order reduction for concurrent object-oriented systems. These reduction strategies are based on (a) detecting heap objects that are thread-local (i.e., can be accessed by a single thread) and (b) exploiting information about patterns of lock-acquisition and release in a program (building on previous work). We present empirical results that demonstrate upwards of a hundred fold reduction in both space and time over existing approaches to model checking concurrent Java programs. In addition to validating their effectiveness, we prove that the reductions preserve LTL−X properties and describe an implementation architecture that allows them to be easily incorporated into existing explicit-state software model checkers.

Concurrent object-oriented programming based on MPI

Object-oriented model possesses inherent concurrency. Integration of concurrency and object-orientation is a promising new field. MPI is a message-passing standard and has been adopted by more and more systems. This paper proposes a novel approach to realize concurrent object-oriented programming based on Message-passing interface (MPI) in which future method communication is adopted between concurrent objects. A state behavior set is proposed to solve inheritance anomaly, and a bounded buffer is taken as an example to illustrate this proposal. The definition of ParaMPI class, which is the most important class in the concurrent class library, and implementation issues are briefly described.

Concurrent Object-Oriented Programming: The MP-Eiffel Approach.

In this article a new concurrent object-oriented programming language is presented. This language ‐ named MP-Eiffel (Multi-Processor Eiffel) ‐ is developed as an extension to the sequential object-oriented language Eiffel. This choice is not accidental. Eiffel’s powerful, safe, and simple object-oriented semantics proved to be an excellent framework to introduce concurrency mechanisms. The choices made for the language concurrent mechanisms, and their semantics, resulted from an attempt to provide a safe and simple integration of the essential properties of both worlds: concurrent and sequential object-oriented programming. In section 2 the essential characteristics, requirements, problems, and elementary solutions of concurrent programming are briefly reviewed. Object-oriented sequential programming is then briefly introduced, giving emphasis to its fundamental and useful properties. Since this work is about creating programming language mechanisms, some important language design rules are enumerated and succinctly justified. Those rules will be used to justify the choices made in MP-Eiffel. Several existing possibilities for integrating concurrency in an object-oriented language are presented and evaluated in section 4. A special care is taken to study the conditions under which unsafe interference may arise from the joint use of some mechanisms, such as the well known problem of “inheritance anomalies”. It is shown that such problems can be prevented without compromising neither of the essential properties of both worlds.

SECG: The SCOOP-to-Eiffel Code Generator.

The Simple Concurrent Object-Oriented Programming (SCOOP) mechanism introduces inter-object concurrency to the Eiffel language, via addition of one new keyword, separate. We describe a general tool that takes a Eiffel program that uses the separate keyword and translates it into an Eiffel multi-threaded program that uses the Eiffel T HREAD class. The resulting code is thereafter compatible with EiffelStudio and any other Eiffel compiler that provides the T HREAD class.

An efficient scheme for accepting recursive method calls in object‐oriented concurrent programming

AbstractWith object‐oriented concurrent programming languages that perform mutual exclusion at the level of objects, deadlock can easily occur due to recursive method calls. We propose a transparent mechanism to programmers called the Key/Lock method, which enables recursive method calls by eliminating recursion deadlock. The Key/Lock method assigns keys, which are uniquely associated with exclusive methods, to messages and especially accepts messages to which these keys are appended. This technique, which can reduce the overhead that accompanies message transmission and reception compared with conventional research techniques, is particularly effective when there are numerous thread branches. We incorporated the Key/Lock method in the concurrent programming language SR and performed performance evaluations to verify the effectiveness of this technique. © 2003 Wiley Periodicals, Inc. Syst Comp Jpn, 34(14): 101–109, 2003; Published online in Wiley InterScience (www.interscience.wiley.com). DOI 10.1002/scj.1226