第三回カーネル／VM探検隊でLuaVMに関してLTをした資料です

1. LuaVM
1 2 L u a V M
2010 2 24

2. blog:
hatena: Isoparametric
twitter: isoparametric
name:
(http://d.hatena.ne.jp/Isoparametric/)
2010 2 24

3. Lua?
Lua
LL ANSI C
2010 2 24

4. LuaVM
Lua
Lua C
if for
Lua
Lua
VM
2010 2 24

5. Lua
VM VM
2010 2 24

6. I think that one cannot completely grok a
scripting language, or any complex system for
that matter, without slitting the animal open
and examining the entrails, organs and other
yucky stuff that isn’t normally seen.
2010 2 24

7. LuaVM
VM(5.0 )
Windows
2010 2 24

8. LuaVM
2010 2 24

9. VM CPU
……CPU
……
……
PC……
2010 2 24

10. VM CPU
……CPU
……
……
PC……
2010 2 24

11. /*----------------------------------------------------------------------
38 (5.1.4 ) name args description
------------------------------------------------------------------------*/
OP_MOVE,/* A B R(A) := R(B) */
OP_LOADK,/* A Bx R(A) := Kst(Bx) */
OP_LOADBOOL,/* A B C R(A) := (Bool)B; if (C) pc++ */
R(X) X OP_LOADNIL,/* A B R(A) := ... := R(B) := nil */
OP_GETUPVAL,/* A B R(A) := UpValue[B] */
OP_GETGLOBAL,/* A Bx R(A) := Gbl[Kst(Bx)] */
OP_GETTABLE,/* A B C R(A) := R(B)[RK(C)]
*/
OP_SETGLOBAL,/* A Bx Gbl[Kst(Bx)] := R(A) */
OP_SETUPVAL,/* A B UpValue[B] := R(A) */
OP_SETTABLE,/* A B C R(A)[RK(B)] := RK(C) */
OP_NEWTABLE,/* A B C R(A) := {} (size = B,C) */
OP_SELF,/* A B C R(A+1) := R(B); R(A) := R(B)[RK(C)] */
OP_ADD,/* A B C R(A) := RK(B) + RK(C) */
K(X) X OP_SUB,/*
OP_MUL,/*
A B C R(A) := RK(B) - RK(C)
A B C R(A) := RK(B) * RK(C)
*/
*/
OP_DIV,/* A B C R(A) := RK(B) / RK(C) */
OP_MOD,/* A B C R(A) := RK(B) % RK(C) */
OP_POW,/* A B C R(A) := RK(B) ^ RK(C) */
OP_UNM,/* A B R(A) := -R(B) */
OP_NOT,/* A B R(A) := not R(B) */
OP_LEN,/* A B R(A) := length of R(B) */
OP_CONCAT,/* A B C R(A) := R(B).. ... ..R(C) */
RK(X) R(X) OP_JMP,/*
OP_EQ,/*
OP_LT,/*
sBx pc+=sBx
A B C if ((RK(B) == RK(C)) ~= A) then pc++
A B C if ((RK(B) < RK(C)) ~= A) then pc++
*/
*/
*/
OP_LE,/* A B C if ((RK(B) <= RK(C)) ~= A) then pc++ */
K(X-k) OP_TEST,/* A C if not (R(A) <=> C) then pc++
OP_TESTSET,/*
*/
A B C if (R(B) <=> C) then R(A) := R(B) else pc++ */
OP_CALL,/* A B C R(A), ... ,R(A+C-2) := R(A)(R(A+1), ... ,R(A+B-1)) */
OP_TAILCALL,/* A B C return R(A)(R(A+1), ... ,R(A+B-1)) */
OP_RETURN,/* A B return R(A), ... ,R(A+B-2) (see note) */
OP_FORLOOP,/* A sBx R(A)+=R(A+2);
if R(A) <?= R(A+1) then { pc+=sBx; R(A+3)=R(A) }*/
OP_FORPREP,/* A sBx R(A)-=R(A+2); pc+=sBx */
OP_TFORLOOP,/* A C R(A+3), ... ,R(A+2+C) := R(A)(R(A+1), R(A+2));
if R(A+3) ~= nil then R(A+2)=R(A+3) else pc++ */
OP_SETLIST,/* A B C R(A)[(C-1)*FPF+i] := R(A+i), 1 <= i <= B */
OP_CLOSE,/* A close all variables in the stack up to (>=) R(A)*/
OP_CLOSURE,/* A Bx R(A) := closure(KPROTO[Bx], R(A), ... ,R(A+n)) */
OP_VARARG/* A B R(A), R(A+1), ..., R(A+B-1) = vararg */
2010 2 24

12. /*----------------------------------------------------------------------
38 (5.1.4 ) name args description
------------------------------------------------------------------------*/
OP_MOVE,/* A B R(A) := R(B) */
OP_LOADK,/* A Bx R(A) := Kst(Bx) */
OP_LOADBOOL,/* A B C R(A) := (Bool)B; if (C) pc++ */
R(X) X OP_LOADNIL,/* A B R(A) := ... := R(B) := nil */
OP_GETUPVAL,/* A B R(A) := UpValue[B] */
OP_GETGLOBAL,/* A Bx R(A) := Gbl[Kst(Bx)] */
OP_GETTABLE,/* A B C R(A) := R(B)[RK(C)]
*/
OP_SETGLOBAL,/* A Bx Gbl[Kst(Bx)] := R(A) */
OP_SETUPVAL,/* A B UpValue[B] := R(A) */
OP_SETTABLE,/* A B C R(A)[RK(B)] := RK(C) */
OP_NEWTABLE,/* A B C R(A) := {} (size = B,C) */
OP_SELF,/* A B C R(A+1) := R(B); R(A) := R(B)[RK(C)] */
OP_ADD,/* A B C R(A) := RK(B) + RK(C) */
K(X) X OP_SUB,/*
OP_MUL,/*
A B C R(A) := RK(B) - RK(C)
A B C R(A) := RK(B) * RK(C)
*/
*/
OP_DIV,/* A B C R(A) := RK(B) / RK(C) */
OP_MOD,/* A B C R(A) := RK(B) % RK(C) */
OP_POW,/* A B C R(A) := RK(B) ^ RK(C) */
OP_UNM,/* A B R(A) := -R(B) */
OP_NOT,/* A B R(A) := not R(B) */
OP_LEN,/* A B R(A) := length of R(B) */
OP_CONCAT,/* A B C R(A) := R(B).. ... ..R(C) */
RK(X) R(X) OP_JMP,/*
OP_EQ,/*
OP_LT,/*
sBx pc+=sBx
A B C if ((RK(B) == RK(C)) ~= A) then pc++
A B C if ((RK(B) < RK(C)) ~= A) then pc++
*/
*/
*/
OP_LE,/* A B C if ((RK(B) <= RK(C)) ~= A) then pc++ */
K(X-k) OP_TEST,/* A C if not (R(A) <=> C) then pc++
OP_TESTSET,/*
*/
A B C if (R(B) <=> C) then R(A) := R(B) else pc++ */
OP_CALL,/* A B C R(A), ... ,R(A+C-2) := R(A)(R(A+1), ... ,R(A+B-1)) */
OP_TAILCALL,/* A B C return R(A)(R(A+1), ... ,R(A+B-1)) */
OP_RETURN,/* A B return R(A), ... ,R(A+B-2) (see note) */
OP_FORLOOP,/* A sBx R(A)+=R(A+2);
if R(A) <?= R(A+1) then { pc+=sBx; R(A+3)=R(A) }*/
OP_FORPREP,/* A sBx R(A)-=R(A+2); pc+=sBx */
OP_TFORLOOP,/* A C R(A+3), ... ,R(A+2+C) := R(A)(R(A+1), R(A+2));
if R(A+3) ~= nil then R(A+2)=R(A+3) else pc++ */
OP_SETLIST,/* A B C R(A)[(C-1)*FPF+i] := R(A+i), 1 <= i <= B */
OP_CLOSE,/* A close all variables in the stack up to (>=) R(A)*/
OP_CLOSURE,/* A Bx R(A) := closure(KPROTO[Bx], R(A), ... ,R(A+n)) */
OP_VARARG/* A B R(A), R(A+1), ..., R(A+B-1) = vararg */
2010 2 24

13. MOVE
LOADK
LOADBOOL
LOADNIL nil
GETUPVAL
GETGLOBAL
GETTABLE
SETGLOBAL
SETUPVAL
SETTABLE
2010 2 24

14. NEWTABLE
SELF
ADD
SUB
MUL
DIV
MOD
POW
UNM
NOT
2010 2 24

15. LEN
CONCAT
JMP
EQ
LT
LE
TEST
TESTSET
CALL
TAILCALL
2010 2 24

16. RETURN
FORLOOP for FORPREP
FORPREP for
TFORLOOP for
SETLIST
CLOSE
CLOSURE
VARARG
2010 2 24

17. 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
OP A B C
OP A Bx
OP A sBx
Figure 6: Instruction layout
OP 6bit
function max (a,b)
local m = a 1 MOVE 2 0 0 ; R(2) = R(0)
if b > a then 2 LT 0 0 1 ; R(0) < R(1) ?
m = b
end
3
4
A
JMP
MOVE
1
2 1 0
;
;
8bit
to 5 (4+1)
R(2) = R(1)
return m 5 RETURN 2 2 0 ; return R(2)
end 6 B C 9bit
RETURN 0 1 0 ; return
18bit 7: Bytecode for a Lua function
Figure
Bx(unsigned) or sBx(signed)
a register or a constant (using the representation RK(X) explained above). With
this format, several typical operations in Lua can be coded in a single instruction.
2010 2 24

18. OP A Bx
OP A sBx
Figure 6: Instruction layout
function max (a,b)
local m = a 1 MOVE 2 0 0 ; R(2) = R(0)
if b > a then 2 LT 0 0 1 ; R(0) < R(1) ?
m = b 3 JMP 1 ; to 5 (4+1)
end 4 MOVE 2 1 0 ; R(2) = R(1)
return m 5 RETURN 2 2 0 ; return R(2)
end 6 RETURN 0 1 0 ; return
Figure 7: Bytecode for a Lua function
a register or a constant (using the representation RK(X) explained above). With
this format, several typical operations in Lua can be coded in a single instruction.
For instance, the increment of a local variable, such as a = a + 1, is coded
as ADD x x y, where x represents the register holding the local variable and y
represents the constant 1. An assignment like a = b.f, when both a and b are
local variables, is also coded as the single instruction GETTABLE x y z, where x
is the register for a, y is the register for b, and z is the index of the string
constant "f". (In Lua, the syntax b.f is syntactic sugar for b["f"], that is, b
2010 2 24 indexed by the string "f".)

19. OP A Bx
OP A sBx
Figure 6: Instruction layout
function max (a,b)
local m = a 1 MOVE 2 0 0 ; R(2) = R(0)
if b > a then 2 LT 0 0 1 ; R(0) < R(1) ?
m = b 3 JMP 1 ; to 5 (4+1)
end 4 MOVE 2 1 0 ; R(2) = R(1)
return m 5 RETURN 2 2 0 ; return R(2)
end 6 RETURN 0 1 0 ; return
Figure 7: Bytecode for a Lua function
R(0) == a, R(1) == b
a register or a constant (using the representation RK(X) explained above). With
this format, several typical operations in Lua can be coded in a single instruction.
LT For instance, the increment of a local variable, such as a = a + 1, is coded
as ADD x x y, where x represents the register holding the local variable and y
PC++ JMP
represents the constant 1. An assignment like a = b.f, when both a and b are
local variables, is also coded as the single instruction GETTABLE x y z, where x
OP_LT,/* A B C if ((RK(B) < RK(C)) ~= A) then pc++
is the register for a, y is the register for b, and z is the index of the string
constant "f". (In Lua, the syntax b.f is syntactic sugar for b["f"], that is, b
*/
2010 2 24 indexed by the string "f".)

