Static Performance Guarantees for Programs with Runtime Checks

Abstract

Instrumenting programs for performing run-time checking of properties, such as regular shapes, is a common and useful technique that helps programmers detect incorrect program behaviors. This is specially true in dynamic languages such as Prolog. However, such run-time checks inevitably introduce run-time overhead (in execution time, memory, energy, etc.). Several approaches have been proposed for reducing such overhead, such as eliminating the checks that can statically be proved to always succeed, and/or optimizing the way in which the (remaining) checks are performed. However, there are cases in which it is not possible to remove all checks statically (e.g., open libraries which must check their interfaces, complex properties, unknown code, etc.) and in which, even after optimizations, these remaining checks still may introduce an unacceptable level of overhead. It is thus important for programmers to be able to determine the additional cost due to the run-time checks and compare it to some notion of admissible cost. The common practice used for estimating run-time checking overhead is profiling, which is not exhaustive by nature. Instead, we propose a method that uses static analysis to estimate such overhead, with the advantage that the estimations are functions parameterized by input data sizes. Unlike profiling, this approach can provide guarantees for all possible execution traces, and allows assessing how the overhead grows as the size of the input grows. Our method also extends an existing assertion verification framework to express "admissible" overheads, and statically and automatically checks whether the instrumented program conforms with such specifications. Finally, we present an experimental evaluation of our approach that suggests that our method is feasible and promising.

VeriFly: On-the-fly Assertion Checking via Incrementality

“…The Ciao model can be considered an antecedent of the now popular gradual-and hybrid-typing approaches (Flanagan 2006;Siek and Taha 2006;Rastogi et al 2015). Moreover, recent work by Stulova et al (2018a;2018b) illustrates further that these techniques and the exploitation of local data invariants allow maintaining strong safety guarantees with zero or very low (and potentially guaranteed (Klemen et al 2018)) run-time checking overheads, even in a reusable-library context, without requiring switching to strong typing. This approach is also more natural in Prolog-style languages that distinguish between erroneous and failed (backtracking) executions.…”

Cost Analysis of Smart Contracts Via Parametric Resource Analysis

“…This analysis was extended to be fully based on abstract interpretation [12] and integrated into the PLAI multi-variant framework, leading to contextsensitive resource analyses [59]. Other extensions include static profiling [43], static bounding of run-time checking overhead [38], or analysis of parallel programs [37]. Other applications include the previously mentioned analyses of platform-dependent properties such as time or energy [39][40][41][42]47,50,51].…”

Multivariant Assertion-based Guidance in Abstract Interpretation

“…Note that almost all current abstract interpretation systems assume in their semantics that the run-time checks will be run. However, due to efficiency considerations, assertion checking in often turned off in production code, specially for complex properties [16]. To the best of our knowledge this is the first precise description of how such annotations are processed within a standard parametric and multivariant fixpoint algorithm, and of their effects on analysis results.…”