Petri net-based analysis on object assignment in distributed object-oriented systems

Object-oriented programming ^[9], which treats objects as processes in execution, has shown significant effectiveness in distributed systems. This effectiveness is greatly influenced by how objects are assigned to nodes. In this paper, we present a colored generalized stochastic Petri net (CGSPN) model to analyze the behavior of object invocations when an assignment strategy is applied. The effectiveness of an object assignment is also analyzed by our CGSPN model. Moreover, this analysis provides guidelines to develop an efficient object assignment strategy. ^[4–8]     

Modeling and analysis of scheduling for distributed real-time embedded systems

Aimed at the deficiencies of resources based time Petri nets (RBTPN) in doing scheduling analysis for distributed real-time embedded systems, the assemblage condition of complex scheduling sequences is presented to easily compute scheduling length and simplify scheduling analysis. Based on this, a new hierarchical RBTPN model is proposed. The model introduces the definition of transition border set, and represents it as an abstract transition. The abstract transition possesses all resources of the set, and has the highest priority of each resource; the execution time of abstract transition is the longest time of all possible scheduling sequences. According to the characteristics and assemblage condition of RBTPN, the refinement conditions of transition border set are given, and the conditions ensure the correction of scheduling analysis. As a result, it is easy for us to understand the scheduling model and perform scheduling analysis.     

An object-oriented tool for simulating distributed real-time control systems

This paper presents an object-oriented software tool, called RTSIM, aimed at simulating real-time embedded controllers. The tool consists of a collection of C++ libraries permitting a separate specification of the functional behaviour of the controller and of the hardware/software architecture to be used for its deployment. In particular, it is possible to provide an accurate modelling of the concurrent architecture of the control tasks and of the run-time support offered by the operating system for the real-time scheduling of the shared resources (CPU, memory buffers and network links). In this way, it is possible to compare different scheduling solutions by evaluating their simulated performance directly in the domain of the control application. Moreover, the tool can be utilized to tune up design parameters such as the activation frequencies of the tasks. The application of the tool is shown in a meaningful case study. Copyright © 2002 John Wiley & Sons, Ltd.     

Virtual prototyping of automated manufacturing systems with Geometry-driven Petri nets

The design process of automated manufacturing systems typically involves physical prototypes to validate the interactions between hardware and software components. However, physical prototyping is expensive and time consuming, which often leads to insufficient opportunities for testing early during the development cycle. Our objective is to improve this situation by providing a method to develop realistic prototypes using virtual reality technology that can be applied during earlier development stages. Our approach combines a virtual reality engine capable of enacting the laws of rigid body physics with a new hybrid software modelling language to control the simulated hardware using virtual sensors and actuators as they would be present in a physical prototype. The new modelling language is called Geometry-driven Petri nets (GPN) and combines a class of timed, high-level Petri nets with data structures used in state-of-the-art VR environments. This article describes the new GPN approach, applies it to a case study of an automated manufacturing line, and compares it with related approaches.     

UM-RTCOM: An analyzable component model for real-time distributed systems

Component-based development is a key technology in the development of software for modern real-time systems. However, standard component models and tools are not suitable for this type of system, since they do not explicitly address real time, memory or cost constraints. This paper presents a new predictable component model for real-time systems (UM-RTCOM) together with a set of tools to support it. The environment allows new components to be developed which can then be assembled to build complete applications, including hardware interaction. The model includes support for real-time analysis at the component and application level. The analysis is achieved by combining component meta-information in the form of an abstract behaviour model and a method to measure worst-case execution times in the final platform. Additionally, we propose an implementation model based on RT-CORBA where the developer uses the UM-RTCOM components and a set of tools to map these elements to elements of the desired platform. In order to apply our proposals, we have used the model and tools in real applications specifically in the context of nuclear power plant simulators.     

An environment for prototyping distributed applications

Designing a distributed application is an extremely complex task. Proper facilities for prototyping distributed applications can be useful in evaluating a design, and also in understanding the effect of different parameters on the performance of an application. We describe a language for prototyping distributed applications, that supports different communication primitives with specified delay, and provides primitives to aid debugging and evaluation. Our environment for executing distributed programs supports heterogeneous computation in which processes can execute on different hardware. Different source languages can be used for coding different modules of the processes. The system has a centralized control and monitoring facility which is based on the Suntools window system.     

A computer network based control architecture for autonomous distributed multirobot systems

This paper presents the specification and implementation procedure using a microcomputer network based autonomous distributed control architecture for industrial multirobot systems. The procedure is based on the concept of data flow network controlled by communicating sequential processes to perform coordinated tasks. Robots and other computerized industrial devices such as conveyors and manufacturing machines are defined as object-oriented Petri nets. A modular and hierarchical approach is adopted to define a set of Petri net type diagrams which represent concurrent activities of control processes for such devices. Asynchronous and synchronous interactions are modelled by places and transitions, respectively, in global process interaction nets. The control software is implemented on a computer network using Inmos transputers with true parallel processing and message passing primitives efficiently handled in hardware. Petri net based models are directly and efficiently transformed to corresponding codes in occam, the high level parallel programming language defined for the transputer.     

