Assertion-based analysis via slicing withABETS(system description)

Abstract

We present ABETS, an assertion-based, dynamic analyzer that helps diagnose errors in Maude programs. ABETS uses slicing to automatically create reduced versions of both a run's execution trace and executed program, reduced versions in which any information that is not relevant to the bug currently being diagnosed is removed. In addition, ABETS employs runtime assertion checking to automate the identification of bugs so that whenever an assertion is violated, the system automatically infers accurate slicing criteria from the failure. We summarize the main services provided by ABETS, which also include a novel assertion-based facility for program repair that generates suitable program fixes when a state invariant is violated. Finally, we provide an experimental evaluation that shows the performance and effectiveness of the system. This paper is under consideration for publication in TPLP.

Static correction of Maude programs with assertions

“…In column S, we report the total speedups (1 − T R fix /T Chk R ) that we achieve w.r.t. the highly optimized execution with runtime assertion checking of [4]. Finally, we record the overheads of the execution times for the original program R with respect to: 1) the monitorized execution times for R, i.e., the ratio (T Chk R −T R )/T R (in column O Chk , taken from [4]); and 2) the execution times of the repaired program, i.e., the ratio (T R fix − T R )/T R (in column O fix ).…”

“…the highly optimized execution with runtime assertion checking of [4]. Finally, we record the overheads of the execution times for the original program R with respect to: 1) the monitorized execution times for R, i.e., the ratio (T Chk R −T R )/T R (in column O Chk , taken from [4]); and 2) the execution times of the repaired program, i.e., the ratio (T R fix − T R )/T R (in column O fix ). These overheads indicate the relative slowdown due to runtime assertion checking (column O Chk ) and to the evaluation of the extra conditions inserted by the correction transformation (column O fix ).…”

“…Because of its efficient rewriting engine and its metalanguage capabilities, Maude turns out to be an excellent instrument to create rich executable environments for various logics, programming languages, and tools. Maude's formal tools are numerous and perform different analysis and verification tasks, either statically (e.g., Maude's theorem prover and model checker [3]) or dynamically (Maude's assertion checker [4]). However, to the best of our knowledge, there is no theoretical foundation for integrating assertions into a general methodology for automated program correction in Maude.…”

“…This means that: 1) every execution of R is an execution of R (i.e., no spurious computation states are produced); and 2) every assertion in A is satisfied by all computation states in R . Our correction technique works on the source code statically, so it does not depend on any concrete computations; this is in contrast with a previous, preliminary approach for dynamic program repair described in [4]. Another important feature of our technique is that it applies to Full Maude [3], which is a powerful extension of Maude that is written in Maude itself and that gives support for object-oriented specification and advanced module operations.…”

Inspecting Maude variants withGLINTS

“…However, for the sake of efficiency, other relevant information that is key for variant narrowing debugging and understanding is not disclosed by Maude, either at the meta-level (as returned by the metaGetVariant and metaGetIrredundantVariant operations themselves) or at the source-level (as delivered in raw text format by the standard Maude interactive debugger, which furthermore cannot be manipulated as a meta-level expression by Maude). To provide the user with a deeper and more agile debugging experience, we have enriched the highly efficient developer version of Maude that we implemented in previous work, Mau-Dev 5 (Alpuente et al 2016;Mau-Dev 2016), with two new meta-operations, namely metaGetVariantsExt and metaGetIrredundantVariantExt that have been implemented in C++. By doing this, besides piecing everything together and giving a graphical reconstruction of the variant narrowing tree, GLINTS also distills the equations, axioms, and builtin operators applied in (simplification and) narrowing steps, together with the equational unifier that enables each step.…”