# Difference between revisions of "Rewriting-Based Techniques for Runtime Verification"

From FSL

(Created page with "== Journal of Automated Software Engineering == <pubbib id='rosu-havelund-2005-jase' template='PubDefaultWithAbstractAndTitle'/> == RIACS Technical Report == <pubbib id='rosu-...") |
|||

Line 1: | Line 1: | ||

== Journal of Automated Software Engineering == | == Journal of Automated Software Engineering == | ||

<pubbib id='rosu-havelund-2005-jase' template='PubDefaultWithAbstractAndTitle'/> | <pubbib id='rosu-havelund-2005-jase' template='PubDefaultWithAbstractAndTitle'/> | ||

− | == RIACS Technical Report == | + | == ASE 2001 == |

+ | <pubbib id='havelund-rosu-2001-ase' template='PubDefaultWithAbstractAndTitle'/> | ||

+ | == 2001 RIACS Technical Report == | ||

<pubbib id='rosu-havelund-2001-tr' template='PubDefaultWithAbstractAndTitle'/> | <pubbib id='rosu-havelund-2001-tr' template='PubDefaultWithAbstractAndTitle'/> |

## Latest revision as of 13:24, 24 February 2016

## [edit] Journal of Automated Software Engineering

**Rewriting-Based Techniques for Runtime Verification**- Grigore Rosu and Klaus Havelund
, Volume 12(2), pp 151-197. 2005**J.ASE**

*Abstract.*Techniques for efficiently evaluating future time Linear Temporal Logic (abbreviated LTL) formulae on finite execution traces are presented. While the standard models of LTL are infinite traces, finite traces appear naturally when testing and/or monitoring real applications that only run for limited time periods. A finite trace variant of LTL is formally defined, together with an immediate executable semantics which turns out to be quite inefficient if used directly, via rewriting, as a monitoring procedure. Then three algorithms are investigated. First, a simple synthesis algorithm for monitors based on dynamic programming is presented; despite the efficiency of the generated monitors, they unfortunately need to analyze the trace backwards, thus making them unusable in most practical situations. To circumvent this problem, two rewriting-based practical algorithms are further investigated, one using rewriting directly as a means for online monitoring, and the other using rewriting to generate automata-like monitors, called binary transition tree finite state machines (and abbreviated BTT-FSMs). Both rewriting algorithms are implemented in Maude, an executable specification language based on a very efficient implementation of term rewriting. The first rewriting algorithm essentially consists of a set of equations establishing an executable semantics of LTL, using a simple formula transforming approach. This algorithm is further improved to build automata on-the-fly via caching and reuse of rewrites (called memoization), resulting in a very efficient and small Maude program that can be used to monitor program executions. The second rewriting algorithm builds on the first one and synthesizes provably minimal BTT-FSMs from LTL formulae, which can then be used to analyze execution traces online without the need for a rewriting system. The presented work is part of an ambitious runtime verification and monitoring project at NASA Ames, called {\sc PathExplorer}, and demonstrates that rewriting can be a tractable and attractive means for experimenting and implementing logics for program monitoring.

## [edit] ASE 2001

**Monitoring Programs using Rewriting**- Klaus Havelund and Grigore Rosu
, IEEE, pp 135-143. 2001**ASE'01**

*Abstract.*We present a rewriting algorithm for efficiently testing future time Linear Temporal Logic (LTL) formulae on finite execution traces. The standard models of LTL are infinite traces, reflecting the behavior of reactive and concurrent systems which conceptually may be continuously alive. In most past applications of LTL, theorem provers and model checkers have been used to formally prove that down-scaled models satisfy such LTL specifications. Our goal is instead to use LTL for up-scaled testing of real software applications, corresponding to analyzing the conformance of finite traces against LTL formulae. We first describe what it means for a finite trace to satisfy an LTL formula and then suggest an optimized algorithm based on transforming LTL formulae. We use the Maude rewriting logic, which turns out to be a good notation and being supported by an efficient rewriting engine for performing these experiments. The work constitutes part of the Java PathExplorer (\JPaXX) project, the purpose of which is to develop a flexible tool for monitoring Java program executions.

## [edit] 2001 RIACS Technical Report

**Synthesizing Dynamic Programming Algorithms from Linear Temporal Logic Formulae**- Grigore Rosu and Klaus Havelund
https://ti.arc.nasa.gov/m/pub-archive/archive/0220.pdf, January 2001**Technical Report**

*Abstract.*The problem of testing a linear temporal logic (LTL) formula on a finite execution trace of events, generated by an executing program, occurs naturally in runtime analysis of software. We present an algorithm which takes an LTL formula and generates an efficient dynamic programming algorithm. The generated algorithm tests whether the LTL formula is satisfied by a finite trace of events given as input. The generated algorithm runs in linear time, its constant depending on the size of the LTL formula. The memory needed is constant, also depending on the size of the formula.