This paper argues for the need to design a new processor scheduling algorithm that can handle the mix of applications we see today. We present a scheduling algorithm which we have implemented in the Solaris UNIX operating system [Eykholt et al. 1992], and demonstrate its improved performance over existing schedulers in research and practice on real applications. In particular, we have quantitatively compared against the popular weighted fair queueing and UNIX SVR4 schedulers in supporting multimedia applications in a realistic workstation environment...

Design-to-time is an approach to problem-solving in resource-constrained domains where: multiple solution methods are available for tasks, those solution methods make tradeoffs in solution quality versus time, and satisficing solutions are acceptable. Design-to-time involves designing a solution to a problem that uses all available resources to maximize the solution quality within the available time. This paper defines the design-to-time approach in detail, contrasting it to the anytime algorithm approach, and presents a heuristic algorithm for designto -time real-time scheduling. Our blackboard architecture that implements the design-to-time approach is discussed and an example problem and solution from the Distributed Vehicle Monitoring Testbed (DVMT) is described in detail. Experimental results, generated using a simulation, show the effects of various parameters on scheduler performance. Finally we discuss future research goals and plans. 1 This work was partly supported by the Of...

This paper surveys recent research in deliberative real-time artificial intelligence (AI). Major areas of study have been anytime algorithms, approximate processing, and large system architectures. We describe several systems in each of these areas, focusing both on progress within the field, and the costs, benefits and interactions among different problem and algorithm complexity limitations used in the surveyed work. 1 This is an invited paper that will appear in the journal Real-Time Systems in 1994. This material is based upon work supported by the National Science Foundation under Grant No. IRI-9208920, NSF contract CDA 8922572, DARPA under ONR contract N00014-92-J-1698 and ONR contract N00014-92-J-1450. The content of the information does not necessarily reflect the position or the policy of the Government and no official endorsement should be inferred. 1 Introduction Historically, the field of AI has not been particularly concerned with real-time performance. The problems ta...

. Embedded real-time systems often operate under strict timing and dependability constraints. To ensure responsiveness, these systems must be able to provide the expected services in a timely manner even in the presence of faults. In this paper, we describe a run-time environment for monitoring of timing constraints in distributed real-time systems. In particular, we focus on the problem of detecting violations of timing assertions in an environment in which the real-time tasks run on multiple processors, and timing constraints can be either inter-processor or intra-processor constraints. Constraint violations are detected at the earliest possible time by deriving and checking intermediate constraints from the user-specified constraints. If the violations must be detected as early as possible, then the problem of minimizing the number of messages to be exchanged between the processors becomes intractable. We characterize a sub-class of timing constraints that occur commonly in distribu...

A real-time system operates under timing constraints which it may be unable to meet under some circumstances. The criticality of a timing constraint determines how a system is to react when a timing failure happens. For critical timing constraints, a timing failure should be detected as soon as possible. However, early detection of timing failures requires more resource usage which may be deemed excessive. While work in real-time system monitoring has progressed in recent years, the issue of tradeoff between detection latency and resource overhead has not been adequately considered. This paper presents an approach for monitoring timing constraints in real-time systems which is based on a simple and expressive specification method for defining the timing constraints to be monitored. Efficient algorithms are developed to catch violations of timing constraints at the earliest possible time. These algorithms have been implemented in a tool called JRTM (Java Run-time Timing-constraint Monit...

As increasingly complex real-time systems are created, program representations must improve to meet the demands of more sophisticated programs. In realtime systems, when an answer is produced is part of its correctness. Proper run-time management in a real-time system thus depends on accurately predicting program execution behavior, which must be based on information either specified in the program source or derived from it during translation. This paper discusses our method for deriving behavioral predictions while translating between the programming and run-time representations used by the Spring system. A graph representation of the program is derived from the intermediate representation the compiler uses to emit code. This graph is then reduced and analyzed to make behavioral predictions. We present the basic translation method, and give examples of how it translates programming language constructs for critical sections and synchronous communication.

We present a programming language called TCEL (Time-Constrained Event Language), whose semantics is based on time-constrained relationships between observable events. Such a semantics infers only those timing constraints necessary to achieve real-time correctness, without over-constraining the system. Moreover, an optimizing compiler can exploit this looser semantics to help tune the code, so that its worst-case execution time is consistent with its real-time requirements. In this paper we describe such a transformation system, which works in two phases. First the TCEL source code is translated into an intermediate representation. Then an instructionscheduling algorithm rearranges selected unobservable operations, and synthesizes tasks guaranteed to respect the original event-based constraints. Keywords: Real-time, programming languages, compiler optimization, code scheduling, single-static assignment, timing analysis, trace scheduling, code motion. This research is supported in par...

The behaviour of a real-time system that interacts repeatedly with its environment is most succinctly specified by its possible traces, or histories. We present a way of using the refinement calculus for developing real-time programs from requirements expressed in this form. Our trace-based specification statements and target language constructs constrain the traces of system variables, rather than updating them destructively like the usual state-machine model. The only variable that is updated is a special current-time variable. The resulting calculus allows refinement from formal specificationswith hard real-time requirements, to high-level languageprograms annotated with precise timing constraints. 1 Introduction Refinement rules that preserve the functional requirements of procedural programs are now well established [18]. Such rules do not support real-time requirements, however. The Quartz project is defining a refinement method for multi-tasking applications with hard re...

We present a programming language with first-class timing constructs, whose semantics is based on timeconstrained relationships between observable events. Since a system specification postulates timing relationships between events, realizing the specification in a program becomes a more straightforward process. Using these constraints, as well as those imposed by data and control flow properties, our objective is to transform the code so that its worst-case execution time is consistent with its real-time requirements. To accomplish this goal we first translate an event-based source program into intermediate code, in which the timing constraints are imposed on the code itself, and then use a compilation technique which synthesizes feasible code from the original source program. 1 Overview The construction of a hard real-time system can, in practice, be a painful process. Many factors conspire to make this the case, among which are inflexible scheduling paradigms and the lack of high-le...

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...