Synchronization in Hard Real-Time Systems

Maruti is a testbed for the design of distributed, hard real-time systems and is based on object-oriented philosophy. In such an environment, synchronization among concurrently executing objects is an important issue. Apart from providing mutual exclusion and conditional synchronization, we need to maintain the required order among threads and to characterize the timing behavior of the primitives. In this paper we have specified real-time synchronization requirements, reviewed various approaches, and evaluated them with respect to the requirements. We have proposed a set of primitives which are integrated into Maruti object-oriented programming. They are designed to be efficient and with low overheads. Separate primitives for each function makes programs more readable. They also help in pre-scheduling the application to guarantee that the deadlines will be met.

[1]  Abraham Silberschatz,et al.  Operating System Concepts , 1983 .

[2]  Craig Schaffert,et al.  An introduction to Trellis/Owl , 1986, OOPSLA 1986.

[3]  Akinori Yonezawa,et al.  Modelling and programming in an object-oriented concurrent language ABCL/1 , 1987 .

[4]  Barbara Liskov,et al.  Guardians and actions: linguistic support for robust, distributed programs , 1982, POPL '82.

[5]  Per Brinch Hansen,et al.  Structured multiprogramming , 1972, CACM.

[6]  Gary L. Peterson,et al.  Myths About the Mutual Exclusion Problem , 1981, Inf. Process. Lett..

[7]  Brian N. Bershad,et al.  A Remote Procedure Call Facility for Interconnecting Heterogeneous Computer Systems , 1987, IEEE Transactions on Software Engineering.

[8]  Alan Shaw,et al.  The logical design of operating systems , 1987 .

[9]  Brian W. Kernighan,et al.  The C Programming Language , 1978 .

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

[11]  簡聰富,et al.  物件導向軟體之架構(Object-Oriented Software Construction)探討 , 1989 .

[12]  J. Duane Northcutt,et al.  Mechanisms for Reliable Distributed Real-Time Operating Systems: The Alpha Kernel , 1987 .

[13]  David Robson,et al.  Smalltalk-80: The Language and Its Implementation , 1983 .

[14]  S. J. Young,et al.  Real Time Languages, Design and Development , 1982 .

[15]  Pierre America,et al.  Pool-T: a parallel object-oriented language , 1987 .

[16]  Michael R. McGuire,et al.  Further comments on Dijkstra's concurrent programming control problem , 1972, CACM.

[17]  Ellis Horowitz,et al.  Abstract data types and software validation , 1978, CACM.

[18]  David R. Cheriton,et al.  Thoth, a portable real-time operating system , 1979, CACM.

[19]  Niklaus Wirth,et al.  Program development by stepwise refinement , 1971, CACM.

[20]  David Lorge Parnas,et al.  Concurrent control with “readers” and “writers” , 1971, CACM.

[21]  Gregory R. Andrews,et al.  Concepts and Notations for Concurrent Programming , 1983, CSUR.

[22]  Norman C. Hutchinson,et al.  EMERALD: An object-based language for distributed programming , 1987 .

[23]  Stuart R. Faulk,et al.  On the Uses of Synchronization in Hard-real-time Systems , 1983, MILCOM 1983 - IEEE Military Communications Conference.

[24]  C. A. R. Hoare,et al.  An axiomatic basis for computer programming , 1969, CACM.

[25]  Edsger W. Dijkstra,et al.  Guarded commands, nondeterminacy and formal derivation of programs , 1975, Commun. ACM.

[26]  William J. Quirk.  Verification and Validation of Real-Time Software , 1985, Springer Berlin Heidelberg.

[27]  Henry Ledgard,et al.  Reference Manual for the ADA® Programming Language , 1983, Springer New York.

[28]  William J. Bolosky,et al.  Mach: A New Kernel Foundation for UNIX Development , 1986, USENIX Summer.

[29]  Roy H. Campbell,et al.  The specification of process synchronization by path expressions , 1974, Symposium on Operating Systems.

[30]  Robert L. Glass.  Real-time: the “Lost World” of software debugging and testing , 1980, CACM.

[31]  Satish K. Tripathi,et al.  Scheduling in Real-Time Distributed Systems - A Review. , 1987 .

[32]  Alexander D. Stoyen,et al.  Real-Time Euclid: A language for reliable real-time systems , 1989, IEEE Transactions on Software Engineering.

[33]  Edsger W. Dijkstra,et al.  The structure of the “THE”-multiprogramming system , 1968, CACM.

[34]  V. D. Gligor,et al.  Assessment of the real-time requirements for programming environments and languages , 1983, RTSS 1983.

[35]  Andrew Birrell,et al.  Implementing remote procedure calls , 1984, TOCS.

[36]  Ashok K. Agrawala,et al.  An optimal algorithm for mutual exclusion in computer networks , 1981, CACM.

[37]  Milan Milenkovic.  Operating Systems: Concepts and Design , 1987 .

[38]  Carl Hewitt,et al.  Laws for Communicating Parallel Processes , 1977, IFIP Congress.

[39]  K. Mani Chandy,et al.  The drinking philosophers problem , 1984, ACM Trans. Program. Lang. Syst..

[40]  Per Brinch Hansen,et al.  Concurrent Programming Concepts , 1973, CSUR.

[41]  Niklaus Wirth,et al.  Algorithms + Data Structures = Programs , 1976 .

[42]  Eric C. Cooper.  Replicated procedure call , 1984, PODC '84.

[43]  Edsger W. Dijkstra,et al.  Notes on structured programming , 1970 .

[44]  David R. Cheriton.  The V Kernel: A Software Base for Distributed Systems , 1984, IEEE Software.

[45]  D. F. Palmer,et al.  Real-Time System Design, Sizing, and Simulation Using DSIGNR , 1982, RTSS.

[46]  Peter Wegner,et al.  Programming Languages - The First 25 Years , 1976, IEEE Trans. Computers.

[47]  Krithi Ramamritham,et al.  Scheduling Tasks with Resource Requirements in Hard Real-Time Systems , 1987, IEEE Transactions on Software Engineering.

[48]  Ashok K. Agrawala,et al.  Objects Architecture: A Comprehensive Design Approach for Real-Time, Distributed, Fault-Tolerant, Reactive Operating Systems. , 1987 .

[49]  Leslie Lamport,et al.  A new solution of Dijkstra's concurrent programming problem , 1974, Commun. ACM.

[50]  C. A. R. Hoare,et al.  Communicating sequential processes , 1978, CACM.

[51]  David Lorge Parnas,et al.  On synchronization in hard-real-time systems , 1988, CACM.

[52]  Juergen Nehmer.  An Object Architecture for Hard Real Time Systems , 1988 .

[53]  Satish K. Tripathi,et al.  The MARUTI hard real-time operating system , 1989, OPSR.

[54]  C. A. R. Hoare,et al.  Monitors: an operating system structuring concept , 1974, CACM.

[55]  Juergen Nehmer.  A Structuring Framework for Distributed Operating Systems , 1988 .