Program representation and execution in real-time multiprocessor systems

In real-time systems the correctness of the computation depends not only on the logical correctness of the answer, but also on when it is produced. Run-time management in a real-time system must therefore exercise detailed control of how and when computations execute. As a result, most approaches to real-time scheduling require substantially more information about a computation's run-time behavior than those used by conventional (non-real-time) systems. The computation behaviors of concern vary with each system, but include: deadline, worst case execution time (WCET), resource use, communication behavior, and precedence relations. One of the ways in which real-time systems are significantly different from conventional systems is that much of of this information must be predictions about worst case computation behavior, since it is required before the computation executes. Conventional systems are, however, design to exhibit good average case behavior, not to make worst case behavior predictable. Adopting predictable worst case behavior as a primary design criterion challenges a wide range of conventional system designs and design principles. This dissertation addresses many of the problems associated with building a predictable real-time system. It presents contributions, of both theoretical and practical interest, at every level of system design and implementation, including: the Spring-C programming language, program translation and behavioral prediction methods, a predictable operating system implementation, and real-time hardware design principles and suggestions. The Spring-C programming language provides a process based programming interface and syntactic features supporting the creation of predictable programs. The compiler analyzes the program by creating a time graph representing its behavior, and then simplifying it using a technique called subgraph reduction. The simplified time graph is used to build a representation of the program's behavior as a group of tasks with known WCET and resource use, whose execution order is constrained by precedence relations. This representation is used by the system to manage the computation's execution. Predictable execution is also affected by hardware support. Our experience in implementing the Spring system generated a number of principles and examples addressing the design of hardware for real-time system support.

[1]  Alan C. Shaw,et al.  Experiments with a program timing tool based on source-level timing schema , 1990, [1990] Proceedings 11th Real-Time Systems Symposium.

[2]  Rajiv Gupta,et al.  compiler-assisted adaptive scheduling in real-time systems , 1990 .

[3]  Hideyuki Tokuda,et al.  Real-Time Mach: Towards a Predictable Real-Time System , 1990, USENIX MACH Symposium.

[4]  Hermann Kopetz,et al.  The real-time operating system of MARS , 1989, OPSR.

[5]  Kang G. Shin HARTS: A Distributed Real-Time Architecture , 1991, Computer.

[6]  Kwei-Jay Lin,et al.  Building flexible real-time systems using the Flex language , 1991, Computer.

[7]  Lui Sha,et al.  Real-time scheduling theory and Ada , 1990, Computer.

[8]  Michael L. Scott,et al.  Dynamic Sharing and Backward Compatibility on 64-Bit Machines , 1992 .

[9]  Gary M. Koob,et al.  Foundations of Real-Time Computing: Scheduling and Resource Management , 1991 .

[10]  John A. Stankovic,et al.  Predictable Real-Time Caching in the Spring System , 1991 .

[11]  Hideyuki Tokuda,et al.  Object-oriented real-time language design: constructs for timing constraints , 1990, OOPSLA/ECOOP '90.

[12]  Lory D. Molesky,et al.  Implementing a predictable real-time multiprocessor Kernel-the Spring Kernel , 1990 .

[13]  Karsten Schwan,et al.  From CHAOS/sup base/ to CHAOS/sup arc/: a family of real-time kernels , 1990, [1990] Proceedings 11th Real-Time Systems Symposium.

[14]  Krithi Ramamritham,et al.  The Spring System Description Language , 1993 .

[15]  Krithi Ramamritham,et al.  Resource Reclaiming in , 1993 .

[16]  Morris Sloman,et al.  Constructing Distributed Systems in Conic , 1989, IEEE Trans. Software Eng..

[17]  John A. Stankovic Real-time operating systems: what's wrong with today's systems and research issues , 1992 .

[18]  Pascal Raymond,et al.  The synchronous data flow programming language LUSTRE , 1991, Proc. IEEE.

[19]  Andrew R. Pleszkun,et al.  Implementing Precise Interrupts in Pipelined Processors , 1988, IEEE Trans. Computers.

[20]  Zary Segall,et al.  MACS: a predictable architecture for real time systems , 1991, [1991] Proceedings Twelfth Real-Time Systems Symposium.

[21]  Chia Shen An integrated approach to dynamic task and resource management in multiprocessor real-time systems , 1992 .

[22]  John A. Stankovic,et al.  Misconceptions About Real-Time Computing , 1988, Computer.

[23]  Krithi Ramamritham,et al.  Preemptive Scheduling Under Time and Resource Constraints , 1987, IEEE Transactions on Computers.

[24]  Krithi Ramamritham,et al.  Meta-Level Control in Distributed Real-Time Systems , 1987, ICDCS.

[25]  Rajiv Gupta,et al.  Compiler support for object-oriented real-time software , 1992, IEEE Software.

[26]  Jeannette M. Wing,et al.  DURRA : A Task-Level Description Language , 1987, ICPP.

[27]  David B. Kirk Predictable cache design for real-time systems , 1991 .

[28]  W. Zhao,et al.  GARTL: a real-time programming language based on multi-version computation , 1990, Proceedings. 1990 International Conference on Computer Languages.

