• Corpus ID: 17286522

OCamlJIT 2.0 - Faster Objective Caml

  title={OCamlJIT 2.0 - Faster Objective Caml},
  author={Benedikt Meurer},
  • B. Meurer
  • Published 8 November 2010
  • Computer Science
  • ArXiv
This paper presents the current state of an ongoing research project to improve the performance of the OCaml byte-code interpreter using Just-In-Time native code generation. Our JIT engine OCamlJIT2 currently runs on x86-64 processors, mimicing precisely the behavior of the OCaml virtual machine. Its design and implementation is described, and performance measures are given. 

Figures and Tables from this paper

Just-In-Time compilation of OCaml byte-code
The improvements, including the new x86 port, are described in detail, and performance measures are given, including a direct comparison of OCamlJIT2 to OCamLJIT, the existing Just-In-Time compiler for the Ocaml byte-code virtual machine.
Towards a native toplevel for the OCaml language
This paper presents the current state of the work on an interactive toplevel for the OCaml language based on the optimizing native code compiler and runtime, which uses Just-In-Time techniques to compile topleVEL phrases to native code at runtime.
OCamlCC - Raising low-level bytecode to high-level C
We present preliminary results about OCamlCC, a compiler producing native code from OCaml bytecode executables, through the generation of C code.
OCamlCC - Traduire OCaml en C en passant par le bytecode
Résumé Nous présentons des résultats préliminaires concernant OCamlCC, un compilateur de programmes OCaml en code natif basé sur la traduction en C des exécutables bytecode.
Meta-tracing makes a fast Racket
The result of spending just a couple person-months implementing and tuning an implementation of Racket written in RPython is presented, with a geometric mean equal to Racket’s performance and within a factor of 2 slower than Gambit and Larceny on a collection of standard Scheme benchmarks.
A Functional-Level Simulator for the Configurable (Many-Core) PRAM-Like REPLICA Architecture
This master's thesis discusses the design and implementation of a simulator for the REPLICA architecture, a many-core PRAM-like machine. REPLICA provides a programming model that seemingly cannot be
Pycket: a tracing JIT for a functional language
Pycket supports a wide variety of the sophisticated features in Racket such as contracts, continuations, classes, structures, dynamic binding, and more, and outperforms existing compilers, both Racket's JIT and other highly-optimizing Scheme compilers.
Programmation Web Typée
Le but de cet these est de contribuer a rendre la programmation Web plus flexible et plus sure qu'elle ne l'est avec les solutions repandues actuellement. Pour ceci, nous proposons une solution dans


A brief history of just-in-time
This work examines the motivation behind JIT compilation and constraints imposed onJIT compilation systems, and presents a classification scheme for such systems, as it surveys forty years of JIT work.
The Behavior of Efficient Virtual Machine Interpreters on Modern Architectures
The results show that for current branch predictors, threaded code interpreters cause fewer mispredictions, and are almost twice as fast as switch based interpreters on modern superscalar architectures.
The Structure and Performance of Efficient Interpreters
This work evaluates how accurate various existing and proposed branch prediction schemes are on a number of interpreters, how the mispredictions affect the performance of the interpreters and how two different interpreter implementation techniques perform with various branch predictors.
Threaded code
The concept of “threaded code” is presented as an alternative to machine language code. Hardware and software realizations of it are given. In software it is realized as interpretive code not needing
A New Approach to Forth Native Code Generation
The heart of RAFTS is a simple method for transforming Forth programs into data ow graphs and static single assignment form, and standard code generation and optimization techniques can be applied to programs in these forms.
The LLVM compiler infrastructure is a maturing and efficient system, which is a good host for a variety of research and is designed to support optimization in the field, both at run-time and during otherwise unused idle time on the machine.
A Portable Forth Engine
The Forth engine discussed in this pa per is written in GNU C which provides several extensions that are important for Forth implemen tation The indirect threaded Forth engine is com pletely machine
LLVM: a compilation framework for lifelong program analysis & transformation
  • Chris Lattner, V. Adve
  • Computer Science
    International Symposium on Code Generation and Optimization, 2004. CGO 2004.
  • 2004
The design of the LLVM representation and compiler framework is evaluated in three ways: the size and effectiveness of the representation, including the type information it provides; compiler performance for several interprocedural problems; and illustrative examples of the benefits LLVM provides for several challenging compiler problems.
Dynamic recompilation and profile-guided optimisations for a .NET JIT compiler
The paper describes the design and implementation of an adaptive recompilation framework for Rotor, a shared source implementation of the common language infrastructure (CLI) that can increase
Optimizing indirect branch prediction accuracy in virtual machine interpreters
This paper investigates two methods for improving the prediction accuracy of BTBs for interpreters: replicating virtual machine (VM) instructions and combining sequences of VM instructions into superinstructions and compares them and several combinations of these techniques.