This paper describes a model for representing the temporal and logical elements of real-time applications, called MAST. This model allows a very rich description of the system, including the effects of event or message-based synchronization, multiprocessor and distributed architectures as well as shared resource synchronization. The model is directly obtainable from a description of the system design using a UML tool. A system representation using this model is analyzable through a set of tools that has been developed within the MAST suite, including worst-case schedulability analysis for hard timing requirements, and discrete-event simulation for soft timing requirements. Although the current model only includes fixed priority systems, it is conceived as an open model and is easily extensible to accommodate

EMBEDDED COMPUTER SYSTEMS are now everywhere: from alarm clocks to PDAs, from mobile phones to cars, almost all the devices we use are controlled by embedded computer systems. An important class of embedded computer systems is that of real-time systems, which have to fulfill strict timing requirements. As realtime systems become more complex, they are often implemented using distributed heterogeneous architectures. The main objective of this thesis is to develop analysis and synthesis methods for communication-intensive heterogeneous hard real-time systems. The systems are heterogeneous not only in terms of platforms and communication protocols, but also in terms of scheduling policies. Regarding this last aspect, in this thesis we consider time-driven systems, event-driven systems, and a combination of both, called multi-cluster systems. The analysis takes into

Multiple, independent robot platforms promise significant advantage with respect to robustness and flexibility. However, coordination between otherwise independent robots requires the exchange of information; either implicitly (as in gestural communication), or explicitly (as in message passing in a communication network.) In either case, control processes resident on all coordinated peers must participate in the collective behavior. This paper evaluates the potential to scale such a coupled control framework to many participating individuals, where scalability is evaluated in terms of the schedulability of coupled, distributed control processes. We examine how schedulability affects the scalability of a robot system, and discuss an algorithm used for off-line schedulability analysis of a distributed task model. We present a distributed coordinated search task and analyze the schedulability of the designed task structure. We are able to analyze communication delays in the system that put upper bounds on the size of the robot teams. We show that hierarchical methods can be used to overcome the scalability problem. We propose that schedulability analysis should be an integrated part of a multi-robot team design process.

In this paper we present an approach to schedulability analysis for hard real-time systems with control and data dependencies. We consider distributed architectures consisting of multiple programmable processors, and the scheduling policy is based on a static priority preemptive strategy. Our model of the system captures both data and control dependencies, and the schedulability approach is able to reduce the pessimism of the analysis by using the knowledge about control and data dependencies. Extensive experiments as well as a real life example demonstrate the efficiency of our approach. 1. Introduction Depending on the particular application, a real-time system has certain requirements on performance, cost, dependability, size, etc. For hard real-time applications the timing requirements are extremely important. Thus, in order to function correctly, a real-time system implementing such an application has to meet its deadlines. In this paper we present an approach to schedulability...

This paper describes a methodology and a framework for building an analyzable real-time model of an object-oriented system that is developed using a UML CASE tool. The real-time model is formulated by a new UML view named "MAST RT View". This view allows the designer to gradually build the real-time model according to the phase of the development process, to feed data into the analysis tools, and to bring the relevant timing responses back into the model. The MAST RT View has three models: the processing capacity of the hardware/ software platform; the timing behavior of the application logical components; and the workload and the timing requirements of each real-time situation to be analyzed. This view is analyzable by the MAST set of tools, which includes worst-case schedulability analysis and discreteevent simulation for hard and soft timing requirements.

We present an approach to frame packing for multi-cluster distributed embedded systems consisting of time-triggered and event-triggered clusters, interconnected via gateways. In our approach, the application messages are packed into frames such that the application is schedulable, thus the end-to-end message communication constraints are satisfied. We have proposed a schedulability analysis for applications consisting of mixed event-triggered and timetriggered processes and messages, and a worst-case queuing delay analysis for the gateways, responsible for routing inter-cluster traffic. Optimization heuristics for frame packing aiming at producing a schedulable system have been proposed. Extensive experiments and a real-life example show the efficiency of our frame-packing approach.

Despite Java's initial promise of providing a reliable and cost-e#ective platform-independent environment, the language appears to be unfavourable in the area of high-integrity systems and real-time systems. To encourage the use of Java in the development of distributed high-integrity real-time systems, the language environment must provide not only a well-defined specification or subset, but also a complete environment with appropriate analysis tools. We propose an extensible distributed high-integrity real-time Java environment, called XRTJ, that supports three attributes, i.e., predictable programming model, dependable static analysis environment, and reliable distributed run-time environment. The goal of this paper is to present an overview of our on-going project and report on its current status. We also raise some important issues in the area of distributed high-integrity systems, and present how we can deal with them by defining two distributed run-time models where safe and timely operations will be supported.

Methods for performing response time analysis of real-time systems are important, not only for their use in traditional schedulability testing, but also for deriving bounds on output timing variations in control applications. Automatic control systems are inherently sensitive to variations in periodicity and end-to-end delays. Therefore, real-time performance needs to be considered during control design. For this purpose, any real-time analysis of a potential control implementation should produce results that can easily be used to examine how the implementation affects control performance. To find the maximum response time variation for a task, bounds on both minimum and maximum response times are needed. A tight bound on this maximum variation is useful in the analysis of control performance and can also be used to improve the results of some iterative response time analysis methods. In this thesis, three methods for response time analysis are developed.

Safety critical embedded real-time systems represent a class of systems that has attracted relatively little attention in research addressing component based software engineering. Hence, the most widely spread component technologies are not used for resource constrained safety critical real-time systems. They are simply to resource demanding, to complex and to unpredictable. In this paper we show how to use component based software engineering for low footprint systems with very high demands on safe and reliable behaviour. The key concept is to provide expressive design time models and yet resource e#ective runtime models by statically resolve resource usage and timing by powerful compile time techniques. This results in a component technology for resource e#ective and temporally verified mapping of a component model to a commercial real-time operating system.

We present a method that enables an efficient implementation of the approximative response-time analysis for tasks with offsets presented by Tindell [11] and Palencia Gutierrez et al. [6].