• Corpus ID: 221640663

Repeated Recursion Unfolding for Super-Linear Speedup within Bounds

  title={Repeated Recursion Unfolding for Super-Linear Speedup within Bounds},
  author={Thom Fruehwirth},
Repeated recursion unfolding is a new approach that repeatedly unfolds a recursion with itself and simplifies it while keeping all unfolded rules. Each unfolding doubles the number of recursive steps covered. This reduces the number of recursive rule applications to its logarithm at the expense of introducing a logarithmic number of unfolded rules to the program. Efficiency crucially depends on the amount of simplification inside the unfolded rules. We prove a super-linear speedup theorem in… 

Figures from this paper



Unfolding for CHR programs

This paper defines an unfolding system for Constraint Handling Rules programs, describes an unfolding rule, shows its correctness and discusses some conditions that can be used to delete an unfolded rule while preserving the program meaning.

Properties of unfolding-based meta-level systems

It is shown that under the absence of certain features, transformation is able to speed up execution time by at most a constant factor only, and that under very weak conditions termination properties are preserved by transformation.

Nonlinear Configurations for Superlinear Speedup by Supercompilation

A conservative extension to supercompilation using equality indices that extends the range of msg-based superlinear speedups and improves the time complexity of the palindrome-suffix problem from O(2 2 ) to O(n).

Theory and Practice of Logic Programming

This work revive and redesigns the YapOr system to exploit or-parallelism based on a multi-threaded implementation and takes full advantage of the state-of-the-art fast and optimized YAP Prolog engine and shares the underlying execution environment, scheduler and most of the data structures used to support Yap or’s model.

Integration and Optimization of Rule-Based Constraint Solvers

This paper introduces a methodology for the tight integration of CHR constraint programs into one such program, and presents a method to detect redundant rules in a CHR program using the notion of operational equivalence.

Compiling CHR to parallel hardware

This paper investigates the compilation of a committed-choice rule-based language, Constraint Handling Rules (CHR), to specialized hardware circuits through the Field Programmable Gate Array (FPGA) technology, by first compiling the CHR code fragment into a low level hardware description language.

As time goes by: Constraint Handling Rules

Covering more than 180 publications, this new survey provides an overview of recent results in a wide range of research areas, from semantics and analysis to systems, extensions, and applications.

Specialization of Concurrent Guarded Multi-set Transformation Rules

This paper presents the first step towards developing program transformation techniques for a concurrent constraint programming language where guarded rules rewrite and augment multi-sets of atomic formulae, called Constraint Handling Rules (CHR).

The Refined Operational Semantics of Constraint Handling Rules

This paper formally defines this refined operational semantics of CHRs and proves it implements the theoretical operational semantics, and shows how to create a (partial) confluence checker capable of detecting programs which are confluent under this semantics, but not under the theoretical Operational semantics.

Extracting the Essence of Distillation

  • G. Hamilton
  • Computer Science
    Ershov Memorial Conference
  • 2009
This paper gives a re-formulation of the previously defined distillation algorithm, which can automatically transform higher-order functional programs into equivalent tail-recursive programs, and simplifies the presentation of the transformation.