Client-specific equivalence checking

Mora, Federico; Li, Yang; Rubin, Julia; Chećhik, Marsha

doi:10.1145/3238147.3238178

Cited by 23 publications

(17 citation statements)

References 21 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…ModDiff [45] is a modular and demand-driven analysis which performs a bottom-up summarization of methods common between versions and only refines the paths of the methods that are needed to prove equivalence. CLEVER [34] formulates the notion of clientspecific equivalence checking and develops an automated technique optimized for checking the equivalence of downstream components by leveraging the fact that their calling context is unchanged. As such, CLEVER only explores paths that are relevant within the client context.…”

Section: Discussion and Related Workmentioning

confidence: 99%

“…We started by using benchmarks proposed by recent work on symbolic-execution-based equivalence checking [34,45], which we refer to as the ModDiff benchmarks. As these benchmarks are relatively small (28 cases, 7.4 statements per case on average) and contain no complex constraints, we also adapted for our evaluation benchmarks collected by Li et al [32] from the literature on evaluating symbolic and concolic execution methods in the presence of complex path conditions and non-linear functions [19,44].…”

Section: Subjectsmentioning

confidence: 99%

“…ModDiff [45] and CLEVER [34] focus on extending equivalence analysis to work in an inter-procedural manner. While these techniques also perform some pruning of common code, they only do that at a path level, eliminating full path summaries only if the entire path contains no changed statement.…”

Section: Introductionmentioning

confidence: 99%

“…We adapted these benchmarks for the equivalence checking context by systematically injecting realistic changes into each of the 57 benchmark's methods, producing one equivalent and one nonequivalent version of each method. We opted for using benchmarks by Li et al, in addition to those introduced by Trostanetski et al [34,45], for our evaluation because the latter benchmarks are relatively small and contain no complex constraints.…”

Section: Introductionmentioning

confidence: 99%

See 3 more Smart Citations

ARDiff: scaling program equivalence checking via iterative abstraction and refinement of common code

Badihi

Akinotcho

et al. 2020

Proceedings of the 28th ACM Joint Meeting on European Software Engineering Conference and Symposium on the Foundations of Softw

Self Cite

View full text Add to dashboard Cite

Equivalence checking techniques help establish whether two versions of a program exhibit the same behavior. The majority of popular techniques for formally proving/refuting equivalence relies on symbolic execution ś a static analysis approach that reasons about program behaviors in terms of symbolic input variables. Yet, symbolic execution is difficult to scale in practice due to complex programming constructs, such as loops and non-linear arithmetic. This paper proposes an approach, named ARDiff, for improving the scalability of symbolic-execution-based equivalence checking techniques when comparing syntactically-similar versions of a program, e.g., for verifying the correctness of code upgrades and refactoring. Our approach relies on a set of novel heuristics to determine which parts of the versions' common code can be effectively pruned during the analysis, reducing the analysis complexity without sacrificing its effectiveness. Furthermore, we devise a new equivalence checking benchmark, extending existing benchmarks with a set of real-life methods containing complex math functions and loops. We evaluate the effectiveness and efficiency of ARDiff on this benchmark and show that it outperforms existing method-level equivalence checking techniques by solving 86% of all equivalent and 55% of non-equivalent cases, compared with 47% to 69% for equivalent and 38% to 52% for non-equivalent cases in related work. CCS CONCEPTS • Software and its engineering → Software evolution.

show abstract

Section: Discussion and Related Workmentioning

confidence: 99%

Section: Subjectsmentioning

confidence: 99%

Section: Introductionmentioning

confidence: 99%

Section: Introductionmentioning

confidence: 99%

See 2 more Smart Citations

ARDiff: scaling program equivalence checking via iterative abstraction and refinement of common code

Badihi

Akinotcho

et al. 2020

Proceedings of the 28th ACM Joint Meeting on European Software Engineering Conference and Symposium on the Foundations of Softw

Self Cite

View full text Add to dashboard Cite

show abstract

“…Related work [11] pioneered the field of semantic differencing between two versions of a procedure by comparing dependencies between input and output variables. Symbolic execution methods [23,24,19] have proposed analysis techniques for programs with small state space and bounded loops, which may support modular regression verification. On the contrary, we can handle programs with unbounded loops and an infinite number of execution paths, like the example of Figs.…”

Section: Introductionmentioning

confidence: 99%

Analysis of Software Patches Using Numerical Abstract Interpretation

Delmas

Miné

2019

Static Analysis

View full text Add to dashboard Cite

We present a static analysis for software patches. Given two syntactically close versions of a program, our analysis can infer a semantic difference, and prove that both programs compute the same outputs when run on the same inputs. Our method is based on abstract interpretation, and parametric in the choice of an abstract domain. We focus on numeric properties only. Our method is able to deal with unbounded executions of infinite-state programs, reading from infinite input streams. Yet, it is limited to comparing terminating executions, ignoring non terminating ones. We first present a novel concrete collecting semantics, expressing the behaviors of both programs at the same time. Then, we propose an abstraction of infinite input streams able to prove that programs that read from the same stream compute equal output values. We then show how to leverage classic numeric abstract domains, such as polyhedra or octagons, to build an effective static analysis. We also introduce a novel numeric domain to bound differences between the values of the variables in the two programs, which has linear cost, and the right amount of relationality to express useful properties of software patches. We implemented a prototype and experimented on a few small examples from the literature. Our prototype operates on a toy language, and assumes a joint syntactic representation of two versions of a program given, which distinguishes between common and distinctive parts.

show abstract

Incremental Analysis of Logic Programs with Assertions and Open Predicates

Garcia-Contreras

Hermenegildo

2020

Logic-Based Program Synthesis and Transformation

View full text Add to dashboard Cite

Generic components are a further abstraction over the concept of modules, introducing dependencies on other (not necessarily available) components implementing specified interfaces. They have become a key concept in large and complex software applications. Despite undeniable advantages, generic code is also anti-modular. Precise analysis (e.g., for detecting bugs or optimizing code) requires such code to be instantiated with concrete implementations, potentially leading to expensive combinatorial explosion. In this paper we claim that incremental, whole program analysis can be very beneficial in this context, and alleviate the anti-modularity nature of generic code. We propose a simple Horn-clause encoding of generic programs, using open predicates and assertions, and we introduce a new incremental, multivariant analysis algorithm that reacts incrementally not only to changes in program clauses, but also to changes in the assertions, upon which large parts of the analysis graph may depend. We also discuss the application of the proposed techniques in a number of practical use cases. In addition, as a realistic case study , we apply the proposed techniques in the analysis of the LPdoc documentation system. W e argue that the proposed traits are a convenient and elegant abstraction for modular generic programming, and that our preliminary results support our thesis that the new incrementality-related features added to the analysis bring promising advantages in this context.Research partially funded by MINECO TIN2015-67522-C3-1-R TRACES project, FPU grant 16/04811, and the Madrid P2018/TCS-4339 BLOQUES-CM program. W e are also grateful to the anonymous reviewers for their useful comments.

show abstract

Client-specific equivalence checking

Cited by 23 publications

References 21 publications

ARDiff: scaling program equivalence checking via iterative abstraction and refinement of common code

ARDiff: scaling program equivalence checking via iterative abstraction and refinement of common code

Analysis of Software Patches Using Numerical Abstract Interpretation

Incremental Analysis of Logic Programs with Assertions and Open Predicates

Contact Info

Product

Resources

About