Concurrent Object-oriented Systems Research Articles

Narrowing and heuristic search for symbolic reachability analysis of concurrent object-oriented systems

A concurrent system specified as a rewrite theory can be analyzed symbolically using narrowing-based reachability analysis. Narrowing-based approaches have been applied to formally analyze cryptographic protocols and parameterized protocols. However, existing narrowing-based analysis methods, based on a breadth-first-search strategy, cannot deal with generic distributed systems with objects and messages due to the symbolic state-space explosion problem and implicit constraints imposed on object-oriented systems. This paper proposes a heuristic search approach for narrowing-based reachability analysis to guide the search for counterexamples with a small number of objects. As a result, our method can effectively find a counterexample if an error state is reachable. In addition, this paper also shows how to encode implicit object-oriented constraints using order-sorted signatures and equational constraints. We demonstrate the effectiveness of our technique using a nontrivial distributed consensus algorithm.

Compositional reasoning about active objects with shared futures

Abstract Distributed and concurrent object-oriented systems are difficult to analyze due to the complexity of their concurrency, communication, and synchronization mechanisms. The future mechanism extends the traditional method call communication model by facilitating sharing of references to futures. By assigning method call result values to futures, third party objects may pick up these values. This may reduce the time spent waiting for replies in a distributed environment. However, futures add a level of complexity to program analysis, as the program semantics becomes more involved. This paper presents a model for asynchronously communicating objects, where return values from method calls are handled by futures. The model facilitates invariant specifications over the locally visible communication history of each object. Compositional reasoning is supported and proved sound, as each object may be specified and verified independently of its environment. A kernel object-oriented language with futures inspired by the ABS modeling language is considered. A compositional proof system for this language is presented, formulated within dynamic logic.

A sound and complete reasoning system for asynchronous communication with shared futures

Distributed and concurrent object-oriented systems are difficult to analyze due to the complexity of their concurrency, communication, and synchronization mechanisms. We consider the setting of concurrent objects communicating by asynchronous method calls. The future mechanism extends the traditional method call communication model by facilitating sharing of references to futures. By assigning method call result values to futures, third party objects may pick up these values. This may reduce the time spent waiting for replies in a distributed environment. However, futures add a level of complexity to program analysis, as the program semantics becomes more involved.This paper presents a Hoare style reasoning system for distributed objects based on a general concurrency and communication model focusing on asynchronous method calls and futures. The model facilitates invariant specifications over the locally visible communication history of each object. Compositional reasoning is supported, and each object may be specified and verified independently of its environment. The presented reasoning system is proven sound and (relatively) complete with respect to the given operational semantics.

Model Checking and Code Generation for UML Diagrams Using Graph Transformation

UML is considered as the standard for object -oriented modelling language adopted by the Object Management Group. However, UML has been criticized due to the lack of formal semantics and the ambiguity of its models. In other hands, UML models can be mathematically verified and checked by using its equivalent formal representation.So, in this paper, we proposean approach and a tool based on graph transformation to perform an automatic mappingfor verification purposes. This transformation aims to bridge the gap between informal and formal notation s and allows a formal verification of concurrent UML models using Maude language. We consider both static (Class Diagram) and dynamic (StateChart and Communication Diagrams)features of concurrent object-oriented system. Then, we use Maude LTL Model Checker to verify the formal model obtained (Automatic Code GenerationMaude). The meta-modelling AToM 3 tool is used. A case study is presented to illustrate our approach.

Observable behavior of distributed systems: Component reasoning for concurrent objects

Distributed and concurrent object-oriented systems are difficult to analyze due to the complexity of their concurrency, communication, and synchronization mechanisms. Rather than performing analysis at the level of code in, e.g., Java or C++, we consider the analysis of such systems at the level of an abstract, executable modeling language. This language, based on concurrent objects communicating by asynchronous method calls, avoids some difficulties of mainstream object-oriented programming languages related to compositionality and aliasing. To facilitate system analysis, compositional verification systems are needed, which allow components to be analyzed independently of their environment. In this paper, a proof system for partial correctness reasoning is established based on communication histories and class invariants. A particular feature of our approach is that the alphabets of different objects are completely disjoint. Compared to related work, this allows the formulation of a much simpler Hoare-style proof system and reduces reasoning complexity by significantly simplifying formulas in terms of the number of needed quantifiers. The soundness and relative completeness of this proof system are shown using a transformational approach from a sequential language with a non-deterministic assignment operator.

