LuaJIT

LuaJIT

The logo featured on the LuaJIT website.
Original author(s)	Mike Pall
Stable release	2.0.5 (later v2.1.ROLLING is also updated, e.g. in 2023) / May 1, 2017; 7 years ago (2017-05-01)
Repository	github.com/LuaJIT/LuaJIT
Written in	C, Lua
Operating system	Unix-like, MacOS, Windows, iOS, Android, PlayStation
Platform	x86, X86-64, PowerPC, ARM, MIPS[1]
Type	Just-in-time compiler
License	MIT License[2]
Website	luajit.org

LuaJIT is a tracing just-in-time compiler for the Lua programming language. Mike Pall, a primary maintainer of the project had resigned in 2015, resorting only to occasional patching to the future 2.1 version.^[3]

History

The LuaJIT project was started in 2005 by developer Mike Pall, released under the MIT open source license.^[4]

The second major release of the compiler, 2.0.0, featured major performance increases.^[5]

The latest release, 2.0.5 is released in 2017. However, Mike Pall, the creator and maintainer recommends using the tip of the v2.1 branch, and does not believe in releases.^[6]

Notable users

• CERN, for their Methodical Accelerator Design 'next-generation' software for describing and simulating particle accelerators^[7]
• OpenResty, a fork of nginx with Lua scripting^[8]
• Neovim, a text editor based on vim that allows the use of Lua for plugins and configuration^[9]
• Kong, a web API gateway^[10]
• Cloudflare, who use LuaJIT in their web application firewall service^[11]

Performance

LuaJIT is often the fastest Lua runtime.^[12] LuaJIT has also been named the fastest implementation of a dynamic programming language.^[13][14]

LuaJIT includes a Foreign Function Interface compatible with C data structures. Its use is encouraged for numerical computation.^[15]

Tracing

LuaJIT is a tracing just-in-time compiler. LuaJIT chooses loops and function calls as trace anchors to begin recording possible hot paths. Function calls will require twice as many invocations to begin recording as a loop. Once LuaJIT begins recording, all control flow, including jumps and calls, are inlined to form a linear trace. All executed bytecode instructions are stored and incrementally converted into LuaJIT's static single-assignment intermediate representation. LuaJIT's trace compiler is often capable of inlining and removing dispatches from object orientation, operators, and type modifications.^[16]

Internal representation

LuaJIT uses two types of internal representation. A stack-based bytecode is used for the interpreter, and a static single-assignment form is used for the just-in-time compiler. The interpreter bytecode is frequently patched by the JIT compiler, often to begin executing a compiled trace or to mark a segment of bytecode for causing too many trace aborts.^[14]

-- Loop with if-statement

local x = 0

for i=1,1e4 do
    x = x + 11
    if i%10 == 0 then -- if-statement
        x = x + 22
    end
    x = x + 33
end

---- TRACE 1 start Ex.lua:5
---- TRACE 1 IR
0001 int SLOAD #2 CI
0002 > num SLOAD #1 T
0003 num ADD 0002 +11
0004 int MOD 0001 +10
0005 > int NE 0004 +0
0006 + num ADD 0003 +33
0007 + int ADD 0001 +1
0008 > int LE 0007 +10000
0009 ------ LOOP ------------
0010 num ADD 0006 +11
0011 int MOD 0007 +10
0012 > int NE 0011 +0
0013 + num ADD 0010 +33
0014 + int ADD 0007 +1
0015 > int LE 0014 +10000
0016 int PHI 0007 0014
0017 num PHI 0006 0013
---- TRACE 1 stop -> loop
---- TRACE 2 start 1/4 Ex.lua:8
---- TRACE 2 IR
0001 num SLOAD #1 PI
0002 int SLOAD #2 PI
0003 num ADD 0001 +22
0004 num ADD 0003 +33
0005 int ADD 0002 +1
0006 > int LE 0005 +10000
0007 num CONV 0005 num.int
---- TRACE 2 stop -> 1

Extensions

LuaJIT adds several extensions to its base implementation, Lua 5.1, most of which do not break compatibility.^[17]

• "BitOp" for binary operations on unsigned 32-bit integers (these operations are also compiled by the just-in-time compiler)^[18]
• "CoCo", which allows the VM to be fully resumable across all contexts^[19]
• A foreign function interface^[20]
• Portable bytecode (regardless of architecture, word size, or endianness, not version)^[21]

DynASM

DynASM is a lightweight preprocessor for C that provides its own flavor of inline assembler, independent of the C compiler. DynASM replaces assembly code in C files with runtime writes to a 'code buffer', such that a developer may generate and then evoke code at runtime from a C program. It was created for LuaJIT 1.0.0 to make developing the just-in-time compiler easier.^{[citation needed]}

DynASM includes a bare-bones C header file which is used at compile time for logic the preprocessor generates. The actual preprocessor is written in Lua.

References