Towards Just-In-Time Partial Evaluation of Prolog

@inproceedings{BolzTereick2009TowardsJP,
  title={Towards Just-In-Time Partial Evaluation of Prolog},
  author={Carl Friedrich Bolz-Tereick and Michael Leuschel and Armin Rigo},
  booktitle={LOPSTR},
  year={2009}
}
We introduce a just-in-time specializer for Prolog. [] Key Result We evaluate the performance of our prototype on a small number of benchmarks.

Towards a jitting VM for prolog execution

It is shown that declarative languages such as Prolog can indeed benefit from having a just-in-time compiler and that PyPy can form the basis for implementing programming languages other than Python.

CompGen: generation of fast JIT compilers in a multi-language VM

The implementation of CompGen for GraalVM shows that the usage of a novel code-generation algorithm allows us to generate efficient compilers that emit fast target programs which easily outperform the first Futamura projection in compilation time.

Practical partial evaluation for high-performance dynamic language runtimes

This work defines languages solely by writing an interpreter and develops a general-purpose compilation system that is competitive with production systems even when they have been heavily optimized for the one language they support.

Just-in-time value specialization

This paper proposes parameter-based value specialization as a way to improve the quality of the code produced by JIT engines, and implements the techniques proposed in this paper in IonMonkey, an industrial quality JavaScript JIT compiler developed in the Mozilla Foundation.

Practical second Futamura projection: partial evaluation for high-performance language interpreters

This work presents an approach to speed up partial evaluation, by generating source code ahead of time, which performs partial evaluation specific to interpreter implementations, and generates source code that yields the target program faster than performing the first Futamura projection.

Bacon: A GPU Programming System With Just in Time Specialization

The OpenCL C syntax is extended into a new language, Bacon C, intended to make development significantly more convenient and enabling pre-optimizations based on just-in-time specialization as this code is compiled via OpenCL at runtime.

Bacon : A GPU Programming Language With Just in Time Specialization ( Draft )

Bacon is a data-parallel programming system targeting OpenCL-compatible graphics processors that is built upon the existing OpenCL standard in order to make it easier for programmers to write high performance kernels for GPU accelerated applications.

Runtime Compilation of Array-Oriented Python Programs

Parakeet selectively augments the standard Python interpreter by compiling and executing functions explicitly marked for acceleration by the programmer, and uses runtime type specialization to eliminate the performancedefeating dynamicism of untyped Python code.

Modularisierung und Wiederverwendung durch generische Klassen in Object Teams

The approach is considered a useful contribution for role-oriented programming in Object Teams, which can serve as an inspiration and a basis for further developments in this area.

References

SHOWING 1-10 OF 41 REFERENCES

Automatic JIT Compiler Generation with Runtime Partial Evaluation

This thesis wrote a Prolog prototype that performs partial evaluation at runtime for interpreters written in Prolog and solves some problems of classical partial evaluation and makes it at the same time applicable to dynamic languages.

HotpathVM: an effective JIT compiler for resource-constrained devices

A just-in-time compiler for a Java VM that is small enough to fit on resource-constrained devices, yet is surprisingly effective, and benchmarks show a speedup that in some cases rivals heavy-weight just- in-time compilers.

A general approach for run-time specialization and its application to C

This paper describes a general approach to run-time specialization that automatically produces source templates at compile time, and transforms them so that they can be processed by a standard compiler, and is efficient, as shown by the implementation for the C language.

DyC: an expressive annotation-directed dynamic compiler for C

Tracing the meta-level: PyPy's tracing JIT compiler

This paper shows how to guide tracing JIT compilers to greatly improve the speed of bytecode interpreters, and how to unroll the bytecode dispatch loop, based on two kinds of hints provided by the implementer of thebytecode interpreter.

Dynamic Partial Evaluation

This paper presents an implementation of dynamic partial evaluation for a simple language - a lambda calculus extended with dynamic typing, subtyping, generic functions and multiple dispatch.

Incremental Dynamic Code Generation with Trace Trees

This work explores trace-based compilation, in which the unit of compilation is a loop, potentially spanning multiple methods and even library code, and generates code that is competitive with traditional dynamic compilers, but that uses only a fraction of the compile time and memory footprint.

Representation-based just-in-time specialization and the psyco prototype for python

  • A. Rigo
  • Computer Science
    PEPM '04
  • 2004
The Psyco prototype for the Python language is presented, and the just-in-time specialization, or specialization by need, which introduces the "unlifting" ability for a value to be promoted from run-time to compile-time during specialization -- the inverse of the lift operator of partial evaluation.

Efficient Just-InTime Execution of Dynamically Typed Languages Via Code Specialization Using Precise Runtime Type Inference

This work presents a new approach to compiling dynamically typed languages in which code traces observed during execution are dynamically specialized for each actually observed run-time type.

How to not write Virtual Machines for Dynamic Languages

This paper proposes a complementary alternative to writing custom virtual machine (VMs) by hand, validated by the PyPy project: flexibly generating VMs from a high-level “specification”, inserting features and low-level details automatically – including good just-in-time compilers tuned to the dynamic language at hand.