Real-time Object-oriented Models Research Articles

Synthesizing Multithreaded Code from Real-Time Object-Oriented Models via Schedulability-Aware Thread Derivation

One of the major difficulties in developing embedded systems with object-oriented modeling is to translate a designed model into code that satisfies required real-time performance. This paper proposes scenario-based implementation synthesis architecture with timing guarantee (SISAtime) that addresses these difficulties. The problems that SISAtime must solve are: how to synthesize multithreaded-code from a real-time object-oriented model; and how to design supporting development tools and runtime system architecture while ensuring that the scenarios in the system have minimal response times and the code satisfies the given timing constraints with a minimal number of threads. SISAtime provides a new scheduling algorithm which minimizes scenario response times. SISAtime also provides a new thread derivation method that derives tasks and maps tasks to threads while automatically assigning task scheduling attributes. We have fully implemented SISAtime by extending the RoseRT development tool that uses UML 2.0 as a modeling language, and we applied it to an existing industrial private branch exchange system. The performance evaluation results show that the response times, context switches, and the number of threads of the system with SISAtime were reduced by 21.6, 33.2, and 65.2 percent, respectively, compared to the system with the best known existing thread derivation method.

Cell modeling with reusable agent-based formalisms

Biologists are building increasingly complex models and simulations of cells and other biological entities, and are looking at alternatives to traditional representations. Making use of the object-oriented (OO) paradigm, the Unified Modeling Language (UML) and Real-time Object-Oriented Modeling (ROOM) visual formalisms, and the Rational Rose RealTime (RRT) visual modeling tool, we summarize a previously-described multi-step process for constructing top-down models of cells. We first construct a simple model of a cell using an architecture in which all objects are containers, agents, or passive objects. We then reuse these architectural principles and components to extend our simple cell model into a more complex cell, the goal being to demonstrate that encapsulation familiar to artificial intelligence researchers can be employed by systems biologists in their models. A red blood cell is embedded in a straight-forward manner within a larger system, which is in turn iteratively embedded within still larger systems, including a blood vessel, a circulatory system, a human being, and a simple ecology. Each complexity increment reuses the same architectural principles, including the use of agents, each of which continuously either moves passive small molecules between containers, or transforms these passive objects from one type into another. We show how it is possible to start with a direct diagrammatic representation of a biological structure such as a cell, using terminology familiar to biologists, and by following a process of gradually adding more and more detail, arrive at a system with structure and behavior of arbitrary complexity that can run and be observed on a computer.

Scenario-based multitasking for real-time object-oriented models

Contemporary embedded systems quite often employ extremely complicated software consisting of a number of interrelated components, and this has made object-oriented design methodologies widely used in practice. To implement an object-oriented model in given target hardware, it is imperative to derive a set of tasks from the designed objects. This process of determining tasks and the events they handle greatly influences the real-time performance of the resultant system including response times and real-time guarantees. However, the innate discrepancies between objects and tasks make this exceedingly difficult, and many developers are forced to find their task sets through trial and error. In this paper, we propose Scenario-based Implementation Synthesis Architecture (SISA), an architecture consisting of a method for deriving a task set from a given object-oriented model and the development tools and run-time system architecture to support the method. A system developed with SISA guarantees the optimal response time for each event while deriving the smallest possible number of tasks. We have fully implemented SISA by extending the RoseRT development tool and applied it to an existing industrial PBX (private branch exchange) system. The experimental results show that SISA outperforms the best known conventional techniques by reducing maximum response times an average of 30.3%.

UML as a cell and biochemistry modeling language

