这次紧接着上次的,将gc类型的数据分析完毕。
谢谢
老朱同学的指正,这里CClosure和LClosure理解有误.
先来看闭包:
可以看到闭包也是会有两种类型,这是因为在lua中,函数不过是一种特殊的闭包而已。
更新:这里CClosure表示是c函数,也就是和lua外部交互传递进来的c函数以及内部所使用的c函数.
LClosure表示lua的函数,这些函数是由lua虚拟机进行管理的..
typedef union Closure {
CClosure c;
LClosure l;
} Closure;
接下来来看这个两个结构。
在看着两个结构之前,先来看宏ClosureHeader,这个也就是每个闭包(函数的头).它包括了一些全局的东西:
更新 :
isC:如果是c函数这个值为1,为lua的函数则为0.
nupvalues:表示upvalue或者upvals的大小(闭包和函数里面的)。
gclist:链接到全局的gc链表。
env:环境,可以看到它是一个table类型的,他里面保存了一些全局变量等。
#define ClosureHeader \
CommonHeader; lu_byte isC; lu_byte nupvalues; GCObject *gclist; \
struct Table *env
ok接下来先来看 CClosure的实现.他很简单,就是保存了一个函数原型,以及一个参数列表
更新:
lua_CFunction f: 这个表示所要执行的c函数的原型.
TValue upvalue[1]:这个表示函数运行所需要的一些参数(比如string 的match函数,它所需要的几个参数都会保存在upvalue里面
typedef struct CClosure {
ClosureHeader;
lua_CFunction f;
TValue upvalue[1];
} CClosure;
更新:
这里我们只简要的介绍CClosure ,主要精力我们还是放在LClosure上.我来简要介绍下CClosure 的操作.一般当我们将CClosure 压栈,然后还有一些对应的调用函数f所需要的一些参数,此时我们会将参数都放到upvalue中,然后栈中只保存cclosure本身,这样当我们调用函数的时候(有一个全局的指针指向当前的调用函数),能够直接得到所需参数,然后调用函数.
LUA_API void lua_pushcclosure (lua_State *L, lua_CFunction fn, int n) {
Closure *cl;
lua_lock(L);
luaC_checkGC(L);
api_checknelems(L, n);
///new一个cclosure
cl = luaF_newCclosure(L, n, getcurrenv(L));
cl->c.f = fn;
L->top -= n;
///开始将参数值放到upvalue中.
while (n--)
setobj2n(L, &cl->c.upvalue[n], L->top+n);
setclvalue(L, L->top, cl);
lua_assert(iswhite(obj2gco(cl)));
api_incr_top(L);
lua_unlock(L);
}
然后来看LClosure 的实现。
在lua中闭包和函数是原型是一样的,只不过函数的upvalue为空罢了,而闭包upvalue包含了它所需要的局部变量值.
这里我们要知道在lua中闭包的实现。Lua 用一种称为upvalue 的结构来实现闭包。对任何外层局部变量的存取间接地通过upvalue来进行,也就是说当函数创建的时候会有一个局部变量表upvals(下面会介绍到).然后当闭包创建完毕,它就会复制upvals的值到upvalue。详细的描述可以看the implementation of lua 5.0(云风的blog上有提供下载).
struct Proto *p:这个指针包含了很多的属性,比如变量,比如嵌套函数等等。
UpVal *upvals[1]:这个数组保存了指向外部的变量也就是我们闭包所需要的局部变量。
下面会详细分析这个东西。
typedef struct LClosure {
ClosureHeader;
struct Proto *p;
UpVal *upvals[1];
} LClosure;
这里我摘录一段the implementation of lua 5.0里面的描述:
引用
通过为每个变量至少创建一个upvalue 并按所需情况进行重复利用,保证了未决状态(是否超过生存期)的局部变量(pending vars)能够在闭包间正确地
共享。为了保证这种唯一性,Lua 为整个运行栈保存了一个链接着所有正打开着
的upvalue(那些当前正指向栈内局部变量的upvalue)的链表(图4 中未决状态
的局部变量的链表)。当Lua 创建一个新的闭包时,它开始遍历所有的外层局部
变量,对于其中的每一个,若在上述upvalue 链表中找到它,就重用此upvalue,
否则,Lua 将创建一个新的upvalue 并加入链表中。注意,一般情况下这种遍历
过程在探查了少数几个节点后就结束了,因为对于每个被内层函数用到的外层局
部变量来说,该链表至少包含一个与其对应的入口(upvalue)。一旦某个关闭的
upvalue 不再被任何闭包所引用,那么它的存储空间就立刻被回收。
下面是示意图:
这里的未决状态(是否超过生存期)的局部变量指的就是我们下面的UpVal,其中:
TValue *v:指向栈内的自己的位置或者自己(这里根据是否这个uvalue被关闭)。
union u:这里可以看到如果是被关闭则直接保存value。如果打开则为一个链表。
typedef struct UpVal {
CommonHeader;
TValue *v; /* points to stack or to its own value */
union {
TValue value; /* the value (when closed) */
struct { /* double linked list (when open) */
struct UpVal *prev;
struct UpVal *next;
} l;
} u;
} UpVal;
然后来看luaF_newLclosure的实现,它与cclosure类似。
Closure *luaF_newLclosure (lua_State *L, int nelems, Table *e) {
Closure *c = cast(Closure *, luaM_malloc(L, sizeLclosure(nelems)));
luaC_link(L, obj2gco(c), LUA_TFUNCTION);
c->l.isC = 0;
c->l.env = e;
///更新upvals。
c->l.nupvalues = cast_byte(nelems);
while (nelems--) c->l.upvals[nelems] = NULL;
return c;
}
ok,接下来我们就通过一些函数来更详细的理解闭包的实现。
先分析CClosure。我们来看luaF_newCclosure的实现,这个函数创建一个CClosure,也就是创建一个所需要执行的c函数.
这个函数实现比较简单,就是malloc一个Closure,然后链接到全局gc,最后初始化Closure 。
Closure *luaF_newCclosure (lua_State *L, int nelems, Table *e) {
///分配内存
Closure *c = cast(Closure *, luaM_malloc(L, sizeCclosure(nelems)));
///链接到全局的gc链表
luaC_link(L, obj2gco(c), LUA_TFUNCTION);
///开始初始化。
c->c.isC = 1;
c->c.env = e;
c->c.nupvalues = cast_byte(nelems);
return c;
}
在lua_State中它里面包含有GCObject 类型的域叫openupval,这个域也就是当前的栈上的所有open的uvalue。可以看到这里是gcobject类型的,这里我们就知道为什么gcobvject中为什么还要包含struct UpVal uv了。而在global_State中的UpVal uvhead则是整个lua虚拟机里面所有栈的upvalue链表的头。
然后我们来看lua中如何new一个upval。
它很简单就是malloc一个UpVal然后链接到gc链表里面。这边要注意,每次new的upval都是close的。
UpVal *luaF_newupval (lua_State *L) {
///new一个upval
UpVal *uv = luaM_new(L, UpVal);
///链接到全局的gc中
luaC_link(L, obj2gco(uv), LUA_TUPVAL);
///可以看到这里的upval是close的。
uv->v = &uv->u.value;
setnilvalue(uv->v);
return uv;
}
接下来我们来看闭包如何来查找到对应的upval,所有的实现就在函数luaF_findupval中。我们接下来来看这个函数的实现。
这个函数的流程是这样的。
1 首先遍历lua_state的openupval,也就是当前栈的upval,然后如果能找到对应的值,则直接返回这个upval。
2 否则新建一个upval(这里注意new的是open的),然后链接到openupval以及uvhead中。而且每次新的upval的插入都是插入到链表头的。而且这里插入了两次。这里为什么要有两个链表,那是因为有可能会有多个栈,而uvhead就是用来管理多个栈的upvalue的(也就是多个openupval)。
UpVal *luaF_findupval (lua_State *L, StkId level) {
global_State *g = G(L);
///得到openupval链表
GCObject **pp = &L->openupval;
UpVal *p;
UpVal *uv;
///开始遍历open upvalue。
while (*pp != NULL && (p = ngcotouv(*pp))->v >= level) {
lua_assert(p->v != &p->u.value);
///发现已存在。
if (p->v == level) {
if (isdead(g, obj2gco(p))) /* is it dead? */
changewhite(obj2gco(p)); /* ressurect it */
///直接返回
return p;
}
pp = &p->next;
}
///否则new一个新的upvalue
uv = luaM_new(L, UpVal); /* not found: create a new one */
uv->tt = LUA_TUPVAL;
uv->marked = luaC_white(g);
///设置值
uv->v = level; /* current value lives in the stack */
///首先插入到lua_state的openupval域
uv->next = *pp; /* chain it in the proper position */
*pp = obj2gco(uv);
///然后插入到global_State的uvhead(这个也就是双向链表的头)
uv->u.l.prev = &g->uvhead; /* double link it in `uvhead' list */
uv->u.l.next = g->uvhead.u.l.next;
uv->u.l.next->u.l.prev = uv;
g->uvhead.u.l.next = uv;
lua_assert(uv->u.l.next->u.l.prev == uv && uv->u.l.prev->u.l.next == uv);
return uv;
}
更新:
上面可以看到我们new的upvalue是open的,那么什么时候我们关闭这个upvalue呢,当函数关闭的时候,我们就会unlink掉upvalue,从全局的open upvalue表中:
void luaF_close (lua_State *L, StkId level) {
UpVal *uv;
global_State *g = G(L);
///开始遍历open upvalue
while (L->openupval != NULL && (uv = ngcotouv(L->openupval))->v >= level) {
GCObject *o = obj2gco(uv);
lua_assert(!isblack(o) && uv->v != &uv->u.value);
L->openupval = uv->next; /* remove from `open' list */
if (isdead(g, o))
luaF_freeupval(L, uv); /* free upvalue */
else {
///unlink掉当前的uv.
unlinkupval(uv);
setobj(L, &uv->u.value, uv->v);
uv->v = &uv->u.value; /* now current value lives here */
luaC_linkupval(L, uv); /* link upvalue into `gcroot' list */
}
}
}
static void unlinkupval (UpVal *uv) {
lua_assert(uv->u.l.next->u.l.prev == uv && uv->u.l.prev->u.l.next == uv);
uv->u.l.next->u.l.prev = uv->u.l.prev; /* remove from `uvhead' list */
uv->u.l.prev->u.l.next = uv->u.l.next;
}
接下来来看user data。这里首先我们要知道,在lua中,创建一个userdata,其实也就是分配一块内存紧跟在Udata的后面。后面我们分析代码的时候就会看到。也就是说Udata相当于一个头。
typedef union Udata {
L_Umaxalign dummy;
struct {
///gc类型的都会包含这个头,前面已经描述过了。
CommonHeader;
///元标
struct Table *metatable;
///环境
struct Table *env;
///当前user data的大小。
size_t len;
} uv;
} Udata;
ok,接下来我们来看代码,我们知道调用lua_newuserdata能够根据指定大小分配一块内存,并将对应的userdata压入栈。
这里跳过了一些代码,跳过的代码以后会分析到。
LUA_API void *lua_newuserdata (lua_State *L, size_t size) {
Udata *u;
lua_lock(L);
luaC_checkGC(L);
///new一个新的user data,然后返回地址
u = luaS_newudata(L, size, getcurrenv(L));
///将u压入压到栈中。
setuvalue(L, L->top, u);
///更新栈顶指针
api_incr_top(L);
lua_unlock(L);
///返回u+1,也就是去掉头(Udata)然后返回。
return u + 1;
}
我们可以看到具体的实现都包含在luaS_newudata中,这个函数也满简单的,malloc一个size+sizeof(Udata)的内存,然后初始化udata。
我们还要知道在全局状态,也就是global_State中包含一个struct lua_State *mainthread,这个主要是用来管理userdata的。它也就是表示当前的栈,因此下面我们会将新建的udata链接到它上面。
Udata *luaS_newudata (lua_State *L, size_t s, Table *e) {
Udata *u;
///首先检测size,userdata是由大小限制的。
if (s > MAX_SIZET - sizeof(Udata))
luaM_toobig(L);
///然后malloc一块内存。
u = cast(Udata *, luaM_malloc(L, s + sizeof(Udata)));
///这里gc相关的东西,以后分析gc时再说。
u->uv.marked = luaC_white(G(L)); /* is not finalized */
///设置类型
u->uv.tt = LUA_TUSERDATA;
///设置当前udata大小
u->uv.len = s;
u->uv.metatable = NULL;
u->uv.env = e;
/* chain it on udata list (after main thread) */
///然后链接到mainthread中
u->uv.next = G(L)->mainthread->next;
G(L)->mainthread->next = obj2gco(u);
///然后返回。
return u;
}
还剩下两个gc类型,一个是proto(函数包含的一些东西)一个是lua_State(也就是协程).
我们来简单看一下lua_state,顾名思义,它就代表了状态,一个lua栈(或者叫做线程也可以),每次c与lua交互都会新建一个lua_state,然后才能互相通过交互。可以看到在new state的时候它的tt就是LUA_TTHREAD。
并且每个协程也都有自己独立的栈。
我们就来看下我们前面已经触及到的一些lua-state的域:
struct lua_State {
CommonHeader;
///栈相关的
StkId top; /* first free slot in the stack */
StkId base; /* base of current function */
StkId stack_last; /* last free slot in the stack */
StkId stack; /* stack base */
///指向全局的状态。
global_State *l_G;
///函数相关的
CallInfo *ci; /* call info for current function */
const Instruction *savedpc; /* `savedpc' of current function */
CallInfo *end_ci; /* points after end of ci array*/
CallInfo *base_ci; /* array of CallInfo's */
lu_byte status;
///一些要用到的len,栈大小,c嵌套的数量,等。
int stacksize;
int size_ci; /* size of array `base_ci' */
unsigned short nCcalls; /* number of nested C calls */
unsigned short baseCcalls; /* nested C calls when resuming coroutine */
lu_byte hookmask;
lu_byte allowhook;
int basehookcount;
int hookcount;
lua_Hook hook;
///一些全局(这个状态)用到的东西,比如env等。
TValue l_gt; /* table of globals */
TValue env; /* temporary place for environments */
///gc相关的东西。
GCObject *openupval; /* list of open upvalues in this stack */
GCObject *gclist;
///错误处理相关。
struct lua_longjmp *errorJmp; /* current error recover point */
ptrdiff_t errfunc; /* current error handling function (stack index) */
};
而global_State主要就是包含了gc相关的东西。
现在基本类型的分析就告一段落了,等到后面分析parse以及gc的时候会再回到这些类型。
分享到:
相关推荐
Lua 源码剖析 —— 解析 Lua 源码的实现机制 Lua 是一款轻量级的脚本语言,广泛应用于游戏开发、软件开发等领域。 Lua 的源码剖析是学习 Lua 语言的必经之路。本文将对 Lua 源码的实现机制进行详细的解析,从 main...
【lua源码剖析】 Lua是一种轻量级的脚本语言,因其简洁、高效而被广泛应用于游戏开发、嵌入式系统以及服务器配置等场景。源码剖析有助于深入了解其内部机制和设计思想,这对于优化lua应用、扩展lua功能或进行跨语言...
《lua 源码剖析》是一本深入探讨lua编程语言...通过对lua源码的学习,开发者不仅能掌握lua语言的精髓,还能提升编程技巧,更好地利用lua解决实际问题。同时,源码阅读也能培养程序员的底层思维,增强系统级编程能力。
Lua源码剖析、Lua虚拟机的机制分析是硕士论文的主题,本文从Lua语言的特性入手,深入分析Lua虚拟机的实现,涵盖编译过程、线程执行、函数调用和垃圾回收过程。然后,本文将Lua虚拟机中的关键技术与Pyt hon虚拟机的...
《Lua 源码剖析》是由知名IT专家云风精心撰写的关于Lua编程语言源代码解析的著作。这本书深入浅出地探讨了Lua的核心机制,为开发者提供了深入了解和掌握Lua的宝贵资源。以下是对该书内容的详细概述: 1. **Lua简介*...
《Lua源码剖析:词法分析与语法解析》 Lua是一种轻量级的脚本语言,其源码设计精巧且高效。本文将深入探讨Lua的词法分析和语法解析过程,帮助读者理解其核心机制。 词法分析是编译器的第一步,它将输入的文本转换...
《Lua源码剖析》 Lua是一种轻量级的脚本语言,因其简洁高效而广泛应用于游戏开发、热更新等领域。本文将深入探讨Lua的核心数据结构和虚拟机机制,以帮助理解其内部工作原理。 首先,我们要关注的是Lua中的基本值...
《Lua源码剖析:VM解析》 Lua是一种轻量级的、高效的脚本语言,它的虚拟机(VM)是其核心部分,负责解释并执行字节码。在深入理解Lua虚拟机的工作机制时,我们首先关注的是luaV_execute函数,它是Lua VM执行的起点...
本文将深入解析Lua源码,探讨其核心数据结构和内存管理机制,以及如何与C语言交互。 首先,我们关注Lua中值的表示方式。在Lua中,所有值都由`TValue`结构体表示,它包含一个`Value`联合体和一个`tt`类型标记。`tt`...
### Lua源码剖析:深入理解Lua的内部机制 #### 引言 Lua,作为一种轻量级、高效且可嵌入的脚本语言,在游戏开发、Web应用、自动化脚本等领域有着广泛的应用。其源码的剖析不仅能够帮助我们更深入地理解Lua的工作...
本书《lua源码导读》旨在深入剖析 Lua 的源代码,帮助读者理解其内部实现原理。 #### 源文件划分 Lua 的源代码组织清晰有序,每个模块负责一部分功能,这种模块化的处理方式使得代码易于理解和维护。主要包括以下...
以下是对Lua源码分析的一些详细知识点。 Lua源码主要可以分为几个部分:虚拟机运转的核心功能、源文件划分、代码风格、Lua核心、代码翻译及预编译字节码、内嵌库、独立解析器及字节码编译器、阅读源代码的次序。...
本文将针对Lua 5.3.4版本的源码进行深度剖析,旨在帮助开发者更深入地理解其内部机制。 一、Lua语言特性 Lua 5.3.4在语言设计上延续了其一贯的精简风格,主要特性包括: 1. 动态类型:Lua的所有值都有类型,类型...
《深入剖析:Lua源码分析》 一、引言与背景 Lua,作为一种小巧而强大的脚本语言,凭借其高效性、灵活性以及易嵌入特性,在游戏开发、系统管理、Web应用等多个领域得到了广泛的应用。它由标准C语言编写而成,这不仅...
共八本: Lua程序设计(第二版);LUA脚本语言参考文档;Lua脚本语言中文教程;Lua性能优化技巧;Lua虚拟机指令集介绍;lua源码剖析;Lua源码赏析;使用notepad 运行python和lua的配置
本文将针对LUA-5.3.2的源码进行深入剖析,旨在帮助读者理解其内部机制,提升编程技巧。 首先,让我们从源码结构开始。`lua-5.3.2`目录下包含了所有源代码和头文件,这使得源码易于阅读和理解。主要的源文件有`lapi....
《深入理解Lua源码解析》 Lua是一种轻量级、高效、可扩展的脚本语言,广泛应用于游戏开发、嵌入式系统以及各种应用程序中。本文将从lua.c的main函数出发,逐步剖析Lua的源码,以帮助读者更好地理解和应用Lua。 1. ...
本文将深入探讨Armature的源码,特别是Flash数据与XML数据之间的关系。 首先,`<skeleton>`节点包含了关于整个骨骼动画的基本信息。`name`属性标识了Flash文件的名称,`frameRate`定义了动画的帧率,而`version`则...
本文将针对Lua 5.1.4版本的源代码进行深入剖析,特别关注C++开发者如何理解和利用这些源码。我们将从C++的角度出发,探讨Lua的内存管理、虚拟机设计、语法解析、运行机制以及与C++的交互等核心知识点。 1. **内存...
"CodeLearn_Lua"项目提供了对Lua源码的深度剖析,旨在帮助开发者更好地理解和掌握Lua的内部工作原理,从而提升编程能力,优化代码性能。 首先,让我们来看看"CodeLearn_Lua"项目的核心内容。源码分析通常包括以下几...