20. 256
B/C 9bit==1bit
Lua
18bit (131071 )
2010 2 24

21. VM Lua
VM
lua -l
2010 2 24

22. Lua
1.0 1.1 2.1 2.2 2.4 2.5 3.0 3.1 3.2 4.0 5.0 5.1
constructors • • • • • • • • • • • •
garbage collection • • • • • • • • • • • •
extensible semantics ◦ ◦ • • • • • • • • • •
support for OOP ◦ ◦ • • • • • • • • • •
long strings ◦ ◦ ◦ • • • • • • • • •
debug API ◦ ◦ ◦ • • • • • • • • •
external compiler ◦ ◦ ◦ ◦ • • • • • • • •
vararg functions ◦ ◦ ◦ ◦ ◦ • • • • • • •
pattern matching ◦ ◦ ◦ ◦ ◦ • • • • • • •
conditional compilation ◦ ◦ ◦ ◦ ◦ ◦ • • • ◦ ◦ ◦
anonymous functions, closures ◦ ◦ ◦ ◦ ◦ ◦ ◦ • • • • •
debug library ◦ ◦ ◦ ◦ ◦ ◦ ◦ ◦ • • • •
multi-state API ◦ ◦ ◦ ◦ ◦ ◦ ◦ ◦ ◦ • • •
for statement ◦ ◦ ◦ ◦ ◦ ◦ ◦ ◦ ◦ • • •
long comments ◦ ◦ ◦ ◦ ◦ ◦ ◦ ◦ ◦ ◦ • •
full lexical scoping ◦ ◦ ◦ ◦ ◦ ◦ ◦ ◦ ◦ ◦ • •
booleans ◦ ◦ ◦ ◦ ◦ ◦ ◦ ◦ ◦ ◦ • •
coroutines ◦ ◦ ◦ ◦ ◦ ◦ ◦ ◦ ◦ ◦ • •
incremental garbage collection ◦ ◦ ◦ ◦ ◦ ◦ ◦ ◦ ◦ ◦ ◦ •
module system ◦ ◦ ◦ ◦ ◦ ◦ ◦ ◦ ◦ ◦ ◦ •
1.0 1.1 2.1 2.2 2.4 2.5 3.0 3.1 3.2 4.0 5.0 5.1
libraries 4 4 4 4 4 4 4 4 5 6 8 9
built-in functions 5 7 11 11 13 14 25 27 35 0 0 0
API functions 30 30 30 30 32 32 33 47 41 60 76 79
vm type (stack × register) S S S S S S S S S S R R
vm instructions 64 65 69 67 67 68 69 128 64 49 35 38
keywords 16 16 16 16 16 16 16 16 16 18 21 21
other tokens 21 21 23 23 23 23 24 25 25 25 24 26
Table 1. The evolution of features in Lua.
2010 2 24