The systems biology community is building increasingly complex models and simulations of cells and other biological entities, and are beginning to look at alternatives to traditional representations such as those provided by ordinary differential equations (ODE). The lessons learned over the years by the software development community in designing and building increasingly complex telecommunication and other commercial real-time reactive systems, can be advantageously applied to the problems of modeling in the biology domain. Making use of the object-oriented (OO) paradigm, the unified modeling language (UML) and Real-Time Object-Oriented Modeling (ROOM) visual formalisms, and the Rational Rose RealTime (RRT) visual modeling tool, we describe a multi-step process we have used to construct top–down models of cells and cell aggregates. The simple example model described in this paper includes membranes with lipid bilayers, multiple compartments including a variable number of mitochondria, substrate molecules, enzymes with reaction rules, and metabolic pathways. We demonstrate the relevance of abstraction, reuse, objects, classes, component and inheritance hierarchies, multiplicity, visual modeling, and other current software development best practices. We show how it is possible to start with a direct diagrammatic representation of a biological structure such as a cell, using terminology familiar to biologists, and by following a process of gradually adding more and more detail, arrive at a system with structure and behavior of arbitrary complexity that can run and be observed on a computer. We discuss our CellAK (Cell Assembly Kit) approach in terms of features found in SBML, CellML, E-CELL, Gepasi, Jarnac, StochSim, Virtual Cell, and membrane computing systems.

Evaluating real-time software specification languages

In recent years, many notations and methods in real-time software engineering have been proposed. However, thorough experimentation to evaluate these notations and methods has not been carried out. This paper focuses on real-time software engineering specification languages: Unified Modeling Language (UML), Real-Time Object-Oriented Modeling Language (ROOM), Modecharts, statecharts, Mealy and Moore machines, finite state machines, classical logic, Z, ASTRAL, temporal logic, FNLOG, linear logic, Timed Communicating Sequential Processes (TCSP), Temporal Calculus of Communicating Systems (TCCS), ρ1, and Multilevel Specification. The basis for evaluating these software engineering specification languages is by using the Turing machines and Interaction machines. We classify them based on their computational capabilities.

Perfecting preemption threshold scheduling for object-oriented real-time system design

In spite of the proliferation of object-oriented design methodologies in contemporary software development, their application to real-time embedded systems has been limited because of the practitioner's conservative attitude toward handling timing constraints. In fact, this conservative attitude is well-grounded because traditional priority-based scheduling techniques cannot be straightforwardly integrated into them. The automated implementation from the object-oriented real-time designs usually incurs a large number of tasks which, under traditional priority-based scheduling techniques, does not scale well due to excessive preemption overheads. Recently, preemption threshold scheduling was introduced to reduce run-time multi-tasking overhead while improving schedulability by exploiting non-preemptibility as much as possible. Unfortunately, the preemption threshold scheduling cannot be directly adopted into the object-oriented design methods due to the lack of real-time synchronization.In this paper, we present the essential basis of real-time synchronization for preemption threshold scheduling. Specifically, we integrate the priority inheritance protocol, the priority ceiling protocol, and the immediate inheritance protocol into preemption threshold scheduling. We also provide their schedulability analyses. Consequently, the integrated scheme, which minimizes worst-case context switches, is appropriate for the automated implementation of real-time object-oriented design models.

A framework for evaluating the effectiveness of real-time object-oriented models

The design of a real-time system needs to incorporate methods specifically developed to represent the temporal properties of the system under consideration. Real-time systems contain time and event driven actions. Structured design methods provided a reasonable set of abstractions for design of time and event driven factors in real-time designs. As program complexity, size, and time to market pressure grows, the real-time community migrated towards object-oriented technology. Evidence suggests that object-oriented technology in non-real-time systems is most effective in abstraction, modeling, implementation, and reuse of software systems. Many design models and methods exist for object-oriented real-time designs. However, the selection process of a model for a particular application remains a tedious task. This paper introduces an analysis framework that can be applied to a design model to evaluate its effectiveness according to desired performance specifications. To illustrate our approach, we present a case study using the popular automotive cruise control example on two real-time object-oriented models.

Automated Implementation of Distributed Real-Time Systems using Real-Time Object-Oriented Modeling

