Towards Just-In-Time Partial Evaluation of Prolog

  title={Towards Just-In-Time Partial Evaluation of Prolog},
  author={Carl Friedrich Bolz-Tereick and Michael Leuschel and Armin Rigo},
We introduce a just-in-time specializer for Prolog. [...] Key Result We evaluate the performance of our prototype on a small number of benchmarks.Expand
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. Expand
CompGen: generation of fast JIT compilers in a multi-language VM
The first Futamura projection enables compilation and high performance code generation of user programs by partial evaluation of language interpreters. Previous work has shown that online partialExpand
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. Expand
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. Expand
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. Expand
Bacon : A GPU Programming Language With Just in Time Specialization ( Draft )
This paper describes Bacon, a data-parallel programming system targeting OpenCL-compatible graphics processors. This system is built upon the existing OpenCL standard in order to make it easier forExpand
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. Expand
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. Expand


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. Expand
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. Expand
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. Expand
DyC: an expressive annotation-directed dynamic compiler for C
The design of DyC is presented, a dynamic-compilation system for C based on run-time specialization that supports program-point-specific polyvariant division and specialization, and initial results have been promising. Expand
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. Expand
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. Expand
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. Expand
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. Expand
Efficient Just-InTime Execution of Dynamically Typed Languages Via Code Specialization Using Precise Runtime Type Inference
Dynamically typed languages such as JavaScript present a challenge to just-in-time compilers. In contrast to statically typed languages such as JVML, in which there are specific opcodes for commonExpand
How to not write Virtual Machines for Dynamic Languages
Typical modern dynamic languages have a growing number of implementations. We explore the reasons for this situation, and the limitations it imposes on open source or academic communities that lackExpand