Concurrent Object-oriented Language 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 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.

Observable interface behaviour and inheritance

This paper formalizes the observable interface behaviour ofopensystems for a strongly-typed, concurrent object-oriented language with single-class inheritance. We formally characterize the observable behaviour in terms of interactions at the program-environment interface. The behaviour is given by transitions between contextual judgments, where the absent environment is represented abstractly as assumption context. A particular challenge is the fact that, when the system is considered as open, code from the environment can be inherited to the component and vice versa. This requires to incorporate an abstract version of the heap into the environment assumptions when characterizing the interface behaviour. We prove the soundness of the abstract interface description.

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.

A type and effect system for deterministic parallel Java

Today's shared-memory parallel programming models are complex and error-prone.While many parallel programs are intended to be deterministic, unanticipated thread interleavings can lead to subtle bugs and nondeterministic semantics. In this paper, we demonstrate that a practical type and effect system can simplify parallel programming by guaranteeing deterministic semantics with modular, compile-time type checking even in a rich, concurrent object-oriented language such as Java. We describe an object-oriented type and effect system that provides several new capabilities over previous systems for expressing deterministic parallel algorithms.We also describe a language called Deterministic Parallel Java (DPJ) that incorporates the new type system features, and we show that a core subset of DPJ is sound. We describe an experimental validation showing thatDPJ can express a wide range of realistic parallel programs; that the new type system features are useful for such programs; and that the parallel programs exhibit good performance gains (coming close to or beating equivalent, nondeterministic multithreaded programs where those are available).

System Prototype and Verification Using Metamodel-Based Transformations

Mapping domain-specific languages' core concepts into the concurrent object-oriented Petri nets formal specification language provides users with the semantics necessary for developing prototypes for these DSLs. Different knowledge domains demand different types of support from software languages. Domain engineers often use domain-specific languages to overcome this problem. DSLs are difficult to design, implement, and maintain and are often less efficient than hand-coded software. To address some of these problems, we propose transforming a DSL into the concurrent object-oriented Petri nets formalism. The DSL metamodel serves as the transformation's starting point. The transformation represents the semantic mapping between the DSL and CO-OPN. We aim both to provide a formally defined semantics for the DSL and, because we integrate CO-OPN in a framework, to provide the functionalities that allow model verification and fast prototype generation for the DSL

Guest Editor's Introduction: Rapid System Prototyping

The March, April, and May 2007 issues of IEEE Distributed Systems Online feature revised versions of the best papers presented at the 17th International IEEE Workshop on Rapid System Prototyping (RSP 06). These articles were selected by reviewers from a large selection of excellent submissions. In this month's issue, we present "System Prototype and Verification Using Metamodel-Based Transformations" by Luis Pedro, Levi Lucio, and Didier Buchs. The article discusses how mapping domain-specific languages' core concepts into the Concurrent Object-Oriented Petri Nets formal specification language can provide users with the semantics necessary for developing prototypes for these DSLs.

A Survey of Concurrent Object-oriented Languages (Cools)

A Survey of Concurrent Object-oriented Languages (Cools)

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.

Interfacing Software Libraries from Nondeterministic Prototypes

Modeling software systems is one of the most obvious uses of a formal specification language. A software prototype, automatically generated from the specification, enables the developer to validate the system in a real environment. However, real software systems are seldom developed from scratch, but rather built using existing libraries. In this paper, we show how a program based on existing software libraries is modeled in the Concurrent Object-Oriented Petri Net specification language, and how a prototype code is generated from the specification. In particular, we study the interface between nondeterminist synchronous prototypes and determinist asynchronous software libraries. We take into account, problems related with nonreversibility of actions and the transactional semantics of the specification language that is kept in the prototypes. A convenient delayed execution mechanism is proposed for the library linking part of the generated code.

BCOOPL: A Language for Controlling Component Interactions

This paper introduces BCOOPL, which stands for Basic Concurrent Object-Oriented Programming Language. BCOOPL was designed to support component-based development. In particular, it focuses on the specification of weakly-coupled components and the specification of interaction sequences between them. BCOOPL supports two design patterns directly. The built-in observer design pattern encourages the construction of weakly-coupled components. Its support for the mediator design pattern allows to govern the interactions between those components. These language features cater for the design and implementation of flexible systems in which specifications of individual component behavior is separated from specifications of component interactions. A high level overview of BCOOPL's key concepts is given, which are exemplified by means of a process control example.

Solving inheritance anomaly with OMNets

This paper presents a concurrent object-oriented modeling language based on Petri nets: OMNets, which helps greatly to avoid the inheritance anomaly problem appeared in concurrent OO languages. OMNets separates the functional part and the synchronization part of objects and uses Petri nets to describe the synchronization part. Both parts are reusable through inheritance.

A two-layered-class approach for the reuse of synchronization code

In concurrent object-oriented languages, the inheritance anomaly is an important and difficult problem which makes synchronization code difficult to reuse. Based on the two-layered-class model, this paper proposes a new approach to provide flexible and sufficient support for the reuse of synchronization code.

Support for Implementation of Evolutionary Concurrent Systems

Concurrent programs that embed specifications of synchronizations in the body of their component are difficult to extend and modify. Small changes in a concurrent program, particularly changes in the interactions among components, may require re-implementation of a large number of components. Even specifications of components cannot be reused easily. This paper presents a concurrent program composition mechanism in which both specification and implementation of computations and interactions are completely separated. Separation of specifications and implementations facilitates extensions and modifications of programs by allowing one to separately change the implementations of computations and interactions. It also supports their reusability. The paper also describes the design and implementation of a concurrent object-oriented programming language based on this model, including a compiler for the language, and reports on the execution behavior of programs written in the language.

