73,501 research outputs found
Argument filterings and usable rules in higher-order rewrite systems
The static dependency pair method is a method for proving the termination of
higher-order rewrite systems a la Nipkow. It combines the dependency pair
method introduced for first-order rewrite systems with the notion of strong
computability introduced for typed lambda-calculi. Argument filterings and
usable rules are two important methods of the dependency pair framework used by
current state-of-the-art first-order automated termination provers. In this
paper, we extend the class of higher-order systems on which the static
dependency pair method can be applied. Then, we extend argument filterings and
usable rules to higher-order rewriting, hence providing the basis for a
powerful automated termination prover for higher-order rewrite systems
A static higher-order dependency pair framework
We revisit the static dependency pair method for proving termination of higher-order term rewriting and extend it in a number of ways:
(1) We introduce a new rewrite formalism designed for general applicability in termination proving of higher-order rewriting, Algebraic Functional Systems with Meta-variables.
(2) We provide a syntactically checkable soundness criterion to make the method applicable to a large class of rewrite systems.
(3) We propose a modular dependency pair framework for this higher-order setting.
(4) We introduce a fine-grained notion of formative and computable chains to render the framework more powerful.
(5) We formulate several existing and new termination proving techniques in the form of processors within our framework.
The framework has been implemented in the (fully automatic) higher-order termination tool WANDA
Dynamic Dependency Pairs for Algebraic Functional Systems
We extend the higher-order termination method of dynamic dependency pairs to
Algebraic Functional Systems (AFSs). In this setting, simply typed lambda-terms
with algebraic reduction and separate {\beta}-steps are considered. For
left-linear AFSs, the method is shown to be complete. For so-called local AFSs
we define a variation of usable rules and an extension of argument filterings.
All these techniques have been implemented in the higher-order termination tool
WANDA
Polynomial Interpretations for Higher-Order Rewriting
The termination method of weakly monotonic algebras, which has been defined
for higher-order rewriting in the HRS formalism, offers a lot of power, but has
seen little use in recent years. We adapt and extend this method to the
alternative formalism of algebraic functional systems, where the simply-typed
lambda-calculus is combined with algebraic reduction. Using this theory, we
define higher-order polynomial interpretations, and show how the implementation
challenges of this technique can be tackled. A full implementation is provided
in the termination tool WANDA
goSLP: Globally Optimized Superword Level Parallelism Framework
Modern microprocessors are equipped with single instruction multiple data
(SIMD) or vector instruction sets which allow compilers to exploit superword
level parallelism (SLP), a type of fine-grained parallelism. Current SLP
auto-vectorization techniques use heuristics to discover vectorization
opportunities in high-level language code. These heuristics are fragile, local
and typically only present one vectorization strategy that is either accepted
or rejected by a cost model. We present goSLP, a novel SLP auto-vectorization
framework which solves the statement packing problem in a pairwise optimal
manner. Using an integer linear programming (ILP) solver, goSLP searches the
entire space of statement packing opportunities for a whole function at a time,
while limiting total compilation time to a few minutes. Furthermore, goSLP
optimally solves the vector permutation selection problem using dynamic
programming. We implemented goSLP in the LLVM compiler infrastructure,
achieving a geometric mean speedup of 7.58% on SPEC2017fp, 2.42% on SPEC2006fp
and 4.07% on NAS benchmarks compared to LLVM's existing SLP auto-vectorizer.Comment: Published at OOPSLA 201
Size-Change Termination as a Contract
Termination is an important but undecidable program property, which has led
to a large body of work on static methods for conservatively predicting or
enforcing termination. One such method is the size-change termination approach
of Lee, Jones, and Ben-Amram, which operates in two phases: (1) abstract
programs into "size-change graphs," and (2) check these graphs for the
size-change property: the existence of paths that lead to infinite decreasing
sequences.
We transpose these two phases with an operational semantics that accounts for
the run-time enforcement of the size-change property, postponing (or entirely
avoiding) program abstraction. This choice has two key consequences: (1)
size-change termination can be checked at run-time and (2) termination can be
rephrased as a safety property analyzed using existing methods for systematic
abstraction.
We formulate run-time size-change checks as contracts in the style of Findler
and Felleisen. The result compliments existing contracts that enforce partial
correctness specifications to obtain contracts for total correctness. Our
approach combines the robustness of the size-change principle for termination
with the precise information available at run-time. It has tunable overhead and
can check for nontermination without the conservativeness necessary in static
checking. To obtain a sound and computable termination analysis, we apply
existing abstract interpretation techniques directly to the operational
semantics, avoiding the need for custom abstractions for termination. The
resulting analyzer is competitive with with existing, purpose-built analyzers
Refinement Types as Higher Order Dependency Pairs
Refinement types are a well-studied manner of performing in-depth analysis on
functional programs. The dependency pair method is a very powerful method used
to prove termination of rewrite systems; however its extension to higher order
rewrite systems is still the object of active research. We observe that a
variant of refinement types allow us to express a form of higher-order
dependency pair criterion that only uses information at the type level, and we
prove the correctness of this criterion
- …