[29]  Alan C. Shaw,et al.  Reasoning About Time in Higher-Level Language Software , 1989, IEEE Trans. Software Eng..

[30]  D. B. Kirk,et al.  SMART (strategic memory allocation for real-time) cache design , 1989, [1989] Proceedings. Real-Time Systems Symposium.

[31]  Alexander D. Stoyen A Schedulability Analyzer for Real-Time Euclid , 1987, RTSS.

[32]  Aloysius K. Mok,et al.  Evaluating tight execution time bounds of programs by annotations , 1989 .

[33]  John Parker,et al.  Real-Time UNIX® Systems: Design and Application Guide , 1990 .

[34]  Douglas Niehaus Program representation and translation for predictable real-time systems , 1991, [1991] Proceedings Twelfth Real-Time Systems Symposium.

[35]  Wei-Kuan Shih,et al.  Algorithms for scheduling imprecise computations , 1991, Computer.

[36]  Antony A. Faustini,et al.  Toward a Real-Time Dataflow Language , 1986, IEEE Software.

[37]  Frédéric Boussinot,et al.  The ESTEREL language , 1991, Proc. IEEE.

[38]  Albert Benveniste,et al.  The synchronous approach to reactive and real-time systems , 1991 .

[39]  Hideyuki Tokuda,et al.  The ARTS real-time object model , 1990, [1990] Proceedings 11th Real-Time Systems Symposium.

[40]  Krithi Ramamritham,et al.  O (n) Scheduling Algorithms for Real-Time Multiprocessor Systems , 1989, ICPP.

[41]  Satish K. Tripathi,et al.  Language support for the Maruti real-time system , 1990, [1990] Proceedings 11th Real-Time Systems Symposium.

[42]  Wolfgang A. Halang,et al.  Constructing Predictable Real Time Systems , 1991 .

[43]  Wayne P. Burleson,et al.  The Spring scheduling co-processor: Design, use, and performance , 1993, 1993 Proceedings Real-Time Systems Symposium.

[44]  J. Stankovic Reeective Real-time Systems , 1993 .

[45]  Chung Laung Liu,et al.  Scheduling Algorithms for Multiprogramming in a Hard-Real-Time Environment , 1989, JACM.

[46]  Karsten Schwan,et al.  CHAOS: why one cannot have only an operating system for real-time applications , 1989, OPSR.

[47]  D. L. Harris,et al.  A designer's perspective of the Hawk multiprocessor operating system kernel , 1989, OPSR.

[48]  Lui Sha,et al.  Real-time synchronization protocols for multiprocessors , 1988, Proceedings. Real-Time Systems Symposium.

[49]  R. Henn,et al.  Additional pearl language structures for the implementation of reliable and inherently safe real-time systems☆ , 1988 .

[50]  Theodore P. Baker The use of ADA for real-time systems , 1990 .

[51]  David B. Whalley,et al.  A retargetable technique for predicting execution time , 1992, [1992] Proceedings Real-Time Systems Symposium.

[52]  Krithi Ramamritham,et al.  The Spring kernel: a new paradigm for real-time systems , 1991, IEEE Software.

[53]  A. D. Stoyenko,et al.  Real-time Euclid: a language for reliable real-time systems , 1989 .

[54]  A.S. Grimshaw,et al.  Real-Time Mentat programming language and architecture , 1989, IEEE Global Telecommunications Conference, 1989, and Exhibition. 'Communications Technology for the 1990s and Beyond.

[55]  Hartwig U. Steusloff Advanced Real-Time Languages for Distributed Industrial Process Control , 1984, Computer.

[56]  Kang G. Shin,et al.  HARTOS: a distributed real-time operating system , 1989, OPSR.

[57]  Alan C. Shaw,et al.  Building a real‐time kernel: First steps in validating a pure process/ADT model , 1991, Softw. Pract. Exp..

[58]  Jay K. Strosnider,et al.  SMART (strategic memory allocation for real-time) cache design using the MIPS R3000 , 1990, [1990] Proceedings 11th Real-Time Systems Symposium.

[59]  Dennis W. Leinbaugh,et al.  Guaranteed response times in a distributed hard-real-time environment , 1986, IEEE Transactions on Software Engineering.

[60]  John A. Stankovic On the Reflective Nature of the Spring Kernel , 1991, Prozeßrechnersysteme.

[61]  Jeannette M. Wing,et al.  Specifying Functional and Timing Behavior for Real-Time Applications , 1987, PARLE.

[62]  Krithi Ramamritham,et al.  The integration of deadline and criticalness in hard real-time scheduling , 1988, Proceedings. Real-Time Systems Symposium.

[63]  Wayne P. Burleson,et al.  The spring scheduling co-processor: a scheduling accelerator , 1993, Proceedings of 1993 IEEE International Conference on Computer Design ICCD'93.

[64]  John A. Stankovic,et al.  Real-time systems: well-timed scheduling and scheduling with precedence constraints , 1993 .

[65]  Peter P. Puschner,et al.  Developing real-time tasks with predictable timing , 1992, IEEE Software.

[66]  Richard Gerber,et al.  Compiling real-time programs into schedulable code , 1993, PLDI '93.