An Object-Oriented Model for Extensible Concurrent Systems: the Composition-Filters Approach

Applying the object-oriented paradigm for the development of large and complex software systems offers several advantages, of which increased extensibility and reusability are the most prominent ones. The object-oriented model is also quite suitable for modeling concurrent systems. However, it appears that extensibility and reusability of concurrent applications is far from trivial. The problems that arise, the so-called inheritance anomalies are analyzed and presented in this paper. A set of requirements for extensible concurrent languages is formulated. As a solution to the identified problems, an extension to the object-oriented model is presented; composition filters. Composition filters capture messages and can express certain constraints and operations on these messages, for example buffering. In this paper we explain the composition filters approach, demonstrate its expressive power through a number of examples and show that composition filters do not suffer from the inheritance anomalies and fulfill the requirements that were established

Examples of Reusing Synchronization Code in Aspect-Oriented Programming using Composition Filters

Applying the object-oriented paradigm for the development of large and complex software systems offers several advantages, of which increased extensibility and reusability are the most prominent ones. The object-oriented model is also quite suitable for modeling concurrent systems. However, it appears that extensibility and reusability of concurrent applications is far from trivial. The problems that arise, the so-called inheritance anomalies or crosscutting aspects have been extensively studied in the literature. As a solution to the synchronization reuse problems, we present the composition-filters approach. Composition filters can express synchronization constraints and operations on objects as modular extensions. In this paper we briefly explain the composition filters approach, demonstrate its expressive power through a number of examples and show that composition filters do not suffer from the inheritance anomalies

ATAMM analysis tool

Diagnostics software for analyzing Algorithm to Architecture Mapping Model (ATAMM) based concurrent processing systems is presented. ATAMM is capable of modeling the execution of large grain algorithms on distributed data flow architectures. The tool graphically displays algorithm activities and processor activities for evaluation of the behavior and performance of an ATAMM based system. The tool's measurement capabilities indicate computing speed, throughput, concurrency, resource utilization, and overhead. Evaluations are performed on a simulated system using the software tool. The tool is used to estimate theoretical lower bound performance. Analysis results are shown to be comparable to the predictions

Symbolically Modeling Concurrent MCAPI Executions

Improper use of Inter-Process Communication (IPC) within concurrent systems often creates data races which can lead to bugs that are challenging to discover. Techniques that use Satisfiability Modulo Theories (SMT) problems to symbolically model possible executions of concurrent software have recently been proposed for use in the formal verification of software. In this work we describe a new technique for modeling executions of concurrent software that use a message passing API called MCAPI. Our technique uses an execution trace to create an SMT problem that symbolically models all possible concurrent executions and follows the same sequence of conditional branch outcomes as the provided execution trace. We check if there exists a satisfying assignment to the SMT problem with respect to specific safety properties. If such an assignment exists, it provides the conditions that lead to the violation of the property. We show how our method models behaviors of MCAPI applications that are ignored in previously published techniques

Research and implementation of integrated concurrent software development environment based on Object-Oriented Petri Nets

While network technologies and environments get more and more popular, the demand for concurrent systems becomes stronger and stronger. But the characteristics of concurrency make it difficult to develop them. This dissertation combines Object-Oriented technology and Petri Nets theory, and put forth OOPN (OO Petri Nets) model to describe concurrent systems. Based on the research of conventional development methods of concurrent software, this article advances a new one, which integrates specification, validation and auto-generating codes. Accordingly, an integrated development environment for concurrent software, i.e., OOPN-IDE, comes into being, which mainly includes the following four tools: the concurrent system modeling tool in either graphics mode or text mode, multi-user modeling coordinator, the concurrent system simulator and enactor, the concurrent system deadlock detector. This dissertation contains the following innovations: 1) Combine OO and Petri Nets. Especially, it is described how OO is benefited from Petri Nets. 2) Petri Nets support the whole cycle of modeling, simulation and enaction. Petri Net structures are kept in generated programs rather than being translated into program structures in the traditional way. The execution of the concurrent programs is based on the firing of the transitions in net models. Thus, we can monitor and control the systems in the view of Petri Nets. 3) Multi users can model coordinately. OOPN-IDE uses a client/server architecture. Multi clients can be involved in a single model simultaneously. The possibility of developing large systems is seen. 4) OOPN-IDE is cross-platform. OOPN-IDE is based on Java and can be used on multi operating systems. It has been tested and appraised by experts in a heterogeneous environment involving Windows 95/98/NT and Solaris 2.x. 5) The future work is discussed

Formal Object Interaction Language: Modeling and Verification of Sequential and Concurrent Object-Oriented Software

