LuaJIT

LuaJIT es un compilador de seguimiento justo a tiempo para el lenguaje de programación Lua.

Historia

El proyecto LuaJIT fue iniciado en 2005 por el desarrollador Mike Pall, lanzado bajo la licencia de código abierto del MIT.

La segunda versión importante del compilador, 2.0.0, impulsó importantes aumentos de rendimiento

La última versión, 2.0.5, se lanzó en 2017. Desde entonces, el proyecto no es mantenido actualmente por desarrolladores que no sean colaboradores.

Usuarios notables

• CERN, por su software de 'próxima generación' Methodical Accelerator Design para describir y simular aceleradores de partículas
• OpenResty, una bifurcación de nginx con secuencias de comandos Lua
• Kong, una puerta de enlace API web
• Cloudflare, que usa LuaJIT en su servicio de firewall de aplicaciones web

Actuación

LuaJIT es a menudo el tiempo de ejecución de Lua más rápido. LuaJIT también ha sido nombrada la implementación más rápida de un lenguaje de programación dinámico. LuaJIT a veces es aclamado como competitivo en el rendimiento de C++.

LuaJIT incluye una interfaz de función externa compatible con estructuras de datos C. Se recomienda su uso para el cálculo numérico.

Rastreo

LuaJIT es un compilador de seguimiento justo a tiempo. LuaJIT elige bucles y llamadas a funciones como anclajes de seguimiento para comenzar a registrar posibles rutas activas. Las llamadas a funciones requerirán el doble de invocaciones para comenzar a grabar como un bucle. Una vez que LuaJIT comienza a grabar, todo el flujo de control, incluidos los saltos y las llamadas, se integran para formar una traza lineal. Todas las instrucciones de bytecode ejecutadas se almacenan y se convierten gradualmente en la representación intermedia estática de asignación única de LuaJIT. El compilador de seguimiento de LuaJIT a menudo es capaz de incorporar y eliminar despachos de orientación de objetos, operadores y modificaciones de tipo.

Representación interna

LuaJIT utiliza dos tipos de representación interna. Se utiliza un código de bytes basado en la pila para el intérprete (informática) y se utiliza un formulario de asignación único estático para el compilador justo a tiempo. El código de bytes del intérprete es frecuentemente parcheado por el compilador JIT, a menudo para comenzar a ejecutar un seguimiento compilado o para marcar un segmento de código de bytes por causar demasiados abortos de seguimiento.

-- Bucle con sentencia if

locales  x  =  0

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

---- TRAZA 1 inicio Ej. lua:5 
---- TRAZA 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 + núm SUMA 0003 +33 
0007 + int SUMA 0001 +1 
0008 > int LE 0007 +10000 
0009 ------ BUCLE ------------ 
0010 núm SUMA 0006 +11 
0011 int MOD 0007 +10 
0012 > int NE 0011 +0 
0013 + núm ADD 0010 +33 
0014 + int ADD 0007 +1 
0015 > int LE 0014 +10000 
0016 int PHI 0007 0014 
0017 núm PHI 0006 0013 
---- TRACE 1 parada - > loop 
---- TRACE 2 inicio 1/4 Ej.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 parada -> 1

Extensiones

LuaJIT agrega varias extensiones a su implementación base, Lua 5.1, la mayoría de las cuales no rompen la compatibilidad.

• "BitOp" para operaciones binarias en enteros de 32 bits sin signo (estas operaciones también son compiladas por el compilador justo a tiempo)
• "CoCo", que permite que la VM sea completamente reanudable en todos los contextos
• Una interfaz de función externa
• Código de bytes portátil (independientemente de la arquitectura, el tamaño de la palabra o el estado final, no la versión)

DINASM

Desarrolladores	mike pal
Liberación estable	2.0.5 / 1 de mayo de 2017; Hace 5 años
Versión preliminar	2.1.0 beta3 GC64
Repositorio	github.com /LuaJIT /LuaJIT
Escrito en	Lúa, C
Plataforma	x86, X86-64, PowerPC, BRAZO, MIPS
Escribe	Preprocesador, Enlazador
Licencia	Licencia MIT
Sitio web	luajit.org /dynasm.html

DynASM es un preprocesador liviano para C que se creó para LuaJIT 1.0.0 para facilitar el desarrollo del compilador justo a tiempo. DynASM reemplaza el código ensamblador en archivos C con escrituras en tiempo de ejecución en un 'búfer de código', de modo que un desarrollador puede generar y luego evocar código en tiempo de ejecución desde un programa C.

DynASM se eliminó gradualmente en LuaJIT 2.0.0 después de una reescritura completa del ensamblador, pero los contribuyentes de LuaJIT siguen usándolo como una mejor sintaxis de ensamblado para el intérprete de LuaJIT.

DynASM incluye un archivo de encabezado C básico que se usa en tiempo de compilación para la lógica que genera el preprocesador. El preprocesador real está escrito en Lua.

Ejemplo

|. tipo L, lua_State, esi // L. |. escriba BASE, TValue, ebx // L->base. |. escriba TOP, TValue, edi // L->top. |. escriba CI, CallInfo, ecx // L->ci. |. escriba LCL, LClosure, eax // L->ci->func->value. |. escriba UPVAL, UpVal           
           
            
           
          
   

|. Ranura de copia macro, D, S, R1, R2, R3      
| movimiento R1, S. _ valor; mov R2, S. valor _ na [ 1 ]; movimiento R3, S. _ tt            
| mov D. _ valor, R1; mov D. _ valor _ na [ 1 ], R2; mov D. _ tt, R3            
|. finmacro

|. ranura de copia macro, D, S; ranura de copia D, S, ecx, edx, eax;. finmacro           

|. macro getLCL, registro  
|| if (! J -> pt -> is_vararg) {  
| mov LCL: reg, BASE [ -1 ]. valor    
|| } más {  
| mov CI, L -> ci    
| mov TOP, CI -> func    
| mov LCL: reg, ARRIBA -> valor    
|| }
|. finmacro

|. macro getLCL; getLCL eax;. finmacro     

[...]

vacío estático jit_op_getupval (jit_State * J, int dest, int uvidx)       
{
  | obtenerLCL  
  | mov UPVAL: ecx, LCL -> upvals [ uvidx ]    
  | mov TOP, UPVAL: ecx -> v    
  | espacio de copia BASE [ destino ], SUPERIOR [ 0 ]    
}