Runtime verification of embedded real-time systems

We present a runtime verification framework that allows on-line monitoring of past-time Metric Temporal Logic (ptMTL) specifications in a discrete time setting. We design observer algorithms for the time-bounded modalities of ptMTL, which take advantage of the highly parallel nature of hardware designs. The algorithms can be translated into efficient hardware blocks, which are designed for reconfigurability, thus, facilitate applications of the framework in both a prototyping and a post-deployment phase of embedded real-time systems. We provide formal correctness proofs for all presented observer algorithms and analyze their time and space complexity. For example, for the most general operator considered, the time-bounded Since operator, we obtain a time complexity that is doubly logarithmic both in the point in time the operator is executed and the operator’s time bounds. This result is promising with respect to a self-contained, non-interfering monitoring approach that evaluates real-time specifications in parallel to the system-under-test. We implement our framework on a Field Programmable Gate Array platform and use extensive simulation and logic synthesis runs to assess the benefits of the approach in terms of resource usage and operating frequency.

[1]  Matthias Függer,et al.  Real-Time Runtime Verification on Chip , 2012, RV.

[2]  Mark Brörkens,et al.  Dynamic Event Generation for Runtime Checking using the JDI , 2002, Electron. Notes Theor. Comput. Sci..

[3]  Daniel L. Dvorak,et al.  NASA Study on Flight Software Complexity , 2009 .

[4]  E. Allen Emerson,et al.  Temporal and Modal Logic , 1991, Handbook of Theoretical Computer Science, Volume B: Formal Models and Sematics.

[5]  Katell Morin-Allory,et al.  Proven correct monitors from PSL specifications , 2006, Proceedings of the Design Automation & Test in Europe Conference.

[6]  Joe Hurd,et al.  Executing the Formal Semantics of the Accellera Property Specification Language by Mechanised Theorem Proving , 2003, CHARME.

[7]  Jakob Engblom On Hardware and Hardware Models for Embedded Real-Time Systems , 2001 .

[8]  Alan J. Hu,et al.  Monitor-Based Formal Specification of PCI , 2000, FMCAD.

[9]  Todd M. Austin,et al.  DIVA: a reliable substrate for deep submicron microarchitecture design , 1999, MICRO-32. Proceedings of the 32nd Annual ACM/IEEE International Symposium on Microarchitecture.

[10]  Zeljko Zilic,et al.  Efficient Automata-Based Assertion-Checker Synthesis of PSL Properties , 2006, 2006 IEEE International High Level Design Validation and Test Workshop.

[11]  Andreas Steininger,et al.  Past Time LTL Runtime Verification for Microcontroller Binary Code , 2011, FMICS.

[12]  Christian Lindig,et al.  Random testing of C calling conventions , 2005, AADEBUG'05.

[13]  Harry D. Foster,et al.  Assertion-Based Design , 2010 .

[14]  Grigore Rosu,et al.  Synthesizing Monitors for Safety Properties , 2002, TACAS.

[15]  Alwyn E. Goodloe,et al.  Copilot: A Hard Real-Time Runtime Monitor , 2010, RV.

[16]  Helmut Veith,et al.  An Abstract Interpretation-Based Framework for Control Flow Reconstruction from Binaries , 2008, VMCAI.

[17]  Alessandro Forin,et al.  The Design and Implementation of P2V, An Architecture for Zero-Overhead Online Verification of Software Programs , 2007 .

[18]  Sylvain Hallé,et al.  MapReduce for parallel trace validation of LTL properties , 2015, Journal of Cloud Computing.

[19]  Stephan Merz,et al.  Model Checking , 2000 .

[20]  BouléMarc,et al.  Automata-based assertion-checker synthesis of PSL properties , 2008 .

[21]  Iain Bate,et al.  Use of Modern Processors in Safety-Critical Applications , 2001, Comput. J..

[22]  Felix Klaedtke,et al.  Algorithms for Monitoring Real-Time Properties , 2011, RV.

[23]  Moshe Y. Vardi,et al.  Deterministic Dynamic Monitors for Linear-Time Assertions , 2006, FATES/RV.

[24]  Andreas Steininger,et al.  Runtime verification of microcontroller binary code , 2014, Sci. Comput. Program..

[25]  Christel Baier,et al.  Principles of Model Checking (Representation and Mind Series) , 2008 .

[26]  Donal Heffernan,et al.  Runtime verification and monitoring of embedded systems , 2007, IET Softw..

[27]  Andreas Steininger,et al.  Automated Test-Trace Inspection for Microcontroller Binary Code , 2011, RV.

[28]  Patrick Cousot,et al.  Abstract interpretation: a unified lattice model for static analysis of programs by construction or approximation of fixpoints , 1977, POPL.

[29]  Thomas A. Henzinger,et al.  Real-Time Logics: Complexity and Expressiveness , 1993, Inf. Comput..

[30]  Pallab Dasgupta,et al.  Synthesis of System Verilog Assertions , 2006, Proceedings of the Design Automation & Test in Europe Conference.

[31]  Hoyt Lougee,et al.  SOFTWARE CONSIDERATIONS IN AIRBORNE SYSTEMS AND EQUIPMENT CERTIFICATION , 2001 .

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

[33]  Grigore Rosu,et al.  An Overview of the Runtime Verification Tool Java PathExplorer , 2004, Formal Methods Syst. Des..

[34]  Amir Pnueli,et al.  The Glory of the Past , 1985, Logic of Programs.

[35]  Xavier Leroy,et al.  Formal certification of a compiler back-end or: programming a compiler with a proof assistant , 2006, POPL '06.

[36]  Sumesh Divakaran,et al.  Conflict-Tolerant Real-Time Specifications in Metric Temporal Logic , 2010, 2010 17th International Symposium on Temporal Representation and Reasoning.