23. Lua
1.0 1.1 2.1 2.2 2.4 2.5 3.0 3.1 3.2 4.0 5.0 5.1
constructors • • • • • • • • • • • •
garbage collection • • • • • • • • • • • •
extensible semantics ◦ ◦ • • • • • • • • • •
support for OOP ◦ ◦ • • • • • • • • • •
long strings ◦ ◦ ◦ • • • • • • • • •
debug API ◦ ◦ ◦ • • • • • • • • •
external compiler ◦ ◦ ◦ ◦ • • • • • • • •
vararg functions ◦ ◦ ◦ ◦ ◦ • • • • • • •
pattern matching ◦ ◦ ◦ ◦ ◦ • • • • • • •
conditional compilation ◦ ◦ ◦ ◦ ◦ ◦ • • • ◦ ◦ ◦
anonymous functions, closures ◦ ◦ ◦ ◦ ◦ ◦ ◦ • • • • •
debug library ◦ ◦ ◦ ◦ ◦ ◦ ◦ ◦ • • • •
multi-state API ◦ ◦ ◦ ◦ ◦ ◦ ◦ ◦ ◦ • • •
for statement ◦ ◦ ◦ ◦ ◦ ◦ ◦ ◦ ◦ • • •
long comments ◦ ◦ ◦ ◦ ◦ ◦ ◦ ◦ ◦ ◦ • •
full lexical scoping ◦ ◦ ◦ ◦ ◦ ◦ ◦ ◦ ◦ ◦ • •
booleans ◦ ◦ ◦ ◦ ◦ ◦ ◦ ◦ ◦ ◦ • •
coroutines ◦ ◦ ◦ ◦ ◦ ◦ ◦ ◦ ◦ ◦ • •
incremental garbage collection ◦ ◦ ◦ ◦ ◦ ◦ ◦ ◦ ◦ ◦ ◦ •
module system ◦ ◦ ◦ ◦ ◦ ◦ ◦ ◦ ◦ ◦ ◦ •
1.0 1.1 2.1 2.2 2.4 2.5 3.0 3.1 3.2 4.0 5.0 5.1
libraries 4 4 4 4 4 4 4 4 5 6 8 9
built-in functions 5 7 11 11 13 14 25 27 35 0 0 0
API functions 30 30 30 30 32 32 33 47 41 60 76 79
vm type (stack × register) S S S S S S S S S S R R
vm instructions 64 65 69 67 67 68 69 128 64 49 35 38
keywords 16 16 16 16 16 16 16 16 16 18 21 21
other tokens 21 21 23 23 23 23 24 25 25 25 24 26
Table 1. The evolution of features in Lua.
2010 2 24