Concurrent Object-Oriented Expert System Framework for Fault Diagnosis in the Microprocessor based System

The paper presents a concurrent fault diagnostic expert system framework. The framework is characterised by two basic features. The first includes a concurrent fault diagnostic strategy, which utilises fault isolation and diagnostic knowledge about unit under test. The second characteristic is object-oriented inference mechanism using simultaneous message passing using multithreading. Object orientation in inference mechanism has improved inference efficiency. The degree of accuracy to which faults are located is improved using fault isolation knowledge. The developed framework is evaluated for its effectiveness and superiority compared with earlier approaches using case studies.

Applying Model Checking to Concurrent UML Models.

We present, in this paper, a framework supporting a formal verification of concurrent UML models using the Maude language. We consider both static and dynamic features of concurrent object-oriented systems. We focus on UML class, state and communication diagrams. The formal and object-oriented language Maude, based on rewriting logic, supports formal specification and programming of concurrent systems, as well as model checking. The major motivations of this work are: (1) translating concurrent UML diagrams into a Maude formal specification and (2) applying model checking to the generated specifications. The approach is illustrated using a concrete case study.

Formal Verification of Object-Oriented Graph Grammars Specifications

Concurrent object-oriented systems are ubiquitous due to the importance of networks and the current demands for modular, reusable, and easy to develop software. However, checking the correctness of such systems is a hard task, mainly due to concurrency and inheritance aspects. In this paper we present an approach to the verification of concurrent object-oriented systems. We use graph grammars equipped with object oriented features (including inheritance and polymorphism) as the specification formalism, and define a translation from such specifications to Promela, the input language of the SPIN model checker.

Exclusion requirements and potential concurrency for composite objects

Concurrent object-oriented systems must prevent the interference that may arise when multiple threads simultaneously access shared components. We present a simple approach for implementing flexible locking strategies in an object-oriented system, in which the components themselves may be composite objects. We express exclusion requirements as sets of conflict pairs on component interfaces. Given knowledge of the dependency between the interface of a composite object and its internal components, we show how external exclusion requirements can be calculated from internal requirements, and further, how any potential concurrent activity outside an object can be projected into potential concurrency for the internal components. With our approach we can defer the distribution of locks in the system until deployment: the placement of locks and choice of lock type for a component can depend on its operating environment. A Galois connection between the outward mapping of exclusion requirements, and the inward mapping of potential concurrency, limits how many locks are worth considering. In this paper we only deal with exclusion control, including mutexes, read–write locks and read–write sets, and do not cover state-dependent locking or transaction-based approaches.

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.

Extending the object model to provide explicit support for crosscutting concerns

AbstractConcurrent systems tend to have certain properties that are not localized in single modular units, but their implementations cut across functional components, increasing coupling and making modular units difficult to reuse and adapt. Example properties include concurrency, synchronization, and authentication. This problem is particularly apparent in systems with evolving requirements, as adapting code that is not localized in single modular units proves to be a tedious process. In this paper we discuss issues related to requirements of concurrent software systems to provide explicit support for these cross‐cutting concerns, and we present the Aspect Moderator, a framework extension to the object model that can ease the development of concurrent object‐oriented systems. Copyright © 2002 John Wiley & Sons, Ltd.

Design principles for highly reusable concurrent object-oriented systems.

Designing a concurrent object oriented language isn’t an easy task. After many years of research, the merging of concurrency and object oriented paradigms hasn’t been achieved in a totally satisfactory way. Although recent models have partly solved important problems such as the inheritance anomaly, they do still present limitations due to the lack of reusability and adaptability. Approaches based on separation of concerns appear to point to the development of models which achieve effectively those requirements. In this essay we argu e that the establishment of orthogonal design principles should be useful in this respect, as it was in other fields of object systems research. We‘ll propose these principles basing on well-known principles of design of programming languages and orthogonal persistence. In order to show the adequacy of these principles, we present CoJava, a model based on the separation of concurrent and functional aspects by means of their implementation in different component classes and their composition at runtime. CoJava has been designed applying our principles to offer a high degree of orthogonality , which results in better reusability than previous models.