LANSF: A protocol modelling environment and its implementation

LANSF is a software package that was originally designed as a tool to investigate the behaviour of medium access control (MAC) level protocols. These protocols form an interesting class of distributed computations: timing of events is the key factor in them. The protocol definition language of LANSF is based on C, and protocols are specified (programmed) as collections of communicating, interrupt-driven processes. These specifications are executable: an event-driven emulator of MAC-level communication phenomena forms the foundation of the implementation. Some tools for debugging, testing, and validation of protocol specifications are provided. We present key features of LANSF at the syntactic level, comment informally on the semantics of these features, and highlight some implementation issues. A complete example of a LANSF application is discussed in the Appendix.     

A tool for measuring inheritance coupling in object-oriented systems

Analyzing object-oriented systems in order to evaluate their quality gains its importance as the paradigm continues to increase in popularity. Consequently, several object-oriented metrics have been proposed to evaluate different aspects of these systems such as class coupling. In object-oriented design, three types of coupling may exist between classes: inheritance coupling, interaction coupling, and component coupling. This paper presents a tool for measuring inheritance coupling in object-oriented systems.     

Pictures that play: Design notations for real-time and distributed systems

‘Pictures that play’ are design diagrams that give enough visual cues to enable a person to trace causality sequences that cut across them, without referring to (or even knowing) the kind of details that would enable a tool to execute the design or to generate executable code. Playing design diagrams is particularly important while exploring alternative solutions during the early stages of designing all kinds of systems. It is done either by mentally tracing sequences across diagrams on paper or a computer screen, or physically tracing them on whiteboards with a pointer or finger during design meetings. Two complementary pictorial design notations are described and used together in an example to illustrate the concept of play and to show how to do it: timethreads, a new notation for causality sequences that cut across many components and across the system end-to-end, and machine charts, an older notation for architecture presented here from a new angle. These notations are specifically designed to support play during the design process, not just record the end result. The focus is on real-time and distributed (RTD) systems, but the approach has wider applicability.     

BPL: A set-based language for distributed system prototyping

Rapid prototyping of software and hardware is recognized as a very important step in timely, cost-effective system development. The complexity inherent in designing distributed computing systems and distributed problem solutions emphasizes the need for effective rapid prototyping tools. ADL/ADS is a testbed user interface tool for experimentation with critical research and design issues pertaining to distributed data processing (DDP). The experimenter expresses a candidate distributed system in terms of experiment objects, along with attributes and relationships. The experiment objects represent hardware, software, and behavior. This paper provides a brief overview of ADL/ADS, and gives especial emphasis to the Behavior Prototyping Language (BPL) within ADL/ADS. BPL is designed for expressing Behavior Modules (B_MODULEs)—the most versatile of the behavior objects. BPL incorporates set-theoretical approaches, and provides syntax designed for effectively describing manipulations of experiment objects, and their attributes and relationships.     

An Efficient Method for Computing Exact State Space of Petri Nets With Stopwatches

In this paper, we address the issue of the formal verification of real-time systems in the context of a preemptive scheduling policy. We propose an algorithm which computes the state-space of the system, modeled as a time Petri net with stopwatches, exactly and efficiently, by the use of Difference Bounds Matrices (DBM) whenever possible and automatically switching to more time and memory consuming general (convex) polyhedra only when required. We propose a necessary and sufficient condition for the need of general polyhedra. We give experimental results comparing our implementation of the method to a full DBM over-approximation and to an exact computation with only general polyhedra.     

Petri net based verification of distributed algorithms: An example

A technique to model and to verify distributed algorithms is suggested. This technique (based on Petri nets) reduces the modelling and analysis effort to a reasonable level. The paper outlines the technique using the example of a typical network algorithm, theecho algorithm.Supported by the DFG-projects Verteilte Algorithmen and Konsensalgorithmen     

An environment for integrated development and evaluation of real-time distributed database systems

Real-time database systems must maintain consistency while minimizing the number of transactions that miss the deadline. To satisfy both the consistency and real-time constraints, there is the need to integrate synchronization protocols with real-time priority scheduling protocols. One of the reasons for the difficulty in developing and evaluating database synchronization techniques is that it takes a long time to develop a system, and evaluation is complicated because it involves a large number of system parameters that may change dynamically. This paper describes an environment for investigating distributed real-time database systems. The environment is based on a concurrent programming kernel that supports the creation, blocking, and termination of processes, as well as scheduling and interprocess communication. The contribution of the paper is the introduction of a new approach to system development that utilizes a module library of reusable components to satisfy three major goals: modularity, flexibility, and extensibility. In addition, experiments for real-time concurrency control techniques are presented to illustrate the effectiveness of the environment.This work was supported in part by ONR contract # NOOO14-88-K-0245, by DOE contract # DEFG05-88-ER25063, by CIT contract # CIT-INF-90-011, and by IBM Federal Systems Division.     