[37]  Henk Corporaal,et al.  Embedded System Design , 2006 .

[38]  Philippe Herrmann,et al.  Refinement-Based CFG Reconstruction from Unstructured Programs , 2011, VMCAI.

[39]  Peter Puschner Is Worst-Case Execution-Time Analysis a Non-Problem? — Towards New Software and Hardware Architectures , 2002 .

[40]  Dejan Nickovic,et al.  Real Time Temporal Logic: Past, Present, Future , 2005, FORMATS.

[41]  Jean-Samuel Chenard,et al.  Hardware-based Temporal Logic Checkers for the Debugging of Digital Integrated Circuits , 2011 .

[42]  Xavier Leroy,et al.  A Formally Verified Compiler Back-end , 2009, Journal of Automated Reasoning.

[43]  D. Borrione,et al.  On-line assertion-based verification with proven correct monitors , 2005, 2005 International Conference on Information and Communication Technology.

[44]  Ole J. Mengshoel,et al.  Who Guards the Guardians? - Toward V&V of Health Management Software - (Short Paper) , 2010, RV.

[45]  Grigore Rosu,et al.  Monitoring Algorithms for Metric Temporal Logic Specifications , 2004, RV@ETAPS.

[46]  Ezio Bartocci,et al.  Adaptive Runtime Verification , 2012, RV.

[47]  Christel Baier,et al.  Principles of model checking , 2008 .

[48]  Klaus Havelund,et al.  Runtime Verification of C Programs , 2008, TestCom/FATES.

[49]  Eric Eide,et al.  Volatiles are miscompiled, and what to do about it , 2008, EMSOFT '08.

[50]  Moshe Y. Vardi,et al.  Optimized temporal monitors for SystemC , 2010, RV.

[51]  Helmut Seidl,et al.  Interprocedural Control Flow Reconstruction , 2010, APLAS.

[52]  Zeljko Zilic,et al.  Incorporating efficient assertion checkers into hardware emulation , 2005, 2005 International Conference on Computer Design.

[53]  Jörg Brauer,et al.  Precise control flow reconstruction using Boolean logic , 2011, 2011 Proceedings of the Ninth ACM International Conference on Embedded Software (EMSOFT).

[54]  Daniel Kroening,et al.  Decision Procedures - An Algorithmic Point of View , 2008, Texts in Theoretical Computer Science. An EATCS Series.

[55]  Russell W. Quong,et al.  ANTLR: A predicated‐LL(k) parser generator , 1995, Softw. Pract. Exp..

[56]  Avner Landver,et al.  The ForSpec Temporal Logic: A New Temporal Property-Specification Language , 2002, TACAS.

[57]  Jeffrey D. Ullman,et al.  Introduction to Automata Theory, Languages and Computation , 1979 .

[58]  Ilan Beer,et al.  FoCs: Automatic Generation of Simulation Checkers from Formal Specifications , 2000, CAV.

[59]  Alessandro Forin,et al.  A C-Language Binding for PSL , 2007, ICESS.

[60]  Philippe Schnoebelen,et al.  Temporal logic with forgettable past , 2002, Proceedings 17th Annual IEEE Symposium on Logic in Computer Science.

[61]  Radu Grigore CONSTRUCTING CHECKERS FROM PSL PROPERTIES , 2005 .

[62]  W. Graham Richards,et al.  Art of electronics , 1983, Nature.

[63]  Grigore Rosu,et al.  Efficient monitoring of safety properties , 2004, International Journal on Software Tools for Technology Transfer.

[64]  Gordon J. Pace,et al.  Safe Runtime Verification of Real-Time Properties , 2009, FORMATS.

[65]  Xuejun Yang,et al.  Finding and understanding bugs in C compilers , 2011, PLDI '11.

[66]  Jeffrey J. P. Tsai,et al.  A Noninterference Monitoring and Replay Mechanism for Real-Time Software Testing and Debugging , 1990, IEEE Trans. Software Eng..

[67]  Doron Drusinsky Monitoring Temporal Rules Combined with Time Series , 2003, CAV.

[68]  Martin Leucker,et al.  Comparing LTL Semantics for Runtime Verification , 2010, J. Log. Comput..

[69]  Grigore Rosu,et al.  Rewriting-Based Techniques for Runtime Verification , 2005, Automated Software Engineering.

[70]  Zeljko Zilic,et al.  Efficient Automata-Based Assertion-Checker Synthesis of PSL Properties , 2006, HLDVT.

[71]  Rolf Drechsler Synthesizing checkers for on-line verification of System-on-Chip designs , 2003, Proceedings of the 2003 International Symposium on Circuits and Systems, 2003. ISCAS '03..

[72]  Grigore Rosu,et al.  Hardware Runtime Monitoring for Dependable COTS-Based Real-Time Embedded Systems , 2008, 2008 Real-Time Systems Symposium.

[73]  Lee Pike,et al.  Runtime Verification for Ultra-Critical Systems , 2011, RV.

[74]  Sebastian Fischmeister,et al.  Time-Aware Instrumentation of Embedded Software , 2010, IEEE Transactions on Industrial Informatics.

[75]  Edmund M. Clarke My 27-year Quest to Overcome the State Explosion Problem , 2009, 2009 24th Annual IEEE Symposium on Logic In Computer Science.

[76]  Jacob M. Howe,et al.  Logahedra: A New Weakly Relational Domain , 2009, ATVA.

[77]  Harold S. Stone,et al.  A Parallel Algorithm for the Efficient Solution of a General Class of Recurrence Equations , 1973, IEEE Transactions on Computers.

[78]  Mahesh Viswanathan,et al.  Runtime Assurance Based On Formal Specifications , 1999, PDPTA.