Results 1  10
of
10
An Overview of the Runtime Verification Tool Java PathExplorer
, 2002
"... We present an overview of the Java PathExplorer runtime verification tool, in short referred to as JPaX. JPaX can monitor the execution of a Java program and check that it conforms with a set of user provided properties formulated in temporal logic. JPaX can in addition analyze the program for concu ..."
Abstract

Cited by 45 (5 self)
 Add to MetaCart
We present an overview of the Java PathExplorer runtime verification tool, in short referred to as JPaX. JPaX can monitor the execution of a Java program and check that it conforms with a set of user provided properties formulated in temporal logic. JPaX can in addition analyze the program for concurrency errors such as deadlocks and data races. The concurrency analysis requires no user provided specification. The tool facilitates automated instrumentation of a program’s bytecode, which when executed will emit an event stream, the execution trace, to an observer. The observer dispatches the incoming event stream to a set of observer processes, each performing a specialized analysis, such as the temporal logic verification, the deadlock analysis and the data race analysis. Temporal logic specifications can be formulated by the user in the Maude rewriting logic, where Maude is a highspeed rewriting system for equational logic, but here extended with executable temporal logic. The Maude rewriting engine is then activated as an event driven monitoring process. Alternatively, temporal specifications can be translated into efficient automata, which check the event stream. JPaX can be used during program testing to gain increased information about program executions, and can potentially furthermore be applied during operation to survey safety critical systems.
Rewritingbased Techniques for Runtime Verification
"... 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 limi ..."
Abstract

Cited by 29 (1 self)
 Add to MetaCart
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 e# ciency 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 rewritingbased practical algorithms are further investigated, one using rewriting directly as a means for online monitoring, and the other using rewriting to generate automatalike monitors, called binary transition tree finite state machines (and abbreviated BTTFSMs). Both rewriting algorithms are implemented in Maude, an executable specification language based on a very e#cient 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 onthefly via caching and reuse of rewrites (called memoization), resulting in a very e#cient 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 BTTFSMs from LTL formulae, which can then be used to a...
Testing Linear Temporal Logic Formulae on Finite Execution Traces
, 2001
"... We present a rewriting algorithm for efficiently testing 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 ..."
Abstract

Cited by 12 (6 self)
 Add to MetaCart
We present a rewriting algorithm for efficiently testing 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 downscaled models satisfy such LTL specifications. Our goal is instead to use LTL for upscaled 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 property and then suggest an optimized algorithm based on transforming LTL formulae. We use Maude, which turns out to be a good notation and an efficient rewriting engine for performing these experiments.
Synthesizing Dynamic Programming Algorithms from Linear Temporal Logic Formulae
, 2001
"... 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 ge ..."
Abstract

Cited by 11 (3 self)
 Add to MetaCart
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.
A Rewrite Logic Approach to Semantic Definition, Design and Analysis of ObjectOriented Languages
, 2006
"... This paper introduces a framework for rapid prototyping of object oriented programming languages and corresponding analysis tools. It is based on formal definitions of language features in rewrite logic, a simple and intuitive logic for concurrency with powerful tool support. A domainspecific front ..."
Abstract

Cited by 4 (1 self)
 Add to MetaCart
This paper introduces a framework for rapid prototyping of object oriented programming languages and corresponding analysis tools. It is based on formal definitions of language features in rewrite logic, a simple and intuitive logic for concurrency with powerful tool support. A domainspecific frontend consisting of a notation and a technique, called K, allows for compact, modular, expressive and easy to understand and change definitions of language features. The framework is illustrated by first defining KOOL, an experimental concurrent objectoriented language with exceptions, and then by discussing the definition of JAVA. Generic rewrite logic tools, such as efficient rewrite engines and model checkers, can be used on language definitions and yield interpreters and corresponding formal program analyzers at no additional cost.
A Rewritingbased Approach to Trace Analysis
 Automated Software Engineering
, 2002
"... We present a rewritingbased algorithm for efficiently evaluating future time Linear Temporal Logic (LTL) formulae on finite execution traces online. While the standard models of LTL are infinite traces, finite traces appear naturally when testing and/or monitoring real applications that only run fo ..."
Abstract

Cited by 3 (3 self)
 Add to MetaCart
