From Wikipedia, the free encyclopedia
Just-in-time compiler for the Lua programming language
LuaJITThe logo featured on the LuaJIT website.
Original author(s) Mike Pall Stable releasev2.1.ROLLING
[1]/ August 21, 2023
; 21 months ago (2023-08-21) 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[2] Type Just-in-time compiler License MIT License[3] Website luajit.orgLuaJIT is a tracing just-in-time compiler and interpreter for the Lua programming language.
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]
LuaJIT uses rolling releases. Mike Pall, the creator and maintainer recommends using the tip of the v2.1 branch, and does not believe in releases.[6]
Mike Pall resigned in 2015 making only occasional patching to the future 2.1 version since then.[7]
LuaJIT is often the fastest Lua runtime.[13] LuaJIT has also been named the fastest implementation of a dynamic programming language.[14][15]
LuaJIT includes a Foreign Function Interface compatible with C data structures. Its use is encouraged for numerical computation.[16]
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.[17]
Internal representation[edit]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.[15]
-- 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
LuaJIT adds several extensions to its base implementation, Lua 5.1, most of which do not break compatibility.[18]
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.
RetroSearch is an open source project built by @garambo | Open a GitHub Issue
Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo
HTML:
3.2
| Encoding:
UTF-8
| Version:
0.7.4