Real-time Deadlines Research Articles

Goals and functions of the human body: an MFM model for fault diagnosis

Describes the use of explicit models of goals and functions for monitoring and diagnosis of intensive-care patients. The method is based on multilevel flow models (MFM) and used in the Guardian system. It provides this system with alarm analysis, fault diagnosis, and automatic generation of explanations. Advantages include a relatively easy knowledge engineering effort and good properties for use in a system with hard real time deadlines. The results of some experiments are also reported.

The Use of Cache Memory in Real-Time Systems

Real-time computer systems must meet specific deadlines in generating their outputs. As a result, all components of the real-time system must have predictable performance so hardware resources can be effectively scheduled, ensuring all deadlines are met. Cache memories, by their nature, have unpredictable access times which result in execution times that may vary significantly for multiple runs of the same program. Varying program execution times complicate scheduling activities, which may result in missed deadlines. For this reason, cache memories are generally not used in hard real-time systems and the substantial performance advantages they offer are therefore not realized.This paper describes research whose goal is to make cache memory predictable as seen by the processor, so it can be used in hard real-time systems. This predictability is a result of improving the cache’s “worst case” effective memory access time which allows the processor to operate more efficiently, thus increasing its ability to meet hard real-time deadlines. By reducing the upper limit execution time (by lowering the worst case effective memory access time) performance will increase in a predictable manner without any risk of missing real-time deadlines.

The use of cache memory in real-time systems

Real-time computer systems must meet specific deadlines in generating their outputs. As a result, all components of the real-time system must have predictable performance so that hardware resources can be effectively scheduled, ensuring that all deadlines are met. Cache memories, by their nature, have unpredictable access times which result in execution times that may vary significantly for multiple runs of the same program. Varying program-execution times complicate scheduling activities, which may result in missed deadlines. For this reason, cache memories are generally not used in hard real-time systems, and the substantial performance advantages they offer are therefore not realized. This paper describes research whose goal is to make cache memory predictable as seen by the processor, so it can be used in hard real-time systems. This predictability is a result of improving the cache's “worst-case” effective memory-access time, which allows the processor to operate more effficiently thus increasing its ability to meet hard real-time deadlines. By reducing the upper limit execution time (by lowering the worst-case effective memory-access time) performance will increase in a predictable manner without any risk of missing real-time deadlines.

A Multilevel Flow Model of the Human Body

This paper describes explicit models of goals and functions used for monitoring, diagnosis, and closed-loop control of intensive-care patients. The method is based on multilevel flow models, (MFM), and used in the Guardian system. MFM provides Guardian with alarm analysis, fault diagnosis, and automatic generation of explanations. The advantages of using MFM are a comparatively easy knowledge engineering and good properties for a system which operates under hard real-time deadlines.

State Machine Based Deadline Analysis of a Programmable Controller for Real-Time Sequential Control Systems

This paper describes a sequential control system in terms of a real-time control. The sequential control system is modeled in a state machine with physical time components, in the form of a plant and a controller. The real-time deadlines of the controller are derived according to the deadline of the plant in terms of the desired logical behavior, performance and stability. The suggested analysis method is applied to programmable controllers, and the real-time deadlines of the programmable controllers are also derived according to their evolution strategies. Finally, design concepts to reduce the delay of the programmable controllers are suggested.

On the reliability of AI planning software in real-time applications

We define the reliability of a real-time system incorporating AI planning programs as the probability that, for each problem-solving request issued from the environment, the embedded system can successfully plan and execute a response within a specified real-time deadline. A methodology is developed for evaluating the reliability of such systems taking into consideration the fact that, other than program bugs, the intrinsic characteristics of AI planning programs may also cause the embedded system to fail even after all software bugs are removed from the program. The utility of the methodology is demonstrated by applying it to the reliability evaluation of two AI planning algorithms embedded in a real-time multicriteria route finding system. >

Databases with deadline and contingency constraints

Real-time database systems associate the concept of deadlines with transaction executions. Previous approaches use best effort techniques to schedule a given set of transactions to meet the deadlines as well as to ensure the consistency of the database. However, such approaches are inadequate for target applications which have hard real-time deadlines that need to be met in the event of crisis situations. In such cases, it is important to obtain plans that may be invoked with guaranteed execution time characteristics. This paper presents an alternative model for real-time database systems in which deadlines are associated with contingency constraints rather than directly with transactions. Our approach leads to a predicate-based model that intrinsically incorporates both triggering and relative timing constraints regarding the transaction executions. We exhibit that selecting plans with respect to various optimality criteria has inherent computational inefficiencies. We study the issues in scheduling of the selected plans with the focus on the contention among the transactions for data resources. Our results exhibit that the data contention, by itself, has a severe adverse impact on the schedulability of the deadline-constrained transactions. We discuss some of the practical implications of our results, and we suggest some counter-measures to handle the computational complexities. >