State inference for dynamically changing interfaces

Types in current programming languages specify constant sets of messages always acceptable throughout the lifetime of the types’ instances. However, especially in concurrent object-oriented systems, the acceptability of messages often changes with the objects’ states. We propose a typed concurrent object calculus where static type checking ensures that users send only acceptable messages although message acceptability may change dynamically. The programmer specifies in types predictable state changes and dependences of message acceptance on states; a compiler infers the needed state information. This state inference has polynomial time complexity and can be used together with subtyping.

A pragmatic behavior subtyping relation based on both states and actions

A behavior preserving relation between Petri-net systems is introduced in this paper, based on the observability of both places and transitions, which is important in modeling the dynamic behavior of concurrent object-oriented systems with Petri nets. Each group of closely related attributes of a concurrent object is modeled by the state of a collection of observable places, and each of its methods by a group of observable transitions. The grouping distinguishes the definition in this paper from others, which makes it easy to work together with the static object models, to reuse the models and to dispel the interference among groups, thus relieving the problem of inheritance anomaly by the possibility of dividing the synchronization code into independent parts. For a formal definition of this behavior subtyping relation, Elementary Net systems, with both S-elements and T-elements labeled, are used. Then it is extended informally to the state based coloured Petri net systems. Finally, the background of the definitions and the future work are presented.

Visual Programming of Concurrent Object-Oriented Systems

In order to be able to understand the functionality of even small concurrent systems, visual and formally-based notations for their description are needed. The handling of complex systems additionally demands for notations offering adequate structuring capabilities. From a theoretical point of view the combination of Petri-Nets and object-oriented concepts is a promising approach in this area. Despite their potential, only few of the existing object-oriented Petri-Net proposals support the seamless development of systems ranging from high-level analysis to visual programming. This article introduces a set of essential properties for approaches in the area of object-oriented Petri-Nets and briefly surveys the common problems of existing work. Afterwards OOPr/T-Models, a novel approach intended to overcome the limitations of existing ones, are introduced. Their practical use as visual programming language for the description of (concurrent) object-oriented systems is shown with an example for the rendering of fractal images.

Ninflet: a migratable parallel objects framework using Java

Ninflet is a Java-based global computing system that builds on our experiences with the Ninf system which facilitated RPC-based computing of numerical tasks in a wide-area network. The goal of Ninflet is to become a new generation of concurrent object-oriented systems which harness abundant idle computing powers, and also seamlessly integrate global as well as local network parallel computing. Ninflet is designed to make use of Java features to implement important features in global computing, such as resource allocation, inter-Ninflet communication, security, checkpointing, object migration, and easy server management via HTTP. © 1998 John Wiley & Sons, Ltd.

COCOON

The software engineering techniques of reuse, encapsulation and information hiding are increasingly being employed in the construction of large, concurrent software systems. Simultaneously, hardware platforms continue to increase in sophistication, particularly in the area of concurrency. Thus, systems engineers are confronted with the problem of bridging the gap between (1) large computer-based software systems composed of tasks and ADTs/objects and (2) parallel and distributed computer platforms. Thus, this paper describes the COCOON (Creator Of Concurrent Object-OrieNted Systems) toolset. COCOON bridges the gap between object-oriented Ada software and distributed architectures. It partitions tasks, packages and subprograms, and assigns partitions to physical processors. The toolset automatically produces a distribution specification.

CORAL: a concurrent object-oriented system for constructing and executing sequential, parallel and distributed applications

This article briefly describes the objectives, approach, major features, and current status of CORAL (Concurrent Object-oRiented Application Language). CORAL is a programming system that permits the construction and execution of sequential, parallel and distributed applications in a transparent manner. It is based on a concurrent object-oriented model of computation in which concurrent objects may execute sequentially in a single processor, in parallel over shared-memory multiprocessors, or distributively over multicomputer networks. In addition, methods within an object may execute in parallel over shared-memory multiprocessors.