We present a rewritingbased algorithm for efficiently evaluating future time Linear Temporal Logic (LTL) formulae on finite execution traces online. 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. The presented algorithm is implemented in the Maude executable specification language and essentially consists of a set of equations establishing an executable semantics of LTL using a simple formula transforming approach. The algorithm is further improved to build automata onthefly from formulae, using memoization. The result is a very efficient and small Maude program that can be used to monitor program executions. We furthermore present an alternative algorithm for synthesizing provably minimal observer finite state machines (or automata) from LTL formulae, which can be used to analyze execution traces without the need for a rewriting system, and can hence be used by observers written in conventional programming languages. The presented work is part of an ambitious runtime verification and monitoring project at NASA Ames, called PATHEXPLORER, and demonstrates that rewriting can be a tractable and attractive means for experimenting and implementing program monitoring logics. 1
Interpreting Abstract Interpretations in Membership . . .
 Proceedings of the International Workshop on RuleBased Programming (RULE’01), volume 59 of Electronic Notes in Theoretical Computer Science. Elsevier Science
, 2001
"... We present a logical framework in which abstract interpretations can be naturally specified and then verified. Our approach is based on membership equational logic which extends equational logics by membership axioms, asserting that a term has a certain sort. We represent an abstract interpretation ..."
Abstract

Cited by 2 (1 self)
 Add to MetaCart
We present a logical framework in which abstract interpretations can be naturally specified and then verified. Our approach is based on membership equational logic which extends equational logics by membership axioms, asserting that a term has a certain sort. We represent an abstract interpretation as a membership equational logic specification, usually as an overloaded ordersorted signature with membership axioms. It turns out that, for any term, its least sort over this specification corresponds to its most concrete abstract value. Maude implements membership equational logic and provides mechanisms to calculate the least sort of a term efficiently. We first show how Maude can be used to get prototyping of abstract interpretations "for free." Building on the metalogic facilities of Maude, we further develop a tool that automatically checks an abstract interpretation against a set of userdefined properties. This can be used to select an appropriate abstract interpretation, to characterize the specific loss of information during abstraction, and to compare different abstractions with each other.
Monitoring Programs using Rewriting
 In Proceedings, International Conference on Automated Software Engineering (ASE’01
, 2001
"... 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 ..."
Abstract
 Add to MetaCart
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 downscaled models satisfy such LTL specifications. Our goal is instead to use LTL for upscaled 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 (JPAX) project, the purpose of which is to develop a flexible tool for monitoring Java program executions.
K: a Rewritebased Framework for Modular Language Design, Semantics, Analysis and Implementation —Version 1—
"... K is an algebraic framework for defining programming languages. It consists of a technique and of a specialized and highly optimized notation. The Ktechnique, which can be best explained in terms of rewriting modulo equations or in terms of rewriting logic, is based on a firstorder representation ..."
Abstract
 Add to MetaCart
K is an algebraic framework for defining programming languages. It consists of a technique and of a specialized and highly optimized notation. The Ktechnique, which can be best explained in terms of rewriting modulo equations or in terms of rewriting logic, is based on a firstorder representation of continuations with intensive use of matching modulo associativity, commutativity and identity. The Knotation consists of a series of highlevel conventions that make the programming language definitions intuitive, easy to understand, to read and to teach, compact, modular and scalable. One important notational convention is based on context transformers, definitions once the concrete structure of the state is provided, by “completing ” the contexts in which the rules should apply. The K framework is introduced by defining FUN, a concurrent higherorder programming language with parametric exceptions. A rewrite logic definition of a programming language can be executed on rewrite engines, thus providing an interpreter for the language for free, but also gives an initial model semantics, amenable to formal analysis such as model checking and inductive theorem proving. Rewrite logic definitions in K can lead to
K: a Rewritebased Framework for Modular Language Design, Semantics, Analysis and Implementation —Version 2—
"... K is an algebraic framework for defining programming languages. It consists of a technique and of a specialized and highly optimized notation. The Ktechnique, which can be best explained in terms of rewriting modulo equations or in terms of rewriting logic, is based on a firstorder representation ..."
Abstract
 Add to MetaCart
K is an algebraic framework for defining programming languages. It consists of a technique and of a specialized and highly optimized notation. The Ktechnique, which can be best explained in terms of rewriting modulo equations or in terms of rewriting logic, is based on a firstorder representation of continuations with intensive use of matching modulo associativity, commutativity and identity. The Knotation consists of a series of highlevel conventions that make the programming language definitions intuitive, easy to understand, to read and to teach, compact, modular and scalable. One important notational convention is based on context transformers, definitions once the concrete structure of the state is provided, by “completing ” the contexts in which the rules should apply. The K framework is introduced by defining FUN, a concurrent higherorder programming language with parametric exceptions. A rewrite logic definition of a programming language can be executed on rewrite engines, thus providing an interpreter for the language for free, but also gives an initial model semantics, amenable to formal analysis such as model checking and inductive theorem proving. Rewrite logic definitions in K can lead to