24. Lua
1.0 1.1 2.1 2.2 2.4 2.5 3.0 3.1 3.2 4.0 5.0 5.1
constructors • • • • • • • • • • • •
garbage collection • • • • • • • • • • • •
extensible semantics ◦ ◦ • • • • • • • • • •
support for OOP ◦ ◦ • • • • • • • • • •
long strings ◦ ◦ ◦ • • • • • • • • •
debug API ◦ ◦ ◦ • • • • • • • • •
external compiler ◦ ◦ ◦ ◦ • • • • • • • •
vararg functions ◦ ◦ ◦ ◦ ◦ • • • • • • •
pattern matching ◦ ◦ ◦ ◦ ◦ • • • • • • •
conditional compilation ◦ ◦ ◦ ◦ ◦ ◦ • • • ◦ ◦ ◦
anonymous functions, closures ◦ ◦ ◦ ◦ ◦ ◦ ◦ • • • • •
debug library ◦ ◦ ◦ ◦ ◦ ◦ ◦ ◦ • • • •
multi-state API ◦ ◦ ◦ ◦ ◦ ◦ ◦ ◦ ◦ • • •
for statement ◦ ◦ ◦ ◦ ◦ ◦ ◦ ◦ ◦ • • •
long comments ◦ ◦ ◦ ◦ ◦ ◦ ◦ ◦ ◦ ◦ • •
full lexical scoping ◦ ◦ ◦ ◦ ◦ ◦ ◦ ◦ ◦ ◦ • •
booleans ◦ ◦ ◦ ◦ ◦ ◦ ◦ ◦ ◦ ◦ • •
coroutines ◦ ◦ ◦ ◦ ◦ ◦ ◦ ◦ ◦ ◦ • •
incremental garbage collection ◦ ◦ ◦ ◦ ◦ ◦ ◦ ◦ ◦ ◦ ◦ •
module system ◦ ◦ ◦ ◦ ◦ ◦ ◦ ◦ ◦ ◦ ◦ •
1.0 1.1 2.1 2.2 2.4 2.5 3.0 3.1 3.2 4.0 5.0 5.1
libraries 4 4 4 4 4 4 4 4 5 6 8 9
built-in functions 5 7 11 11 13 14 25 27 35 0 0 0
API functions 30 30 30 30 32 32 33 47 41 60 76 79
vm type (stack × register) S S S S S S S S S S R R
vm instructions 64 65 69 67 67 68 69 128 64 49 35 38
keywords 16 16 16 16 16 16 16 16 16 18 21 21
other tokens 21 21 23 23 23 23 24 25 25 25 24 26
Table 1. The evolution of features in Lua.
2010 2 24

