Software:LuaJIT
 The logo featured on the LuaJIT website. | |
 | |
| Original author(s) | Mike Pall |
|---|---|
| Stable release | v2.1.ROLLING[1]
/ August 21, 2023 |
| Repository | github |
| 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 |
LuaJIT is a tracing just-in-time compiler and interpreter for the Lua programming language.
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]
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]
Notable users
- CERN, for their Methodical Accelerator Design 'next-generation' software for describing and simulating particle accelerators[8]
- OpenResty, a fork of nginx with Lua scripting[9]
- Neovim, a text editor based on vim that allows the use of Lua for plugins and configuration[10]
- Kong, a web API gateway[11]
- Cloudflare, who use LuaJIT in their web application firewall service[12]
Performance
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]
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.[17]
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.[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
Extensions
LuaJIT adds several extensions to its base implementation, Lua 5.1, most of which do not break compatibility.[18]
- "BitOp" for binary operations on unsigned 32-bit integers (these operations are also compiled by the just-in-time compiler)[19]
- "CoCo", which allows the VM to be fully resumable across all contexts[20]
- A foreign function interface[21]
- Portable bytecode (regardless of architecture, word size, or endianness, not version)[22]
DynASM
| Developer(s) | Mike Pall |
|---|---|
| Written in | Lua, C[23] |
| Platform | x86, X86-64, PowerPC, ARM, MIPS |
| Type | Preprocessor, Linker |
| License | MIT License[3] |
| Website | luajit |
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
- ↑ LuaJIT tags
- ↑ "LuaJIT". https://luajit.org/luajit.html.
- ↑ 3.0 3.1 "LuaJIT/COPYRIGHT at v2.1 · LuaJIT/LuaJIT". 7 January 2022. https://github.com/LuaJIT/LuaJIT/blob/v2.1/COPYRIGHT.
- ↑ "The LuaJIT Project". https://luajit.org/.
- ↑ Pall, Mike. "Re: [ANN llvm-lua 1.0"]. http://lua-users.org/lists/lua-l/2009-06/msg00071.html.
- ↑ "Project status - Issue #665 - LuaJIT/LuaJIT". https://github.com/LuaJIT/LuaJIT/issues/665.
- ↑ "[ANN Looking for new LuaJIT maintainers - luajit - FreeLists"] (in en). https://www.freelists.org/post/luajit/Looking-for-new-LuaJIT-maintainers.
- ↑ Deniau, Laurent. "Lua(Jit) for computing accelerator beam physics". CERN. https://cds.cern.ch/record/2157242.
- ↑ "OpenResty® - Official Site". https://openresty.org/en/.
- ↑ "Lua - Neovim docs". https://neovim.io/doc/user/lua.html#lua-luajit.
- ↑ "Kong/kong". Kong. 25 February 2022. https://github.com/Kong/kong.
- ↑ "Helping to make Luajit faster". 19 October 2017. https://blog.cloudflare.com/helping-to-make-luajit-faster/.
- ↑ "LuaJIT Performance". https://staff.fnwi.uva.nl/h.vandermeer/docs/lua/luajit/luajit_performance.html.
- ↑ "Laurence Tratt: The Impact of Meta-Tracing on VM Design and Implementation". https://tratt.net/laurie/research/pubs/html/bolz_tratt__the_impact_of_metatracing_on_vm_design_and_implementation/.
- ↑ 15.0 15.1 d'Andrea, Laurent (2019). Behavioural Analysis of Tracing JIT Compiler Embedded in the Methodical Accelerator Design Software (Thesis). CERN. Retrieved 31 July 2022.
- ↑ Pall, Mike. "Tuning numerical computations for LuaJIT (was Re: [ANN Sci-1.0-beta1) - luajit - FreeLists"] (in en). https://www.freelists.org/post/luajit/Tuning-numerical-computations-for-LuaJIT-was-Re-ANN-Sci10beta1.
- ↑ Rottenkolber, Max. "Later Binding: Just-in-Time Compilation of a Younger Dynamic Programming Language." ELS. 2020
- ↑ "Extensions". https://luajit.org/extensions.html.
- ↑ "BitOp Semantics". https://bitop.luajit.org/semantics.html.
- ↑ "Coco - True C Coroutines". https://coco.luajit.org/.
- ↑ "FFI Library". https://luajit.org/ext_ffi.html.
- ↑ "Extensions". https://luajit.org/extensions.html.
- ↑ "DynASM Features". https://luajit.org/dynasm_features.html.
 |  |
