Component-based Real-time Systems Research Articles

A Method for Selecting a Model to Estimate Software Reliability at the Design Phase of Component-Based Real-Time System Development

A Method for Selecting a Model to Estimate Software Reliability at the Design Phase of Component-Based Real-Time System Development

A Probabilistic Calculus for Probabilistic Real-Time Systems

Challenges within real-time research are mostly in terms of modeling and analyzing the complexity of actual real-time embedded systems. Probabilities are effective in both modeling and analyzing embedded systems by increasing the amount of information for the description of elements composing the system. Elements are tasks and applications that need resources, schedulers that execute tasks, and resource provisioning that satisfies the resource demand. In this work, we present a model that considers component-based real-time systems with component interfaces able to abstract both the functional and nonfunctional requirements of components and the system. Our model faces probabilities and probabilistic real-time systems unifying in the same framework probabilistic scheduling techniques and compositional guarantees varying from soft to hard real time. We provide an algebra to work with the probabilistic notation developed and form an analysis in terms of sufficient probabilistic schedulability conditions for task systems with either preemptive fixed-priority or earliest deadline first scheduling paradigms.

Translating end-to-end timing requirements to timing analysis model in component-based distributed real-time systems

Often, component-based real-time systems are modeled with trigger and data chains. The end-to-end timing requirements on trigger chains are different from those on data chains. For a trigger chain, the interest lies in the calculation of holistic response time and its comparison with end-to-end deadline. Whereas, the schedulability of a data chain requires a comparison between its end-to-end latencies and corresponding deadlines. We discuss the problem of translating end-to-end timing requirements unambiguously from component-based real-time systems into timing analysis models which are required as input by the analysis tools. We also provide preliminary guidelines for such translations in the existing industrial tool suite.

Behavioral Compatibility Analysis of Component-based Real-time System

For verification of component behavior compatibility in component-based real-time system, we make use of the timed automata to formally describe the component. In this way, the problem of component behavior compatibility is equivalent to whether the complementary actions can really synchronize over common channels on the system’s TA models. We then use the verification function of UPPAAL to automatically generate result, and finally conduct a case study to demonstrate how our technique works.

Robustness testing of composed real-time systems

In this paper, we suggest a methodology for testing robustness of Real-Time Component-Based Systems (RTCBS). A RTCBS system is described as a collection of components where each component is modeled as a Timed Input-Output Automaton (TIOA). For each component, we handle two specifications: a nominal one and a degraded one. We extract test sequences from the nominal specification and we inject automatically faults in order to model hostile environments. Then we present an adequate test architecture consisting of the System Under Test (SUT) of components, and a distributed tester that consists of a set of coordinating testers. Each tester is dedicated to test a single SUT component. A test execution algorithm is presented. Testing the SUT is divided into two phases. In the first phase, the tester executes the generated test sequences of each component in isolation and records the feedback of this experimentation. The robustness is checked by verifying if the recorded results are accepted by the degraded specification of each component. If all components are robust according to the inserted hazards, we check the robustness of communications between components respecting the same process described before.

Integrating UML and UPPAAL for designing, specifying and verifying component-based real-time systems

A new tool for integrating formal methods, particularly model checking, in the development process of component-based real-time systems specified in UML is proposed. The described tool, TANGRAM (Tool for Analysis of Diagrams), performs automatic translation from UML diagrams into timed automata, which can be verified by the UPPAAL model checker. We focus on the CORBA Component Model. We demonstrate the overall process of our approach, from system design to verification, using a simple but real application, used in train control systems. Also, a more complex case study regarding train control systems is described.

Model-based Runtime Verification Framework for Self-optimizing Systems

This paper describes a novel on-line model checking approach offered as service of a real-time operating system (RTOS). The verification system is intended especially for self-optimizing component-based real-time systems where self-optimization is performed by dynamically exchanging components. The verification is performed at the level of (RT-UML) models. The properties to be checked are expressed by RT-OCL terms where the underlying temporal logic is restricted to either time-annotated ACTL or LTL formulae. The on-line model checking runs interleaved with the execution of the component to be checked in a pipelined manner. The technique applied is based on on-the-fly model checking. More specifically for ACTL formulae this means on-the-fly solution of the NHORNSAT problem while in the case of LTL the emptiness checking method is applied.