PORTS: a parallel, optimistic, real-time simulator

This paper describes issues concerning the design of an optimistic parallel discrete event simulation system that executes in environments that impose real-time constraints on the simulator's execution. Two key problems must be addressed by such a system. First the timing characteristics of the parallel simulator must be sufficiently predictable to allow one to guarantee that real-time deadlines for completing simulation computations will be met. Second, the optimistic computation must be able to interact with its surrounding environment with as little latency as possible, necessitating rapid commitment of I/O operations. To address the first question, we show that optimistic simulators that never send incorrect messages (sometimes called “aggressive-no-risk” simulators) provide sufficient predictability to allow traditional schedulability analysis techniques commonly used in real-time systems to be applied. We show that incremental state saving techniques introduce sufficient unpredictability that they are not well-suited for real-time environments. We observe that the traditional “lowest timestamp first” scheduling policy used in many optimistic parallel simulation systems is an optimal (in the real-time sense) scheduling algorithm when event timestamps and real-time deadlines are the same. Finally, to address the question for rapid commitment of I/O operations, we utilize a continuous GVT computation scheme for shared-memory multiprocessors where a new value of GVT is computed after processing each event in the simulation. These ideas are incorporated in a parallel, optimistic, real-time simulation system called PORTS. Initial performance measurements of the shared-memory based PORTS system executing on a Kendall Square Research multiprocessor are presented. Initial performance results are encouraging, demonstrating that PORTS achieves performance approaching that of a conventional Time Warp system for the benchmark programs that were tested.

Modelling heterogeneous processor scheduling for real-time systems

A new model is presented to describe data-flow algorithms implemented in a multiprocessing system. Called the resource/data flow graph (RDFG), the model explicitly represents cyclo-static processor schedules as circuits of processor arcs that reflect the order that processors execute graph nodes. The model also allows the guarantee of meeting hard real-time deadlines. When unfolded, the model identifies statistically the processor schedule. The model therefore is useful for determining the throughput and latency of systems with heterogeneous processors. The applicability of the model is demonstrated using a space surveillance algorithm.

An Agent-based Architecture for Concurrent Engineering

This paper describes a reference architecture for a concurrent engineering environment. The architecture embeds applications in wrappers to treat the applications as individual reasoning agents. Embedded applications have included planning, vision, simulation, and robotic control modules. These agents negotiate from various perspectives to arrive at globally acceptable solutions. The agents transmit information and negotiate using a canonical vocabulary based upon an international standard for data exchange. Because our implementation of the architecture explicitly considers real-world issues, such as heterogeneous systems, distributed processing, faults, meeting real-time deadlines, and communication delays, the implementation of architecture facilitates rapid transferral from laboratory experiments to field systems.

Chronological scheduling of transactions with temporal dependencies

Database applications often impose temporal dependencies between transactions that must be satisfied to preserve data consistency. The extant correctness criteria used to schedule the execution of concurrent transactions are either time independent or use strict, difficult to satisfy real-time constraints. On one end of the spectrum, serializability completely ignores time. On the other end, deadline scheduling approaches consider the outcome of each transaction execution correct only if the transaction meets its real-time deadline. In this article, we explore new correctness criteria and scheduling methods that capture temporal transaction dependencies and belong to the broad area between these two extreme approaches. We introduce the concepts of succession dependency and chronological dependency and define correctness criteria under which temporal dependencies between transactions are preserved even if the dependent transactions execute concurrently. We also propose a chronological scheduler that can guarantee that transaction executions satisfy their chronological constraints. The advantages of chronological scheduling over traditional scheduling methods, as well as the main issues in the implementation and performance of the proposed scheduler, are discussed.

Inherently stable real-time priority list dispatchers

This paper concerns the problem of scheduling instability, where reducing the duration of one or more tasks delays the starting time of another task. This can make it difficult or impossible to guarantee real-time deadlines. Unfortunately, simulating schedules with all possible variations in the durations of all tasks is in most cases an intractable problem. Therefore, task dispatching must be provably stable for all permissible variations in durations. To alleviate scheduling instability, we have developed a new class of provably stable runtime dispatchers that are less restrictive than known stabilization algorithms. Extensive simulations show that even the simple, low-overhead dispatchers perform remarkably well. These results suggest that is better. Developers of hard real-time systems can implement fast, simple low-overhead runtime task dispatchers that guarantee stability but still deliver near-optimal performance. >