An object-oriented architecture for knowledge-based production scheduling systems

This paper describes an object-oriented architecture to support decision making in production scheduling environments. An object-oriented world view is used to integrate concepts from discrete event simulation, conventional scheduling logic and artificial intelligence to produce capacity-feasible schedules. The architecture was implemented as a collection of loosely coupled reusable software objects by extending the functionality of software objects from BLOCS/M (Berkeley Library of Objects for Control and Simulation of Manufacturing). Our experience with an industrial prototype is presented.     

The ABS tool suite: modelling, executing and analysing distributed adaptable object-oriented systems

Modern software systems must support a high degree of variability to accommodate a wide range of requirements and operating conditions. This paper introduces the Abstract Behavioural Specification (ABS) language and tool suite, a comprehensive platform for developing and analysing highly adaptable distributed concurrent software systems. The ABS language has a hybrid functional and object- oriented core, and comes with extensions that support the development of systems that are adaptable to diversified requirements, yet capable to maintain a high level of trustworthiness. Using ABS, system variability is consistently traceable from the level of requirements engineering down to object behaviour. This facilitates temporal evolution, as changes to the required set of features of a system are automatically reflected by functional adaptation of the system’s behaviour. The analysis capabilities of ABS stretch from debugging, observing and simulating to resource analysis of ABS models and help ensure that a system will remain dependable throughout its evolutionary lifetime. We report on the experience of using the ABS language and the ABS tool suite in an industrial case study.     

A distributed approach for fault detection and diagnosis based on Time Petri Nets

This paper proposes an algorithm for the model based design of a distributed protocol for fault detection and diagnosis for very large systems. The overall process is modeled as different Time Petri Net (TPN) models (each one modeling a local process) that interact with each other via guarded transitions that becomes enabled only when certain conditions (expressed as predicates over the marking of some places) are satisfied (the guard is true). In order to use this broad class of time DES models for fault detection and diagnosis we derive in this paper the timing analysis of the TPN models with guarded transitions. In this paper we also extend the modeling capability of the faults calling some transitions faulty when operations they represent take more or less time than a prescribed time interval corresponding to their normal execution. We consider here that different local agents receive local observation as well as messages from neighboring agents. Each agent estimates the state of the part of the overall process for which it has model and from which it observes events by reconciling observations with model based predictions. We design algorithms that use limited information exchange between agents and that can quickly decide “questions” about “whether and where a fault occurred?” and “whether or not some components of the local processes have operated correctly?”. The algorithms we derive allow each local agent to generate a preliminary diagnosis prior to any communication and we show that after communicating the agents we design recover the global diagnosis that a centralized agent would have derived. The algorithms are component oriented leading to efficiency in computation.     

Formal models for the description of timed behaviors of multimedia and hypermedia distributed systems

This paper presents two modeling approaches that can be used as a formal basis for designing distributed multimedia and hypermedia systems. Using these approaches, users and designers are able to express formally their multimedia and hypermedia synchronization and time requirements. The two different models considered are Hierarchical Time Stream Petri Nets and RT-LOTOS. It will be shown that both models, starting from a different formal basis, are of interest as they possess complementary advantages and can then be used at different stages of the system life cycle. For instance, HTSPN provides an user-friendly graphical specification framework, whereas RT-LOTOS offers an extensive simulation and validation framework applicable to specifications derived from HTSPN.     

A toolset in Java2 for modelling, prototyping and implementing communicating real-time state machines

This paper proposes an approach to the development of real-time systems which depends on Communicating Real-Time State Machines (CRSMs) as the specification language, and on a customisable actor kernel for prototyping, analysis and implementation of a modelled system. CRSMs offer an intuitive and distributed specification of a system in terms of a collection of co-operating state machines interacting with one another through timed CSP-like I/O commands. On the other hand, the underlying actor framework provides a time-sensitive scheduling structure which can be tuned to CSRMs in order to support temporal validation through assertions on the recorded time-stamped event histories. The approach can be practically used through a graphical environment (jCRSM) which has been realised using Java2. The toolset facilitates editing, testing and implementation in Java of CRSM systems. The proposed methodology is novel in that it provides a seamless system development life cycle where the specification, analysis, design and implementation phases are unified by a common representation of machines in terms of actors. The paper demonstrates the use of CRSM based software components by means of examples.