BCOOPL: Basic concurrent object-oriented programming language

A small, object-oriented language is introduced: BCOOPL (Basic Concurrent Object-Oriented Programming Language). This language is specifically targeted to support component-oriented programming. The main design goal of BCOOPL was to provide a small, but powerful set of language features that supports the construction of high-quality components through well-established software engineering practices, which include the separation of interfaces and implementations, weakly-coupled objects, and abstraction. A number of design patterns based on these principles is actually built in the language. In particular, the observer, the mediator and the bridge are supported directly. This provides a strong foundation on which higher level component specification languages can be built. BCOOPL has a long research history. Its roots can be traced back to path expressions, and the concurrent object-oriented programming languages Procol and Talktalk. As a result, BCOOPL only integrates essential language features that blend well and have proven their value in practice. Copyright © 2000 John Wiley & Sons, Ltd.

A survey of concurrent object-oriented languages

SUMMARY During the last decade object-oriented programming has grown from marginal influence into widespread acceptance. During the same period, progress in hardware and networking has changed the computing environment from sequential to parallel. Multi-processor workstations and clusters are now quite common. Unnumbered proposals have been made to combine both developments. Always the prime objective has been to provide the advantages of object-oriented software design at the increased power of parallel machines. However, combining both concepts has proven to be notoriously difficult. Depending on the approach, often key characteristics of either the object-oriented paradigm or key performance factors of parallelism are sacrificed, resulting in unsatisfactory languages. This survey first recapitulates well-known characteristics of both the object-oriented paradigm and parallel programming, and then marks out the design space of possible combinations by identifying various interdependencies of key concepts. The design space is then filled with data points: for 111 proposed languages we provide brief characteristics and feature tables. Feature tables, the comprehensive bibliography, and web-addresses might help in identifying open questions and preventing re-inventions. Copyright © 2000 John Wiley & Sons, Ltd.

An efficient meta-lock for implementing ubiquitous synchronization

Programs written in concurrent object-oriented languages, especially ones that employ thread-safe reusable class libraries, can execute synchronization operations (lock, notify, etc.) at an amazing rate. Unless implemented with utmost care, synchronization can become a performance bottleneck. Furthermore, in languages where every object may have its own monitor, per-object space overhead must be minimized. To address these concerns, we have developed a meta-lock to mediate access to synchronization data. The meta-lock is fast (lock + unlock executes in 11 SPARC™ architecture instructions), compact (uses only two bits of space), robust under contention (no busy-waiting), and flexible (supports a variety of higher-level synchronization operations). We have validated the meta-lock with an implementation of the synchronization operations in a high-performance product-quality Java™ virtual machine and report performance data for several large programs.

Efficient logic variables for distributed computing

We define a practical algorithm for distrubuted rational tree unification and prove its correctness in both the off-line and on-line cases. We derive the distributed algorithm from a centralized one, showing clearly the trade-offs between local and distributed execution. The algorithm is used to realize logic variables in the Mozart Programming System, which implements the Oz language (see http://www/mozart-oz.org). Oz appears to the programmer as a concurrent object-oriented language with dataflow synchronization. Logic variables implement the dataflow behavior. We show that lohgic variables can easily be added to the more restricted models of Java and ML, thus providing an alternative way to do concurent programming in these languages. We present common distributed programming idioms in a network-transparent way using logic variables. We show that in common cases the algorithm maintains the same message latency as explicit message passing. In addition, it is able to handle uncommon cases that arise from the properties of latency tolerance and third-party independence. This is evidence that using logic variables in distributed computing is beneficial at both the system and language levels. At the system level, they improve latency tolerance and third-party independence. At the language level, they help make network-transparent distribution practical.

Matisse: a system-on-chip design methodology emphasizing dynamic memory management

Matisse is a design environment intended for developing systems characterized by a tight interaction between control and data-flow behavior, intensive data storage and transfer and stringent real-time requirements. Matisse bridges the gap from a system specification, using a concurrent object-oriented language, to an optimized embedded single-chip hardware/software implementation. Matisse supports stepwise exploration and refinement of dynamic memory management, memory architecture exploration, and gradual incorporation of timing constraints before going to traditional tools for hardware synthesis, software compilation, and inter-processor communication synthesis. With this approach, specifications of embedded systems can be written in a high-level programming language using data abstraction. Application of Matisse on telecom protocol processing systems in the ATM area shows significant improvements in area usage and power consumption.

The ClassiC programming language and design of synchronous concurrent object oriented languages

Many real-time systems make use of concurrent programming systems and are often designed using object oriented design methods. Concurrent Object Oriented Languages (COOLS) are a class of programming language that integrates the facilities of concurrent and object oriented programming in an integrated rather than orthogonal manner. With the increasing interest in the use of object oriented languages such as C++ for the programming of embedded and real-time systems COOLs seem to be a natural candidate for such tasks. Several COOLs have been described in the literature which address the requirements of concurrent programming, inter-process communication (IPC) and synchronisation in various different ways. This paper discusses one such language, ClassiC, and examines the approach to this problem taken in its design. In particular, it is shown that the features of ClassiC allow derivation of active classes from other active classes. It is shown how this property can be used to overcome some of the problems associated with synchronous IPC schemes while maintaining the advantages of them and how the use of the asynchronous IPC model allows verification of synchronisation and deadlock properties based on the use of CSP methods.