A few days ago the news was released that the project Jitter officially became a project under the wing of the GNU Project and it is now being developed under the name GNU Jitter using GNU infrastructure and in accordance with the project requirements.
For those unfamiliar with Jitter, you should know that it isa is an implementation that allows to generate portable and very fast virtual machines for arbitrary designs of programming languages, whose code execution performance is significantly ahead of interpreters and close to native compiled code.
Jitter is highly portable and a correct VM will exhibit exactly the same behavior on any platform that has only a compiler and a standard C library; however, performance will be better using one of the supported architectures (currently: M68k, MIPS, PowerPC, RISC-V, SPARC, x86_64; 64nd level: Aarch390, Alpha, ARM, SXNUMXx) on ELF systems with GCC. Of course, Jitter is part of the GNU project and is designed primarily for use on the GNU system.
Umezawar takes as input a high-level specification of supported instructions by a virtual machine, and in the output forms a ready-to-use implementation of a virtual machine to execute the given instructions.
The logic of each instruction in the specification is specified using C code. Additional features include support for conditional branching operations that are difficult to implement in C and inherent in dynamic programming languages, such as tag value checking and overflow checking.
The Jitter runtime also features efficient support for difficult-to-implement conditional branching operations using only C, such as checking for value labels as required by dynamically typed languages ​​and arithmetic with overflow checking. VM code accesses procedure call and return operations, in most cases relying on efficient hardware mechanisms.
The resulting virtual machine is formatted in C with a small number of inserts assembler. Configurations are provided to enable various optimizations and select delivery mechanisms, making it easy to migrate a virtual machine to different platforms.
It supports the use of register, stack, and join execution architectures, as well as the ability to mirror virtual machine data structures in CPU hardware registers and connect garbage collectors.
The generated code includes a simple C API to dynamically replace and execute code in a virtual machine, as well as a controller program to separately execute code from text files in a virtual machine.
The generated C code is heavily conditioned and can be configured to run using different distribution techniques of varying sophistication; the most efficient dispatch techniques rely on some architecture-specific, but not VM-specific, assembly support provided by Jitter; all dispatch models, but one is also based on GNU C extensions.
Finally, for those who are interested in knowing more about it, they should know that the original Jitter code is written in C and is available under the GPLv3 license. You can learn more in the following link
How to get Jitter?
For those who are interested in being able to test Jitter, they can obtain the source code by opening a terminal and typing the following command in it:
git clone http://git.ageinghacker.net/jitter
Once this is done, now we proceed to enter the folder that has the code, we are going to execute the startup script that is used to generate the necessary files to configure and build Jitter, including a configuration script. We do this with:
cd jitter && ./bootstrap
It is worth mentioning that Jitter follows the GNU conventions for configuration and construction and supports construction from the source directory; in fact, it supports cross-compilation and even running the test suite in a cross-compilation via an emulator.
./configure && make
Finally, to execute, just type:
make check