A formally based hard real-time kernel

In order to demonstrably satisfy hard real-time deadlines, a system must be predictable, and in particular the kernel must be predictable. In this paper we present and analyse a predictable kernel related to AORTA, a formal design language for hard real-time systems. The features of the kernel allow AORTA designs to be verifiably and semi-automatically implemented, and enable verified guarantees to be given about the real-time behaviour of the system.

Extremal scheduling of parallel processing with and without real-time constraints

Parallel execution of an arrival stream of jobs with and without real-time constraints on a (possibly heterogeneous) multiprocessor system is considered. A job consists of a set of tasks and a partial order specifying the precedence constraints between the tasks. The real-time constraints are specified by due times, also called soft real time deadlines. It is assumed that there is a predefined mapping from the set of tasks onto the set of machines that is identical for all jobs. Associated with each task is a service time that may depend on the machine that it is allocated to. The problem of scheduling tasks into execution at each machine is the subject of this paper

Time Warp simulation in time constrained systems

The suitability of the Time Warp mechanism to perform simulations with real-time constraints is examined. A model for Time Warp is developed that accounts for overheads such as state saving, state restoration, and sending and transmitting positive and negative messages. A criterion called R-schedulability is defined to indicate whether or not computations can meet real-time deadlines. It is shown that if false events (events that will be rolled back or cancelled later) are generated, and there are no committed events with timestamps equal to those of the false events, Time Warp cannot meet the R-schedulability criterion. Further, if aggressive cancellation is used, scheduling guarantees still cannot be made even in the absence of such false events. However, Time Warp using lazy cancellation is shown to be R-schedulable provided such false events do not exist. Finally, based on these results, bounds on the execution time of a Time Warp simulation are derived.

A statecharts-based specification and verification of real-time job scheduling systems

Real-time job scheduling is a difficult problem. The job scheduling system receives jobs from environment, each job with its own real-time deadline. Queueing and scheduling may still be necessary, in order to maximize the processor usage and also to impose job priorities. In order to compare different scheduling algorithms, formal methods to specify the real-time job scheduling system are necessary, so that properties of the algorithms may be tested against the specified model, prior to implementation. This paper develops a statecharts-based specification for real-time job scheduling systems, and compares it to the modal primitive recursive arithmetic of Yodaiken and Ramamritham.

A Statecharts-Based Specification and Verification of Real-TIme Job Scheduling Systems

Real-time job scheduling is a difficult problem. The job scheduling system receives jobs from the environment, each job with its own real-time deadline. Queuing and scheduling may still be necessary, in order to maximize the processor usage and also to impose job priorities. In order to compare different scheduling algorithms, we need formal methods to specify the real-time job scheduling system, so that properties of the algorithms may be tested against the specified model, prior to implementation. This paper develops a statecharts-based specification for real-time job scheduling systems, and compares it to the modal primitive recursive recursive arithmetic of Yodaiken and Ramamritham.

Software architecture for hard real-time applications: Cyclic executives vs. fixed priority executives

We contrast the software architecture of a hard real-time application using a fixed priority task structure against the software architecture of the same system using a cyclic executive structure to satisfy hard real-time deadlines in response to a set of embedded system requirements. We identify the perceived and actual advantages and disadvantages of both approaches, consider the types of applications which can take advantage of these approaches, and make recommendations related to the attributes of such applications that might be needed with both approaches. We conclude that the fixed priority approach, when priorities are assigned using rate monotonic priorities, generally dominates the cyclic executive approach for hard real-time systems.

Global cyclic scheduling: A method to guarantee the timing behavior of distributed real-time systems

The use of the global cyclic scheduling discipline in distributed real-time systems guarantees that the response time requirements of the environment are always met. The global scheduling discipline uses cyclic scheduling plans for its decisions. These plans are determined off-line. During the development phase of a real-time system deadlines are checked and the scheduling plans are generated. Software tools support the computation of the scheduling plans. In this paper we discuss the global cyclic scheduling discipline and present a software system to support the development of distributed real-time systems. Our software system consists of a specificaton tool for the real-time software and a schedule computation tool. Three different algorithms for the computation of the scheduling plans are presented.

On synchronization in hard-real-time systems

The design of software for hard-real-time systems is usually difficult to change because of the constraints imposed by the need to meet absolute real-time deadlines on processors with limited capacity. Nevertheless, a new approach involving a trio of ideas appears to be helpful for those who build software for such complex applications.