0
LuaVM
                1 2       L u a V M




2010   2   24
blog:
                         hatena: Isoparametric
                         twitter: isoparametric
                     ...
Lua?


                Lua




                 LL    ANSI C

2010   2   24
LuaVM
                                      Lua

                Lua C
                          if    for
               ...
Lua

                      VM   VM




2010   2   24
I think that one cannot completely grok a
                scripting language, or any complex system for
                th...
LuaVM
                          VM(5.0   )




                Windows




2010   2   24
LuaVM




2010   2   24
VM              CPU
                        ……CPU
                        ……



                       ……




            ...
VM              CPU
                        ……CPU
                        ……



                       ……




            ...
/*----------------------------------------------------------------------

   38           (5.1.4     )   name	 	      args...
/*----------------------------------------------------------------------

   38           (5.1.4     )   name	 	      args...
MOVE

                 LOADK

                LOADBOOL

                 LOADNIL    nil

                GETUPVAL

       ...
NEWTABLE

                  SELF

                  ADD

                  SUB

                  MUL

                  D...
LEN

                CONCAT

                  JMP

                  EQ

                   LT

                  LE

   ...
RETURN

                FORLOOP    for         FORPREP

                FORPREP          for

                TFORLOOP    ...
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                          Bx
                             OP             A                          sBx

 ...
OP             A                          Bx
                             OP             A                          sBx

 ...
256
                        B/C 9bit==1bit

                Lua


                18bit               (131071   )
2010   2...
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   ...
Lua
                                                   1.0   1.1   2.1   2.2   2.4   2.5   3.0    3.1   3.2   4.0   5.0   ...
Lua
                                                   1.0   1.1   2.1   2.2   2.4   2.5   3.0    3.1   3.2   4.0   5.0   ...
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 ...
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]



             ...
local a,t,i
                a=a+i
                a=a+100                                                   YO

          ...
Lua 4.0.1

main <0:@test.lua> (12 instructions/96 bytes at 0x100100650)
0 params, 5 stacks, 3 locals, 0 strings, 0 numbers...
Lua 4.0.1

main <0:@test.lua> (12 instructions/96 bytes at 0x100100650)
0 params, 5 stacks, 3 locals, 0 strings, 0 numbers...
Lua 4.0.1

main <0:@test.lua> (12 instructions/96 bytes at 0x100100650)
0 params, 5 stacks, 3 locals, 0 strings, 0 numbers...
Lua 4.0.1

main <0:@test.lua> (12 instructions/96 bytes at 0x100100650)
0 params, 5 stacks, 3 locals, 0 strings, 0 numbers...
Lua 4.0.1

main <0:@test.lua> (12 instructions/96 bytes at 0x100100650)
0 params, 5 stacks, 3 locals, 0 strings, 0 numbers...
Lua 4.0.1

main <0:@test.lua> (12 instructions/96 bytes at 0x100100650)
0 params, 5 stacks, 3 locals, 0 strings, 0 numbers...
Lua 5.1.4

  main <test.lua:0,0> (4 instructions, 16 bytes at 0x100101050)
  0+ params, 3 slots, 0 upvalues, 3 locals, 1 c...
Lua 5.1.4

  main <test.lua:0,0> (4 instructions, 16 bytes at 0x100101050)
  0+ params, 3 slots, 0 upvalues, 3 locals, 1 c...
Lua 5.1.4

  main <test.lua:0,0> (4 instructions, 16 bytes at 0x100101050)
  0+ params, 3 slots, 0 upvalues, 3 locals, 1 c...
Lua 5.1.4

  main <test.lua:0,0> (4 instructions, 16 bytes at 0x100101050)
  0+ params, 3 slots, 0 upvalues, 3 locals, 1 c...
Lua 5.1.4

  main <test.lua:0,0> (4 instructions, 16 bytes at 0x100101050)
  0+ params, 3 slots, 0 upvalues, 3 locals, 1 c...
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 availab...
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 o...
The Implementation of Lua 5.0

                The Evolution of Lua

                A No-Frills Introduction to Lua 5.1 V...
Lua




                Lua




2010   2   24
Lua
                              C



                Lua     JIT
                                  C



                ...
2010   2   24
Upcoming SlideShare
Loading in...5
×

12 分くらいで知るLuaVM

4,125

Published on

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

Published in: Technology
0 Comments
8 Likes
Statistics
Notes
  • Be the first to comment

No Downloads
Views
Total Views
4,125
On Slideshare
0
From Embeds
0
Number of Embeds
3
Actions
Shares
0
Downloads
49
Comments
0
Likes
8
Embeds 0
No embeds

No notes for slide

Transcript of "12 分くらいで知るLuaVM"

  1. 1. LuaVM 1 2 L u a V M 2010 2 24
  2. 2. blog: hatena: Isoparametric twitter: isoparametric name: (http://d.hatena.ne.jp/Isoparametric/) 2010 2 24
  3. 3. Lua? Lua LL ANSI C 2010 2 24
  4. 4. LuaVM Lua Lua C if for Lua Lua VM 2010 2 24
  5. 5. Lua VM VM 2010 2 24
  6. 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. 7. LuaVM VM(5.0 ) Windows 2010 2 24
  8. 8. LuaVM 2010 2 24
  9. 9. VM CPU ……CPU …… …… PC…… 2010 2 24
  10. 10. VM CPU ……CPU …… …… PC…… 2010 2 24
  11. 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. 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. 13. MOVE LOADK LOADBOOL LOADNIL nil GETUPVAL GETGLOBAL GETTABLE SETGLOBAL SETUPVAL SETTABLE 2010 2 24
  14. 14. NEWTABLE SELF ADD SUB MUL DIV MOD POW UNM NOT 2010 2 24
  15. 15. LEN CONCAT JMP EQ LT LE TEST TESTSET CALL TAILCALL 2010 2 24
  16. 16. RETURN FORLOOP for FORPREP FORPREP for TFORLOOP for SETLIST CLOSE CLOSURE VARARG 2010 2 24
  17. 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. 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. 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. 20. 256 B/C 9bit==1bit Lua 18bit (131071 ) 2010 2 24
  21. 21. VM Lua VM lua -l 2010 2 24
  22. 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. 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. 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. 25. VM V S V M 2010 2 24
  26. 26. VM VM push VM VM 2010 2 24
  27. 27. VM Lua VM Lua local push/pop 2010 2 24
  28. 28. LuaVM Lua 2010 2 24
  29. 29. == == 2010 2 24
  30. 30. == == Lua VM …… VM 2010 2 24
  31. 31. 2010 2 24
  32. 32. LuaVM 4byte Lua 1byte 2byte 2010 2 24
  33. 33. ADD ADD ADD ADD + 2010 2 24
  34. 34. JavaVM goto 2byte) 2byte 2010 2 24
  35. 35. Lua 4byte Lua 1 or 2byte 2010 2 24
  36. 36. local a,t,i a=a+i a=a+100 YO a=t[i] 2010 2 24
  37. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 50. 2010 2 24
  51. 51. Lua :-p …… 2010 2 24
  52. 52. Lua Lua 12byte tag+ union 2010 2 24
  53. 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. 54. L u a V M 2010 2 24
  55. 55. Lua Lua Lua local 2010 2 24
  56. 56. Lua 2010 2 24
  57. 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. 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. 59. Lua Lua 2010 2 24
  60. 60. Lua C Lua JIT C VM 2010 2 24
  61. 61. 2010 2 24
  1. A particular slide catching your eye?

    Clipping is a handy way to collect important slides you want to go back to later.

×