This paper presents a systematic, schedulability-aware method for auto¬mated implementation of complex distributed real-time control systems designed with real-time object-oriented models. Our approach derives tasks in each node of a distributed system by grouping mutually exclusive transactions. It then assigns each task a feasible priority and preemption threshold. To allow for the automated analysis of the timing behavior of the derived task set, our approach exploits a schedulability analysis test based on response time analysis. This paper shows how a run-time system supporting the proposed approach is designed and how code generation is done under our framework. Our method solves the difficult task derivation problem and enables the rapid development of distributed real-time systems.

A comparison of real-time object-oriented modeling methods ROOM and OCTOPUS

ROOM and OCTOPUS are two real-time object-oriented modeling methods used commonly. The paper analyses and compares ROOM and OCTOPUS based on details where philosophies of both methods are in sharper contrast, such as model representation, class and object and inheritance, concurrency, and state charts.

Schema evolution of an object-oriented real-time database system for manufacturing automation

Database schemata often experience considerable changes during the development and initial use phases of database systems for advanced applications such as manufacturing automation and computer-aided design. An automated schema evolution system can significantly reduce the amount of effort and potential errors related to schema changes. Although schema evolution for nonreal-time databases was the subject of previous research, its impact on real-time database systems remains unexplored. These advanced applications typically utilize object-oriented data models to handle complex data types. However, there exists no agreed-upon real-time object-oriented data model that can be used as a foundation to define a schema-evolution framework. Therefore, the authors first design a conceptual real-time object-oriented data model, called Real-time Object Model with Performance Polymorphism (ROMPP). It captures the key characteristics of real-time applications-namely, timing constraints and performance polymorphism-by utilizing specialization-dimension and letter-class hierarchy constructs, respectively. They then re-evaluate previous (nonreal-time) schema evolution support in the context of real-time databases. This results in modifications to the semantics of schema changes and to the needs of schema change resolution rules and schema invariants. Furthermore, they expand the schema change framework with new constructs-including new schema change operators, new resolution rules, and new invariants-necessary for handling the real-time characteristics of ROMPP.

Real-time object-oriented modeling

Abstract The of a software system refers to its highest-level modular decomposition and the interrelationship patterns between its modules. An architecture serves as a blueprint for implementation and also as the chief determinant of a system's ability evolve. Consequently, there is an increased interest in methods for specifying and validating software architectures. One such method is based on the ROOM mode ling language which combines the object paradigm with mode ling abstractions devised specifically for distributed real-time software. To overcome the treacherous decay phenomenon, whereby, over time, software diverges increasingly from its specification, ROOM formally constrains the implementation to its architectural specification. This is achieved primarily through full automated code generation, a technique that is panicularly challenging in real-time applications where stringent performance and memory requirements are the norm.

Real-Time Object-Oriented Database Support For Program Stock Trading

Many computer systems that automatically control financial applications are required to handle large amounts of data with timing constraints imposed on the data and on the transactions that access the data. Traditional database technology, however, is not designed to manage perishable (timeconstrained) data of financial applications, such as “current†stock prices and trading volumes in index arbitrage transactions. Furthermore, traditional database systems are not capable of scheduling the time-constrained transactions in financial applications, such as transactions that must be performed within time bounds of guaranteed price quotations. This paper presents a schema model of real-time objectoriented database that addresses these weaknesses and shows how this model can support a form of intelligent program stock trading called index arbitrage. This paper also illustrates the use of a protocol called timed atomic commitment, which is an extension of traditional distributed database atomic commitment protocol, to perform index arbitrage transactions using our real-time object-oriented database model.

Object-oriented real-time systems: concepts and examples

The problems associated with developing real-time software systems, including ensuring predictable real-time behavior under both normal and abnormal operating conditions, are outlined. The management of temporal complexity, structuring of dynamic real-time applications, object-oriented models, object-oriented real-time languages, and the requirements for real-time object-oriented models are discussed. Chaos, an object-based language and programming/execution paradigm designed for dynamic real-time applications, is described. >