25. VM
V S V M
2010 2 24

26. VM
VM
push
VM VM
2010 2 24

27. VM
Lua
VM Lua
local
push/pop
2010 2 24

28. LuaVM
Lua
2010 2 24

29. == ==
2010 2 24

30. == ==
Lua VM ……
VM
2010 2 24

31. 2010 2 24

32. LuaVM
4byte Lua
1byte 2byte
2010 2 24

33. ADD
ADD
ADD
ADD
+
2010 2 24

34. JavaVM goto 2byte)
2byte
2010 2 24

35. Lua 4byte Lua 1 or 2byte
2010 2 24

36. local a,t,i
a=a+i
a=a+100 YO
a=t[i]
2010 2 24

37. local a,t,i
a=a+i
a=a+100 YO
a=t[i]
1
[1]
PUSHNIL 3
2
[2]
GETLOCAL 0 ; a
3
[2]
GETLOCAL 2 ; i
4
[2]
ADD
5
[2]
SETLOCAL 0 ; a
6
[3]
GETLOCAL 0 ; a
7
[3]
ADDI 100
8
[3]
SETLOCAL 0 ; a
9
[4]
GETLOCAL 1 ; t
10
[4]
GETINDEXED 2 ; i
11
[4]
SETLOCAL 0 ; a
12
[4]
END
2010 2 24

