Verification, refinement and scheduling of real-time programs

Abstract A real-time program can be developed by refining a specification into program code. Verification of the timing properties of the program is then usually done at two levels: verification of the ordering of timed actions in the program and proof that execution of the program on a specific system will meet its timing requirements. Refinement is done within a formal model but the second step requires a different framework in which scheduling theory analysis is used and actual program execution times can be taken into account. The implementation of a program on a system is said to be feasible or schedulable if it will meet all the timing deadlines. This paper shows how the feasibility of scheduling a real-time program can also be proved as a step in the refinement of the program from its specification. Verification of this step of refinement makes use of methods from scheduling theory within a formal system development framework.

[1]  Hussein Zedan,et al.  Refinement of Complex Systems: A Case Study , 1995, Comput. J..

[2]  Robert M. Keller,et al.  Formal verification of parallel programs , 1976, CACM.

[3]  Alan Burns,et al.  Feasibility analysis of fault-tolerant real-time task sets , 1996, Proceedings of the Eighth Euromicro Workshop on Real-Time Systems.

[4]  Robert W. Floyd,et al.  Assigning Meanings to Programs , 1993 .

[5]  K. Mani Chandy,et al.  Parallel program design - a foundation , 1988 .

[6]  Mathai Joseph,et al.  Formalizing Real-Time Scheduling as Program Refinement , 1997, ARTS.

[7]  Zohar Manna,et al.  Clocked Transition Systems , 1996 .

[8]  Mathai Joseph,et al.  Finding Response Times in a Real-Time System , 1986, Comput. J..

[9]  Zohar Manna,et al.  Verifying Clocked Transition Systems , 1995, Hybrid Systems.

[10]  Zhiming Liu,et al.  Fault-tolerant programming by transformations , 1991 .

[11]  Mathai Joseph,et al.  Verification of fault tolerance and real time , 1996, Proceedings of Annual Symposium on Fault Tolerant Computing.

[12]  Jozef Hooman,et al.  Specification and Compositional Verification of Real-Time Systems , 1991, Lecture Notes in Computer Science.

[13]  Leslie Lamport,et al.  Mechanical Verification of Concurrent Systems with TLA , 1992, Larch.

[14]  Fred Kröger,et al.  Temporal Logic of Programs , 1987, EATCS Monographs on Theoretical Computer Science.

[15]  Leslie Lamport,et al.  The temporal logic of actions , 1994, TOPL.

[16]  Anders P. Ravn,et al.  Verifying duration properties of timed transition systems , 1998, PROCOMET.

[17]  Martín Abadi,et al.  The existence of refinement mappings , 1988, [1988] Proceedings. Third Annual Information Symposium on Logic in Computer Science.

[18]  Thomas A. Henzinger,et al.  Temporal proof methodologies for real-time systems , 1991, POPL '91.

[19]  Zhi-Ming Liu,et al.  Compositional Inductive Verification of Duration Properties of Real-Time Systems , 1997 .

[20]  Zohar Manna,et al.  The Temporal Logic of Reactive and Concurrent Systems , 1991, Springer New York.

[21]  C. A. R. Hoare,et al.  A Calculus of Durations , 1991, Inf. Process. Lett..

[22]  AbadiMartín,et al.  An old-fashioned recipe for real time , 1994 .

[23]  Tomasz Janowski,et al.  Dynamic Scheduling in the Presence of Faults: Specification and Verification , 1996, FTRTFT.

[24]  Kevin Warwick.  A Fault Tolerant Control Scheme , 1991 .

[25]  Mathai Joseph,et al.  Real-time systems - specification, verification and analysis , 1995, Prentice Hall International series in computer science.

[26]  James W. Layland,et al.  Scheduling Algorithms for Multiprogramming in a Hard-Real-Time Environment , 1989, JACM.

[27]  Thomas A. Henzinger,et al.  Temporal Proof Methodologies for Timed Transition Systems , 1994, Inf. Comput..

[28]  Anders P. Ravn,et al.  Duration Specifications for Shared Processors , 1992, FTRTFT.

[29]  John P. Lehoczky,et al.  The rate monotonic scheduling algorithm: exact characterization and average case behavior , 1989, [1989] Proceedings. Real-Time Systems Symposium.

[30]  Mathai Joseph.  Formal Techniques in Real-Time and Fault-Tolerant Systems , 2002, Lecture Notes in Computer Science.

[31]  Fred B. Schneider,et al.  Reasoning about Programs by Exploiting the Environment , 1994, ICALP.