Re: Fwd: Octave JIT consultancy

[Daryl Maier]

Hello,

My name is Daryl Maier and I am one of the core contributors to the open
source Eclipse OMR compiler mentioned in this thread.  I was pleased to
discover your interest in possibly using the OMR compiler technology to
construct a JIT for Octave.  I encourage this effort, as the core of the
compiler was contributed into OMR precisely to make it easier to provide
JITs for language environments like this.

If you are not familiar with the OMR project please allow me to provide a
brief introduction.  OMR is a collection of open source, language agnostic
runtime components intended to be integrated into language runtimes where
that functionality is needed.  It provides core functionality for building
compilers (JITs) and garbage collectors, as well as infrastructural
components such as threading libraries and OS interfaces to make integration
and portability easier.  The runtime-neutral technology was distilled from
the J9 Java virtual machine, where it had over 15 years of development of
high-quality performance and memory optimizations and broad OS and processor
support.  The technology itself is very scalable, and has been used in small
embedded devices up through large mainframe environments.  It was open
sourced as an Eclipse Foundation project in 2016 under an Apache 2.0 and
Eclipse Public License v2 dual license.  Eclipse OMR lives in GitHub
(https://github.com/eclipse/omr) and is a very active project with a growing
community and near-daily contributions.

The compiler itself is written in C++ and was developed as a just-in-time
compiler from its inception.  Hence, its focus is on fast compile-time and
low memory footprint.  The compiler contains a rich suite of classical
compiler optimizations and the infrastructure to support speculative
optimizations and recompilation.  It can generate code for x86, Power, Z,
and AArch64 (in progress).  You can interface with the compiler component
either by writing a custom IL generator, or using a simplified programmatic
interface we've been developing called JitBuilder that abstracts away many
of the details of the compiler IL.  While the project's main consumer is
OpenJ9, we have had success producing proof-of-concept JITs for other
language environments such as Lua
(https://github.com/Leonardo2718/lua-vermelha) and WebAssembly
(https://github.com/wasmjit-omr/wasmjit-omr).

If anyone is interested in exploring the use of OMR for a JIT solution in
Octave feel free to reach out to me directly, or use one of the channels in
the Eclipse OMR community (either Slack via
https://join.slack.com/t/eclipse-omr/shared_invite/enQtMzg2ODIwODc4MTAyLTk4ZjJjNTZlZmMyMGRmYTczOTkzMGJiNTQ4NTA3YTA1NGU4MmJjNWI4NTBjOGNkNmNjMWQ3MmFmYjA4OGZjZjM
or GitHub).

I am perfectly happy to spend some time giving you a deeper dive on the
compiler technology, helping to understand the effort involved in creating a
JIT with it and learning more about Octave internals, guiding you to
determine the best way to integrate it into Octave, and answering any
questions you might have along the way.

Cheers,
..daryl




--
Sent from: https://octave.1599824.n4.nabble.com/Octave-Maintainers-f1638794.html