38. local a,t,i
a=a+i
a=a+100 YO
a=t[i]
1
[1]
PUSHNIL 3 1 [2]ADD 0 0 2
2
[2]
GETLOCAL 0 ; a 2 [3]ADD 0 0 -1 ; - 100
3
[2]
GETLOCAL 2 ; i 3 [4]GETTABLE 0 1 2
4
[2]
ADD 4 [4]RETURN 0 1
5
[2]
SETLOCAL 0 ; a
6
[3]
GETLOCAL 0 ; a
7
[3]
ADDI 100
8
[3]
SETLOCAL 0 ; a
9
[4]
GETLOCAL 1 ; t
10
[4]
GETINDEXED 2 ; i
11
[4]
SETLOCAL 0 ; a
12
[4]
END
2010 2 24

39. Lua 4.0.1
main <0:@test.lua> (12 instructions/96 bytes at 0x100100650)
0 params, 5 stacks, 3 locals, 0 strings, 0 numbers, 0 functions, 5
lines
1
[1]
PUSHNIL 3
2
[2]
GETLOCAL 0 ; a
3
[2]
GETLOCAL 2 ; i
4
[2]
ADD
5
[2]
SETLOCAL 0 ; a
6
[3]
GETLOCAL 0 ; a
7
[3]
ADDI 100
8
[3]
SETLOCAL 0 ; a
9
[4]
GETLOCAL 1 ; t
10 [4]
GETINDEXED 2 ; i
11 [4]
SETLOCAL 0 ; a
12 [4]
END
2010 2 24

