由于lua的编译速度相当快,而且这种迭代编译的过程仅仅在程序加载的时候进行一次,故而可以带来性能的提高;一些在系统初始化可以决定的参数(比如从配置文件中读出来的数据直接编译为常量置入程序中。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
local select = select
local setmetatable = setmetatable
local getfenv = getfenv
local setfenc = setfenv
local loadstring = loadstring
local type = type
local tostring = tostring
local next = next
local unpack = unpack
local assert = assert
local string = string
local table = table
local io = io

local function (...)
return select("#", ...), select(1, ...)
end

Lua的upvalue和闭包

Lua函数可以被当成参数传递,也可以被当成结果返回,在函数体中仍然可以定义内嵌函数,Lua闭包是Lua函数生成的数据对象。每个闭包可以有一个upvalue值,或者多个闭包共享一个upvalue值。

什么是JIT

JIT=Just In Time即时编译,是动态编译的一种形式,是一种优化虚拟机运行的技术。
程序运行通常有两种方式,一种是静态编译,一种是动态编译,即使编译混合了这二者。Java和.Net/mono中都使用了这种技术。
然而IOS中禁止使用(不是针对JIT,而是所有的动态编译都不支持)

为什么要使用JIT

解释执行:

  • 效率低
  • 代码暴露

静态编译:

  • 不够灵活,无法热更新
  • 平台兼容性差。

JIT:

  • 效率:高于解释执行,低于静态编译。
  • 安全性:一般都会先转换成字节码。
  • 热更新:无论源码还是字节码本质都是资源文件。
  • 兼容性:虚拟机会处理平台差异,对用户透明。

JIT是如何实现的

这里讲的实际上是JIT的一个变种:自适应动态编译(adaptive dynamic compilation)。它分为两种:Method JIT和Trace JIT。
简单来讲:

  1. 跟踪热点函数或trace,编译成机器码执行,并缓存起来供以后使用。
  2. 非热点函数解释执行。

为什么只编译热点函数?
对只执行一次的代码而言,解释执行其实总是比JIT编译要快。对这些代码做JIT编译在执行,可以说是得补偿式。而对于只执行少量次数的代码,JIT编译带来的执行速度的提升也未必必能抵消掉最初编译带来的开销。只有对频繁执行的代码,JIT编译才能保证有正面的收益。

Lua元素(Metatable)

1.定义算术操作符和关系操作符的行为

+ __add
* __mul
- __sub
/ __div
- __unm(for negation) 自减
% __mod
^ __pow

关系操作符

== __eq
<  __lt
<= __le

当我们访问某个不存在的字段的时候,就会调用__index元方法。

源文件划分

1.虚拟机运转核心功能
|源文件名 |功能 |前缀|
|———————:|———————————————:|—-:|
|lapi.c |C语言接口 |luaC|
|lctype.c |C标准库中ctype相关实现 ||
|ldebug.c |Debug 接口 ||
|ldo.c |函数调用以及栈管理 |luaD|
|lfunc.c |函数原型及闭包管理 ||
|lgc.c |垃圾回收 ||
|lmem.c |内存管理接口 ||
|lobject.c |对象操作的一些函数 ||
|lopcodes.c |虚拟机的字节码定义 ||
|lstate.c |全局状态机 ||
|lstring.c |字符串池 ||
|ltable.c |表类型的相关操作 |luaH|
|ltm.c |元方法 ||
|lvm.c |虚拟机 ||
|lzio.c |输入流接口 |luaZ|

2.源代码解析以及预编译字节码
|源文件名 |功能 |前缀|
|———————:|———————————————:|—-:|
|lcode.c |代码生成器||
|ldump.c |序列化预编译的Lua字节码||
|llex.c |词法分析器||
|lparser.c |解析器||
|lundump.c |还原预编译的字节码||

3.内嵌库
|源文件名 |功能 |前缀|
|———————:|———————————————:|—-:|
|lauxlib.c |库编写用到的辅助函数库||
|lbaselib.c |基础库||
|lbitlib.c |位操作库||
|ldblib.c |Debug库||
|lini.c | 内嵌库的初始化||
|liolib.c |IO库||
|lstrlib.c |字符串库||
|ltablib.c |表处理库||

4.可执行的解析器,字节码编译器
|源文件名 |功能 |前缀|
|———————:|———————————————:|—-:|
|lua.c |解释器||
|luac.c |字节码编译器||

Lua核心

Lua核心部分仅包括Lua虚拟机的运转。Lua虚拟机的行为是由一组组opcode控制的。这些opcode定义在lopcodes.h及lopcodes.c中。而虚拟机对opcode的解析和运作在lvm.c中,其API以luaV为前缀。
Lua虚拟机的外在数据形式是一个lua_State结构体,取名State大概意为Lua虚拟机的当前状态。全局State引用了整个虚拟机的所有数据。这个全局State的相关代码放在lstate.c中,API使用luaE为前缀。
函数的运行流程:函数调用及返回则放在ldo.c中,相关API以luaD为前缀。
Lua中最复杂和重要的三种数据类型function、table、string的实现分属在lfunc.c、ltable.c、lstring.c中。这三组内部API分别以luaF、luaH、luaS为前缀命名。不同的数据类型最终呗统一定义为LuaObject,相关操作在lobject.c中,API以luaO为前缀。
Lua从第五版后增加了元表,元表的处理在ltm.c中,API以luaT为前缀。
另外,核心系统还用到两个基础设施:内存管理lmem.c,API以luaM为前缀;带缓存的流处理lzio.c,API以luaZ为前缀。
最后是核心系统里最为复杂的部分,垃圾回收部分,在lgc.c中实现,API以luaC为前缀。
Lua设计的初衷之一就为了最好的和宿主系统相结合。它是一门嵌入式语言,所以必须提供和宿主系统交互API。这些API以C函数的形式提供,大多数实现在lapi.c中。API直接以lua为前缀,可供C编写的程序库直接调用。

代码翻译及预编译字节码

光有核心代码和一个虚拟机还无法让Lua程序运行起来。因为必须从外部输入将Lua运行起来。Lua的脚本需要经过解析得到内部的数据结构(常量和opcode的集合)。这个是用parser:lparser.c (luaY:语法解析)及词法分析llex.c(luaX)
解析完脚本代码,还需要最终生成code码,在lcode.c中实现。luaK
为了满足某些需求,加快代码翻译的流程。还可以采用预编译的过程。把运行时编译的结果,生成为字节码。这个过程以及逆过程由ldump.c和lundump.c实现。luaU

内嵌库

作为嵌入式语言,其实完全可以不提供任何库及函数。全部由宿主系统注入到State中即可。也的确有许多系统是这么用的。但Lua的官方版本还是提供了少量必要的库。尤其是一些基础函数paris、error、setmetatable、type等等,完成了语言的一些基本特性,几乎很难不使用。
而coroutine、string、table、math等等库,也很常用。Lua提供了一套简洁的方案,允许你自由加载你需要的部分,以控制最终执行文件的体积和内存的占用量。主动加载这些内建库进入lua_State,是由在lualib.h中的API实现的。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
static TValue *index2addr (lua_State *L, int idx) {
CallInfo *ci = L->ci;
if (idx > 0) {
TValue *o = ci->func + idx;
api_check(L, idx <= ci->top - (ci->func + 1), "unacceptable index");
if (o >= L->top) return NONVALIDVALUE;
else return o;
}
else if (!ispseudo(idx)) { /* nagative index */
api_check(L, idx != 0 && -idx <= L->top - (ci->func + 1), "invalid index");
return L->top + idx;
}
...
}
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
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
public class LuaMgr
{
public static Module GetModule(string name)
{
Module m = m_modules.PG_TryGetValue(name);
if (m == null)
{
...
}
// repeat
if (m.m_state != Module.State.None)
{
if (m.m_state == Module.State.Failed) return null;
return m;
}

var L = m_L;//lua_State
string[] names = name.Split(m_dotSep); // mulit file
LuaDLL.lua_pushvalue(L, LuaIndexes.LUA_GLOBALSINDEX); // 0
for (int i = 0; i < names.Length; ++ i)
{
LuaDLL.lua_pushstring(L, names[i]);
LuaDLL.lua_rawget(L, -2); //

var t = LuaDLL.lua_type(L, -1); // 1
switch (t)
{
case LuaTypes.LUA_TNIL:
LuaDLL.lua_pop(L, 1);

luaDLL.lua_newtable(L);
luaDLL.lua_pushstring(L, names[i]);
luaDLL.lua_pushvalue(L, -2);
LuaDLL.lua_rawset(L, -4); // _G.name = module

LuaDLL.lua_rawgeti(L, LuaIndexes.LUA_REGISTRYINDEX, m_ref_globalMeta);
LuaDLL.lua_setmetatable(L, -2);
LuaDLL.lua_pushvalue(L, -1);
LuaDLL.lua_setfield(L, -2, "_M"); // module._M = module
break;
case LuaTypes.LUA_TTABLE:
break;
default:
m.m_state = Module.State.Failed;
LuaDLL.lua_pop(L, 2);
return null;
}

LuaDLL.lua_remove(L, -2);
}

m.m_index = ++m_moduleIndex;
m.m_ref_module = LuaDLL.luaL_ref(L, luaIndexes.LUA_REGISTRYINDEX);
ReloadModule(m);
return m;
}
}
public static int LoadModule()
{
var L = LuaMgr.m_L;
string name = LuaDLL.lua_tosting(L, 1);
var m = LuaMgr.GetModule(name);
LuaDLL.lua_pushboolean(L, m != null);
return 1;
}

阅读源代码的次序

首先、阅读外围的库是如何实现功能扩展的,这样可以熟悉Lua公开API,不必陷入功能细节。
然后、阅读API的具体实现。Lua对外暴露的API可以说是一个对内部模块的一层封装,这个层次尚未触及核心,但可以对核心代码有个初步的了解。
之后、可以开始了解Lua VM的实现。
接下来就是分别理解函数调用、返回,string,table,metatable等如何实现。
debug模块是一个额外的设施,但可以帮助你理解Lua内部细节。
最后是parser等编译相关的部分。
垃圾回收是最难的部分,可能会花掉最多的时间去理解细节。

Lua模块与包

模块类似于一个封装库,从Lua5.1开始,Lua加入了标准的模块管理机制,可以把一些公用的代码放在一个文件里,以API接口的形式在其他地方调用,有利于代码的重用和降低代码耦合度。
Lua的模块是由变量、函数等已知元素组成的table,因此创建一个模块很简单,就是创建一个table,然后把需要导出的常量、函数放入其中,最后返回这个table就行。以下为创建自定义模块module.lua,文件代码格式如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
-- 文件名module.lua
-- 定义一个名为module的模块
module = {}
-- 定义一个常量
module.constant = "这是一个常量"
-- 定义一个函数
function module.func1()
io.write("这是一个公有函数!n")
end

local function func2()
print("这是一个私有函数!")
end
function module.func3()
func2()
end
return module

由上可知,模块的结构就是一个table的结构,因此可以像操作table里的元素那样来操作调用模块里的常量或函数。
上面的func声明为程序块的局部变量,即表示一个私有函数,因此是不能从外部访问模块里的这个私有函数,必须通过模块的公有函数来调用。

require 函数

Lua提供了一个名为require的函数用来加载模块。要加载一个模块,只需要简单地调用就可以了。例如:

require("<模块名>")

或者

require "<模块名>"

执行require后会返回一个由模块常量或函数组成的table,并且还会定义一个包含该table的全局变量。

加载机制

对于自定义的模块,模块文件不是放在哪个目录都行,函数require有它自己的文件路劲加载策略,它会尝试从Lua文件或C程序库中加载模块。
require用于搜索Lua文件的路径是存放在全局变量package.path中,当Lua启动后,会以环境变量LUA_PATH的值来初始这个环境变量。如果没有找到该环境变量,则使用一个编译时定义的默认路径来初始化。
当前目录也会加载