English (United Kingdom)

https://curated-unify.zendy.io/wp-json/zendy-region/v1/featured_content/oa?rat=en

https://curated-unify.zendy.io/wp-json/zendy-region/v1/highlighted_journal/

Global: Zendy Tools annual

Presents the keyphrase highlighting as premium feature

Keyphrase Highlighting

Presents the summarisation as premium feature

Summarisation

Insights

Presents the pdf analysis as premium feature

PDF Analysis

Presents the zaia usage as premium feature

ZAIA

Global: Zendy Tools monthly

Global: Zendy Plus monthly

Presents the access of premium content as premium feature

Premium Content

Global: Zendy Plus annual

Global: Zendy Free Plan

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

An Approach to Static Performance Guarantees for Programs with Run-time Checks