Object-oriented logical specification of time-critical systems

We define TRIO+, an object-oriented logical language for modular system specification. TRIO+ is based on TRIO, a first-order temporal language that is well suited to the specification of embedded and real-time systems, and that provides an effective support to a variety of validation activities, like specification testing, simulation, and property proof. Unfortunately, TRIO lacks the ability to construct specifications of complex systems in a systematic and modular way. TRIO+ combines the use of constructs for hierarchical system decomposition and object-oriented concepts like inheritance and genericity with an expressive and intuitive graphic notation, yielding a specification language that is formal and rigorous, yet still flexible, readable, general, and easily adaptable to the user's needs. After introducing and motivating the main features of the language, we illustrate its application to a nontrivial case study extracted from a real-life industrial application.

[1]  J.A. Stankovic,et al.  Misconceptions about real-time computing: a serious problem for next-generation systems , 1988, Computer.

[2]  Jonathan S. Ostroff,et al.  Temporal logic for real-time systems , 1989 .

[3]  Ian J. Hayes,et al.  A Case-Study in Timed Refinement: A Mine Pump , 1992, IEEE Trans. Software Eng..

[4]  Niklaus Wirth,et al.  Toward a discipline of real-time programming , 1977, CACM.

[5]  Leslie Lamport,et al.  Proving Liveness Properties of Concurrent Programs , 1982, TOPL.

[6]  Donatella Sciuto,et al.  Specification and Verification of Hardware Systems using the Temporal Logic Language TRIO , 1991 .

[7]  Carlo Ghezzi,et al.  TRIO: A logic language for executable specifications of real-time systems , 1990, J. Syst. Softw..

[8]  David Scott Warren,et al.  Objects as Intensions , 1988, ICLP/SLP.

[9]  Willem P. de Roever,et al.  Examples of a Real-Time Temporal Logic Specification , 1983, The Analysis of Concurrent Systems.

[10]  Arthur J. Bernstein,et al.  Proving real-time properties of programs with temporal logic , 1981, SOSP.

[11]  Richard A. O'Keefe,et al.  Towards an Algebra for Constructing Logic Programs , 1985, International Conference on Spoken Language Processing.

[12]  Ali Mili,et al.  Structured Specifying: Techniques and Applications , 1990 .

[13]  Angelo Morzenti,et al.  An Object-Oriented Logic Language for Modular System Specification , 1991, ECOOP.

[14]  Meilir Page-Jones.  Comparing techniques by means of encapsulation and connascence , 1992, CACM.

[15]  Ron Koymans,et al.  Specifying Message Passing and Time-Critical Systems with Temporal Logic , 1992, Lecture Notes in Computer Science.

[16]  Tommaso Bolognesi,et al.  Timed Process Algebras with Urgent Interactions and a Unique Powerful Binary Operator , 1991, REX Workshop.

[17]  Daniel G. Bobrow,et al.  Vulcan: Logical Concurrent Objects , 1987, Research Directions in Object-Oriented Programming.

[18]  Alan Snyder.  Encapsulation and inheritance in object-oriented programming languages , 1986, OOPSLA 1986.

[19]  David A. Carrington,et al.  Object-Z: An Object-Oriented Extension to Z , 1989, FORTE.

[20]  José Meseguer,et al.  Principles of OBJ2 , 1985, POPL.

[21]  Sandro Morasca,et al.  FUNCTIONAL TEST CASE GENERATION FOR REAL-TIME SYSTEMS , 1993 .

[22]  Graeme Smith,et al.  The object-Z specification language: version 1 , 1991 .

[23]  Z. Manna,et al.  Verification of concurrent programs: a temporal proof system , 1983 .

[24]  Alasdair Urquhart,et al.  Temporal Logic , 1971 .

[25]  Elena Ratto,et al.  TRIO, a logic formalism for the specification of real-time systems , 1989, [1989] Proceedings. EUROMICRO Workshop on Real Time.

[26]  Carlo Ghezzi,et al.  A Unified High-level Petri Net Model for Time Critical Systems , 1991 .

[27]  Hans H. Kron,et al.  Programming-in-the-Large Versus Programming-in-the-Small , 1976, IEEE Trans. Software Eng..

[28]  W. T. Harwood,et al.  The specification of complex systems , 1986 .

[29]  Catriel Beeri,et al.  A Formal Approach to Object-Oriented Databases , 1990, Data Knowl. Eng..

[30]  Herbert B. Enderton.  A mathematical introduction to logic / Herbert B. Enderton , 1972 .

[31]  K. Fuchi,et al.  Concurrent Prolog , 1988 .

[32]  Carlo Ghezzi,et al.  A model parametric real-time logic , 1992, TOPL.

[33]  Serge Abiteboul,et al.  IFO: a formal semantic database model , 1987, TODS.

[34]  E. Corsetti,et al.  Dealing with different time scales in formal specifications , 1991, Proceedings of the Sixth International Workshop on Software Specification and Design.

[35]  Chris Smith,et al.  An Object Oriented Interpretation of LOTOS , 1989, FORTE.

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

[37]  John S. Conery,et al.  Logical Objects , 1988, ICLP/SLP.

[38]  Jean-Pierre Rosen,et al.  What orientation should Ada objects take? , 1992, CACM.

[39]  Dale Miller,et al.  A Theory of Modules for Logic Programming , 1986, SLP.

[40]  Dino Mandrioli,et al.  Proving Properties of Real-Time Systems Through Logical Specifications and Petri Net Models , 1994, IEEE Trans. Software Eng..

[41]  Miguel Felder,et al.  Validating real-time systems by history-checking TRIO specifications , 1992, ICSE '92.

[42]  Carlo Ghezzi,et al.  A Unified High-Level Petri Net Formalism for Time-Critical Systems , 1991, IEEE Trans. Software Eng..

[43]  Richard A. Kemmerer,et al.  Testing Formal Specifications to Detect Design Errors , 1985, IEEE Transactions on Software Engineering.

[44]  José Meseguer,et al.  Unifying Functional, Object-Oriented and Relational Programming with Logical Semantics , 1987, Research Directions in Object-Oriented Programming.

[45]  Angelo Morzenti,et al.  Validating Real-Time Systems by Executing Logic Specifications , 1991, REX Workshop.

[46]  Fred Krögr.  Temporal Logic Of Programs , 1987 .

[47]  A. Pnueli.  The Temporal Semantics of Concurrent Programs , 1979, Theor. Comput. Sci..

[48]  Serge Abiteboul,et al.  IFO: A Formal Semantic Database Model , 1987, ACM Trans. Database Syst..

[49]  Paul T. Ward,et al.  The transformation schema: An extension of the data flow diagram to represent control and timing , 1986, IEEE Transactions on Software Engineering.

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