As software systems become larger and more complex, developers require the ability to model abstract concepts while ensuring consistency across the entire project. The internet has changed the nature of software by increasing the desire for software deployment across multiple distributed platforms. Finally, increased dependence on technology requires assurance that designed software will perform its intended function. This thesis introduces the Formal Object Interaction Language (FOIL). FOIL is a new object-oriented modeling language specifically designed to address the cumulative shortcomings of existing modeling techniques. FOIL graphically displays software structure, sequential and concurrent behavior, process, and interaction in a simple unified notation, and has an algebraic representation based on a derivative of the π-calculus. The thesis documents the technique in which FOIL software models can be mathematically verified to anticipate deadlocks, ensure consistency, and determine object state reachability. Scalability is offered through the concept of behavioral inheritance; and, FOIL’s inherent support for modeling concurrent behavior and all known workflow patterns is demonstrated. The concepts of process achievability, process complete achievability, and process determinism are introduced with an algorithm for simulating the execution of a FOIL object model using a FOIL process model. Finally, a technique for using a FOIL process model as a constraint on FOIL object system execution is offered as a method to ensure that object-oriented systems modeled in FOIL will complete their processes based activities. FOIL’s capabilities are compared and contrasted with an extensive array of current software modeling techniques. FOIL is ideally suited for data-aware, behavior based systems such as interactive or process management software

Concurrent system design: Applied mathematics & modeling in software engineering education

A hallmark of engineering design is the use of models to explore the consequences of design decisions. Sometimes these models are physical prototypes or informal drawings, but the sine qua non of contemporary practice is the use of formal, mathematical models of system structure and behavior. Whether circuit models in electrical engineering, heat-transfer models in mechanical engineering, or queuing theory models in industrial engineering, mathematics makes it possible to perform rigorous analysis that is the cornerstone of modern engineering. Until recently, such modeling was impractical for software systems. Informal models abounded, such as those created in UML1, but rigorous models from which one could derive significant properties were either so rudimentary or so tedious to use that it was difficult to justify the incremental benefit in other than the most critical of systems. In part this is a reflection of the relative immaturity of software engineering, but it also reflects a key distinction between software and traditional engineering: whereas the latter builds on numerical computation and continuous functions, software is more appropriately modeled using logic, set theory, and other aspects of discrete mathematics. Most of the models stress relationships between software components, and numerical computation is the exception rather than the norm. Recent advances in both theory and application have made it possible to model significant aspects of software behavior precisely, and to use tools to help analyze the resulting properties2,3,4. In this paper, we focus on a course developed by James Vallino and since taught and modified by Michael Lutz, to present formal modeling to our software engineering students at RIT. Our overall goals were three-fold: To acquaint our students with modern modeling tools, to connect the courses they take in discrete mathematics to real applications, and to persuade them that mathematics has much to offer to the engineering of quality software

Modeling behavioral design patterns of concurrent objects

ABSTRACT Object-oriented software development practices are being rapidly adopted within increasingly complex systems, including reactive, real-time and concurrent system applications. While data modeling is performed very well under current objectoriented development practices, behavioral modeling necessary to capture critical information in real-time, reactive, and concurrent systems is often lacking. Addressing this deficiency, we offer an approach for modeling and analyzing concurrent object-oriented software designs through the use of behavioral design patterns, allowing us to map stereotyped UML objects to colored Petri net (CPN) representations in the form of reusable templates. The resulting CPNs are then used to model and analyze behavioral properties of the software architecture, applying the results of the analysis to the original software design

Logic-Based Specification Languages for Intelligent Software Agents

The research field of Agent-Oriented Software Engineering (AOSE) aims to find abstractions, languages, methodologies and toolkits for modeling, verifying, validating and prototyping complex applications conceptualized as Multiagent Systems (MASs). A very lively research sub-field studies how formal methods can be used for AOSE. This paper presents a detailed survey of six logic-based executable agent specification languages that have been chosen for their potential to be integrated in our ARPEGGIO project, an open framework for specifying and prototyping a MAS. The six languages are ConGoLog, Agent-0, the IMPACT agent programming language, DyLog, Concurrent METATEM and Ehhf. For each executable language, the logic foundations are described and an example of use is shown. A comparison of the six languages and a survey of similar approaches complete the paper, together with considerations of the advantages of using logic-based languages in MAS modeling and prototyping.Comment: 67 pages, 1 table, 1 figure. Accepted for publication by the Journal "Theory and Practice of Logic Programming", volume 4, Maurice Bruynooghe Editor-in-Chie

An Instance-Based Structured Object Oriented Method for Co-Analysis/Co-Design of Concurrent Embedded Systems

The current object-oriented class-based approaches to hardware/software co-analysis/co-design of embedded systems are limited in their abilities to properly capture the structure of individual instances of hardware and software components and their interactions. This paper discusses a methodology to extend a structured objectoriented hardware/software co-design methodology based on the High Order Object-oriented Modeling Technique (HOOMT) to incorporate instance-based object and behavioral models. The instance-based structured object-oriented methodology will enable description of a system\u27s structure based on individual instances of hardware and software components and specification of the interactions among them. In addition, lattices are introduced to specify the concurrent behavior of hardware/software components in a concurrent embedded system. These additions further enhance the method\u27s capability of providing a precise set of specifications that can be understood easily by both hardware and software designers in co-analysis/codesign. The methodology has been applied to the specification of hardware and software of a simulated advanced power grid control system