12 分くらいで知るLuaVM

LuaVM 1 2 L u a V M 2010 2 24

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

Lua? Lua LL ANSI C 2010 2 24

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

Lua VM VM 2010 2 24

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

LuaVM VM(5.0 ) Windows 2010 2 24

LuaVM 2010 2 24

VM CPU ……CPU …… …… PC…… 2010 2 24

/*---------------------------------------------------------------------- 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

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

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

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

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

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

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".)

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".)

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

VM Lua VM lua -l 2010 2 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

VM V S V M 2010 2 24

VM VM push VM VM 2010 2 24

VM Lua VM Lua local push/pop 2010 2 24

LuaVM Lua 2010 2 24

== == 2010 2 24

== == Lua VM …… VM 2010 2 24

2010 2 24

LuaVM 4byte Lua 1byte 2byte 2010 2 24

ADD ADD ADD ADD + 2010 2 24

JavaVM goto 2byte) 2byte 2010 2 24

Lua 4byte Lua 1 or 2byte 2010 2 24

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

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

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

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

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

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

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

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

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

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

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

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

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

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

2010 2 24

Lua :-p …… 2010 2 24

Lua Lua 12byte tag+ union 2010 2 24

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%) ﬁbo (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

L u a V M 2010 2 24

Lua Lua Lua local 2010 2 24

Lua 2010 2 24

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

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

Lua Lua 2010 2 24

Lua C Lua JIT C VM 2010 2 24

2010 2 24

http://d.hatena.ne.jp	501
http://www.slideshare.net	4
http://paper.li	4
http://localhost:9393	1
http://a0.twimg.com	1
http://b.hatena.ne.jp	1

12 分くらいで知るLuaVM

by Isoparametric ! on Feb 23, 2010

Accessibility

Categories

Tags

Upload Details

Usage Rights

6 Embeds 512

Statistics

12 分くらいで知るLuaVM — Presentation Transcript