Scenario-Based Consistency Verification of Component-Based Real-Time System Designs

For real-time software systems, this paper considers the problem of checking component-based designs for timing scenario-based specifications, which is one of the challenges in real-time computing domain. Firstly the timing scenario-based specifications are specified by UML sequence diagrams with a set of boolean expressions, then the interface automata for modeling real time systems through adding time intervals on the actions is extened. The component-based designs are modeled by a real-time interface automaton network which contains a set of real-time interface automata synchronized by shared actions. Based on analyzing the compatible integer state space of a real-time interface automata network, a corresponding reachability graph is constructed and finally an algorithm for checking the consistency between the real-time component-based designs and the timing scenario-based specifications is developed.

A Hierarchical Framework for Component-based Real-time Systems

In this paper, we describe a methodology for the design and the development of component-based real-time systems. In our model, a component consists of a set of concurrent real-time threads that communicate by means of synchronous and asynchronous operations. In addition, each component can specify its own local scheduling algorithm. We also discuss the support that must be provided at the operating system level, and present an implementation in the SHaRK operating system.

Static analysis of real-time component-based systems configurations

Nowadays, more and more often, complex systems are built by assembling together different system components. This technology also affects the construction of heterogeneous and/or hybrid systems where components can represent hardware sensors, software controllers, etc. Moreover the resulting system is normally distributed. These systems have often real-time constraints/requirements and each component is characterized by its own speed determined by its local clock. In this paper we present a framework to specify and statically analyze the architecture of a system as a network of (parallel) components, each one with its own local clock. Configuring the system means to formally define how to get the global clock out of the local clocks. This clock configuration step is “optimal” that is, it is the best way to relate the local clocks so that the maximum number of synchronizations in the system can happen. Besides the usual behavioral and timing analysis, it is, for example, possible to verify if, and how changing the local speed of a component can affect the global performance of the system. Components behaviors are specified by means of a simple process algebra. Local clocks are modeled as higher order terms in a given signature, and unification is used to define the common clock. Then an operational semantics defines which transitions a process can perform and which transitions let time to elapse. A set of case studies illustrate the approach.

ControlShell: A Software Architecture for Complex Electromechanical Systems

Real-time system software is notoriously complex. Large projects must balance the special needs of real-time software—such as clock management, control systems, and strategy—with the needs of in teracting teams of programmers, managers, and long-term main tenance personnel. Successful projects require a solid software architecture, an intuitive graphical programming paradigm, a well- developed reuse system, and powerful system services. This paper walks through the methodology and application of ControlShell, the component-based real-time programming system. ControlShell provides an integrated development environment for building complex electromechanical systems. It targets complex systems that require both cyclic data processing and strategic event management and sequencing. ControlShell is specifically designed to facilitate team develop ment of complex electromechanical systems. Teams must share and reuse code; ControlShell provides component-level code shar ing and reuse. Complex systems require flexibility; ControlShell gains flexibility by supporting independent module-level code gen eration. Large systems are most easily designed as independent parts; ControlShell encourages easy interconnectivity of objects. Finally, complex systems are modal; ControlShellfeatures a unique configuration-control system for changing operating modes. The paper concludes by examining the application of this frame work to a dual-arm robotic work cell, a subsystem of the Space Shuttle Launch Processing System, and an underwater autonomous vehicle.

The ControlShell component-based real-time programming system, and its application to the Marsokhod Martian Rover

Real-time system software is notoriously hard to share and reuse. This paper walks through the methodology and application of ControlShell, a component-based programming system for real-time system software development. ControlShell combines graphical system-building tools, an execution-time configuration manager, a real-time matrix package, and an object name service into an integrated development environment. It targets complex systems that require on-line reconfiguration and strategic control.ControlShell takes advantage of functional object hierarchies to enable code sharing and reuse. It gains flexibility by supporting easy interconnectivity of these objects. It features a unique configuration control system for changing operating modes.The paper concludes by examining the application of this framework to a teleoperated rover under development as a joint effort by NASA, several Russian space research institutes, and US industry. The rover is able to function remotely under control of a virtual reality interface.