40. Lua 4.0.1
main <0:@test.lua> (12 instructions/96 bytes at 0x100100650)
0 params, 5 stacks, 3 locals, 0 strings, 0 numbers, 0 functions, 5
lines
1
[1]
PUSHNIL 3 local a,t,i
2
[2]
GETLOCAL 0 ; a
3
[2]
GETLOCAL 2 ; i
4
[2]
ADD
5
[2]
SETLOCAL 0 ; a
6
[3]
GETLOCAL 0 ; a
7
[3]
ADDI 100
8
[3]
SETLOCAL 0 ; a
9
[4]
GETLOCAL 1 ; t
10 [4]
GETINDEXED 2 ; i
11 [4]
SETLOCAL 0 ; a
12 [4]
END
2010 2 24

41. Lua 4.0.1
main <0:@test.lua> (12 instructions/96 bytes at 0x100100650)
0 params, 5 stacks, 3 locals, 0 strings, 0 numbers, 0 functions, 5
lines
1
[1]
PUSHNIL 3 local a,t,i
2
[2]
GETLOCAL 0 ; a
3
[2]
GETLOCAL 2 ; i a=a+i
4
[2]
ADD
5
[2]
SETLOCAL 0 ; a
6
[3]
GETLOCAL 0 ; a
7
[3]
ADDI 100
8
[3]
SETLOCAL 0 ; a
9
[4]
GETLOCAL 1 ; t
10 [4]
GETINDEXED 2 ; i
11 [4]
SETLOCAL 0 ; a
12 [4]
END
2010 2 24

42. Lua 4.0.1
main <0:@test.lua> (12 instructions/96 bytes at 0x100100650)
0 params, 5 stacks, 3 locals, 0 strings, 0 numbers, 0 functions, 5
lines
1
[1]
PUSHNIL 3 local a,t,i
2
[2]
GETLOCAL 0 ; a
3
[2]
GETLOCAL 2 ; i a=a+i
4
[2]
ADD
5
[2]
SETLOCAL 0 ; a
6
[3]
GETLOCAL 0 ; a
7
[3]
ADDI 100
a=a+100
8
[3]
SETLOCAL 0 ; a
9
[4]
GETLOCAL 1 ; t
10 [4]
GETINDEXED 2 ; i
11 [4]
SETLOCAL 0 ; a
12 [4]
END
2010 2 24

43. Lua 4.0.1
main <0:@test.lua> (12 instructions/96 bytes at 0x100100650)
0 params, 5 stacks, 3 locals, 0 strings, 0 numbers, 0 functions, 5
lines
1
[1]
PUSHNIL 3 local a,t,i
2
[2]
GETLOCAL 0 ; a
3
[2]
GETLOCAL 2 ; i a=a+i
4
[2]
ADD
5
[2]
SETLOCAL 0 ; a
6
[3]
GETLOCAL 0 ; a
7
[3]
ADDI 100
a=a+100
8
[3]
SETLOCAL 0 ; a
9
[4]
GETLOCAL 1 ; t
10 [4]
GETINDEXED 2 ; i a=t[i]
11 [4]
SETLOCAL 0 ; a
12 [4]
END
2010 2 24

44. Lua 4.0.1
main <0:@test.lua> (12 instructions/96 bytes at 0x100100650)
0 params, 5 stacks, 3 locals, 0 strings, 0 numbers, 0 functions, 5
lines
1
[1]
PUSHNIL 3 local a,t,i
2
[2]
GETLOCAL 0 ; a
3
[2]
GETLOCAL 2 ; i a=a+i
4
[2]
ADD
5
[2]
SETLOCAL 0 ; a
6
[3]
GETLOCAL 0 ; a
7
[3]
ADDI 100
a=a+100
8
[3]
SETLOCAL 0 ; a
9
[4]
GETLOCAL 1 ; t
10 [4]
GETINDEXED 2 ; i a=t[i]
11 [4]
SETLOCAL 0 ; a
12 [4]
END
YO!
ADD ADDI
……
2010 2 24

