Testing is an important part of any software development project, and can typically surpass more than half of the development cost. For safety-critical computer based systems, testing is even more important due to stringent reliability and safety requirements. However, most safety-critical computer based systems are real-time systems, and the majority of current testing and debugging techniques have been developed for sequential (non real-time) programs. These techniques are not directly applicable to real-time systems, since they disregard issues of timing and concurrency. This means that existing techniques for reproducible testing and debugging cannot be used. Reproducibility is essential for regression testing and cyclic debugging, where the same test cases are run repeatedly with the intention of verifying modified program code or to track down errors. The current trend of consumer and industrial applications goes from single microcontrollers to sets of distributed micro-controllers, which are even more challenging than handling real-time per-see, since multiple loci of observation and control additionally must be considered. In this thesis we try to remedy these problems by presenting an integrated approach to monitoring, testing, and debugging of distributed real-time systems. For monitoring

this paper and in Reference 3, the simulator/assertion checker responds to single-step commands from the user in real-time

In active database systems, events are used in ECA rules to specify the time to check the conditions of the rules. Composite events can be constructed in an intuitive way by applying event operators, such as and, or, sequence, etc., to primitive events. Where timing is important, these event operators may introduce ambiguity if there is no formal semantics defining the occurrence of the composite events. In this paper, we propose a formalism to specify a wider range of composite events with formal semantics in the logic RTL which is especially amenable for specifying timing constraints in real-time systems. The use of RTL to define the formal semantics also allows us to exploit compilation methods which can be used to translate the enabling conditions of ECA rules into timing constraints. Thus the detection of composite events can be handled by monitoring the corresponding timing constraints, a subject which has been explored in our previous work [18, 19]. A prototype implementation of...

This paper presents an approach for engineering time-constrained systems which must operate in dynamic environments. Systems which operate in such environments may have unknown worst-case scenarios, may have large variances in the sizes of the data and event sets that they process (and thus, have large variances in execution latencies and resource requirements), and may not be statically characterizable, even by time-invariant statistical distributions. To enable the engineering of such systems, we have developed a specification language that enables the description of environment-dependent features. We also present an abstract model that is constructed from the specifications, and is augmented dynamically with the state of environment-dependent features. The model is also used to define techniques for QoS (quality-of-service) monitoring, QoS diagnosis, and allocation analysis. Experimental results show the effectiveness of the approach for specification of real-time QoS, detection and...

: This paper describes the rationale and design of a new distributed systems programming model based on events, constraints, and objects 1 . The paper describes the inter-object communication or invocation mechanism, and the way in which concurrency, synchronisation, and timing properties are expressed and controlled. The invocation mechanism is unusual in that it is event-based. It encourages loose coupling among the objects and a high degree of encapsulation for each object. Concurrency, synchronisation, and timing properties are expressed in a uniform way using constraints which may be associated with objects and events. KEY WORDS: events, constraints, inter-object communication mechanism, object-oriented programming 1 Introduction It is well known that large parallel and distributed applications are hard to program, [39], with communication, synchronisation, and timing contributing to the complexity of the task. It is also accepted that object-orientation goes somewhere towards...

Before designing safety- or mission-critical real-time systems, a specification of the required behaviour of the system should be produced and reviewed by domain experts. After the system has been...

Real-time systems and applications impose stringent timing constraints on critical tasks. The design of such systems are more complex than that of conventional systems, because correctness and performance, besides being key system design issues, are directly related to system feasiblility. Object-oriented application frameworks have been proposed for communication systems, distributed applications, medical imaging, and financial engineering. On the contrary, there has been relatively little work on an application framework for the design of a general real-time system. Facing the growing need for such systems, we propose a novel framework, called RTFrame, especially for real-time systems. RTFrame consists of five components: Specifier, Extractor, Scheduler, Allocator, and Generator. Within RTFrame, several design patterns have been proposed for real-time systems. Experiences of using RTFrame show a significant increase in design productivity through design reuse, and a significant decrease in design time and effort. 1

In this paper a new approach for building embedded applications is presented. The approach is based on the composition of reusable components with the addition of a contract principle for modelling non-functional constraints. Non-functional constraints are an important aspect of embedded systems, and this is why they are modelled separately. As such, the component view presented here differs from traditional component based views, where focus is laid on the functional part. The ideas discussed in the paper have been implemented in a tool. This tool enables the construction of embedded software by means of components and contracts. Currently, runtime mechanisms- that enable runtime monitoring of the contracts-are being included.

Introduction In designing real-time systems, we often make assumptions about the behavior of the system and its environment. These assumptions take many forms, such as upper bounds on interprocess communication delay, deadlines on the execution of tasks, or minimum separations between occurrences of two events. They are often made to deal with the unpredictability of the external environment or to simplify a problem that is otherwise intractable or very hard to solve. Such assumptions may be expressed as part of the formal specification of the system or as scheduling requirements on real-time computations. Despite the contributions of formal verification methods and real-time scheduling results in recent years, the need to perform run-time monitoring of these systems is not diminished, for several reasons: the execution environment of most systems is imperfect and the interaction with the external world introduces additional unpredictability; design assumptions can be violated

This paper presents a novel hardware monitoring system that gives non-intrusive observability into the execution of hardware-accelerated Real-Time Operating Systems.