45. Lua 5.1.4
main <test.lua:0,0> (4 instructions, 16 bytes at 0x100101050)
0+ params, 3 slots, 0 upvalues, 3 locals, 1 constant, 0 functions
1 [2] ADD 0 0 2
2 [3] ADD 0 0 -1 ; - 100
3 [4] GETTABLE 0 1 2
4 [4] RETURN 0 1
2010 2 24

46. Lua 5.1.4
main <test.lua:0,0> (4 instructions, 16 bytes at 0x100101050)
0+ params, 3 slots, 0 upvalues, 3 locals, 1 constant, 0 functions
1 [2] ADD 0 0 2 a=a+i
2 [3] ADD 0 0 -1 ; - 100
3 [4] GETTABLE 0 1 2
4 [4] RETURN 0 1
2010 2 24

47. Lua 5.1.4
main <test.lua:0,0> (4 instructions, 16 bytes at 0x100101050)
0+ params, 3 slots, 0 upvalues, 3 locals, 1 constant, 0 functions
1 [2] ADD 0 0 2 a=a+i
2 [3] ADD 0 0 -1 ; - 100 a=a+100
3 [4] GETTABLE 0 1 2
4 [4] RETURN 0 1
2010 2 24

48. Lua 5.1.4
main <test.lua:0,0> (4 instructions, 16 bytes at 0x100101050)
0+ params, 3 slots, 0 upvalues, 3 locals, 1 constant, 0 functions
1 [2] ADD 0 0 2 a=a+i
2 [3] ADD 0 0 -1 ; - 100 a=a+100
3 [4] GETTABLE 0 1 2 a=t[i]
4 [4] RETURN 0 1
2010 2 24

49. Lua 5.1.4
main <test.lua:0,0> (4 instructions, 16 bytes at 0x100101050)
0+ params, 3 slots, 0 upvalues, 3 locals, 1 constant, 0 functions
1 [2] ADD 0 0 2 a=a+i
2 [3] ADD 0 0 -1 ; - 100 a=a+100
3 [4] GETTABLE 0 1 2 a=t[i]
4 [4] RETURN 0 1
local a,t,i ……
2010 2 24

50. 2010 2 24

51. Lua :-p
……
2010 2 24

52. Lua
Lua 12byte tag+
union
2010 2 24

53. ual machine with the new optimization for arrays can reduce the runnin
up to 40%.
The complete code of Lua 5.0 is available for browsing at Lua’s web site
p://www.lua.org/source/5.0/.
program Lua 4.0 Lua 5’ Lua 5.0
sum (2e7) 1.23 0.54 (44%) 0.54 (44%)
fibo (30) 0.95 0.68 (72%) 0.69 (73%)
ack (8) 1.00 0.86 (86%) 0.88 (88%)
random (1e6) 1.04 0.96 (92%) 0.96 (92%)
sieve (100) 0.93 0.82 (88%) 0.57 (61%)
heapsort (5e4) 1.08 1.05 (97%) 0.70 (65%)
matrix (50) 0.84 0.82 (98%) 0.59 (70%)
re 10: Benchmarks (times in seconds; percentages are relative to Lua 4.0)
Lua
2010 2 24

54. L u a V M
2010 2 24

55. Lua
Lua
Lua
local
2010 2 24

56. Lua
2010 2 24

57. LuaVM
Lua-Alchemy(Lua on Flash)
kahlua(Lua on Java[J2ME])
Yueliang(Lua on Lua)
LuaCLR(Lua on .NET)
Lua2js(Lua on JavaScript)
http://lua-users.org/wiki/
LuaImplementations
2010 2 24

58. The Implementation of Lua 5.0
The Evolution of Lua
A No-Frills Introduction to Lua 5.1 VM
Instructions
Lua lvm.c lopcodes.h
2010 2 24

59. Lua
Lua
2010 2 24

60. Lua
C
Lua JIT
C
VM
2010 2 24

61. 2010 2 24