关于Lua一点分析

2023-06-20 17:56•css•阅读 584

一.变量和值

Lua是一种动态类型语言。这意味着变量时没有类型的只有值有类型

在lua中的值类型一共有八类,number,bool,string,function,table,userdata,thread,nil.其中nil比较特殊,只有一个值就是nil.在lua中变量的"类型"是可以转换的.对于可垃圾回收的gc对象,采用的是都是引用指向的方式,不存在写时拷贝的问题.指向相同数据对象的变量会存在写入覆盖的问题.

GC不回收的有number,bool,和lightuserdata,这些类型都不引起额外的内存分配.

lua中用于可回收值的头部

#define CommonHeader GCObject *next; lu_byte tt; lu_byte marked

** Common header in struct form

typedef struct GCheader {

CommonHeader;

} GCheader;

next指针用于连接gc链表 tt用于表示gc值的类型 marked用于lua的垃圾回收算法

lua中的值表示

typedef union {

GCObject *gc;

void *p;

lua_Number n;

int b;

} Value;

#define TValuefields Value value; int tt

typedef struct lua_TValue {

TValuefields;

} TValue;

所有的变量在c层面上都是TValue类型的具体的lua变量"类型"则取决于他所使用的Value域即取决它所指向的值类型 tt用来标示当前的lua变量"类型" 不同类型变量去使用不同域

n用于number类型 b用于boolean p用于lightuserdata(不能回收) 当使用其他各类型时则需要GCObject*指针指向对应的值

union GCObject {

GCheader gch;

union TString ts;

union Udata u;

union Closure cl;

struct Table h;

struct Proto p;

struct UpVal uv;

struct lua_State th; /* thread */

};

变量与值的关系

lua中的变量是没有类型的只有值有类型当变量表示number ,bool,lightuserdata等简单值的时候值类型就反应在Value上当变量指向其他类型的时候值类型反应在GCObject指针的指向上面也就是两个变量可以指向同一个GCObject对象这样的GCObject就只存在一份了换句话说就是变量都是对GC对象的一种引用

变量与值的产生

对于number,bool,lightuserdata这样的简单值来说变量与值是同时产生的而对于指向一个GC对象的变量来说首先应该创建这样的GC对象然后再将Value对象的GC指针指向这个GC对象对于一个普通变量的赋值来说 Value只用直接改写相应的域即可而对于一个GC对象两个变量会同时指向一个GCObject

字符串对象的产生

lua_pushstring 创建一个TString 并将lua栈顶的TValue指向这个TString

LUA_API void lua_pushlstring (lua_State *L, const char *s, size_t len) {

lua_lock(L);

luaC_checkGC(L);

setsvalue2s(L, L->top, luaS_newlstr(L, s, len));

api_incr_top(L);

lua_unlock(L);

}

TString *luaS_newlstr (lua_State *L, const char *str, size_t l) {

GCObject *o;

unsigned int h = cast(unsigned int, l); /* seed */

size_t step = (l>>5)+1; /* if string is too long, don't hash all its chars */

size_t l1;

for (l1=l; l1>=step; l1-=step) /* compute hash */

h = h ^ ((h<<5)+(h>>2)+cast(unsigned char, str[l1-1]));

//lua中所有的字符串变量都放在globalstate中的字符串表中所以先查找字符串是否已经存在了

for (o = G(L)->strt.hash[lmod(h, G(L)->strt.size)]; o != NULL; o = o->gch.next)

{

TString *ts = rawgco2ts(o);

if (ts->tsv.len == l && (memcmp(str, getstr(ts), l) == 0)) //字符串已经存在

{

if (isdead(G(L), o)) //是否已经死亡这一步的GC还没有执行GCSweepString 但是已经执行了GCSpropagate 所以才会变成死的也就是mark还是old white

changewhite(o); //将其复生重新将这个GCObject* 变成current white就可

return ts;

}

return newlstr(L, str, l, h); /* not found */

}

//没有找到字符串重新创建一个新的

static TString *newlstr (lua_State *L, const char *str, size_t l, unsigned int h)

{

TString *ts;

stringtable *tb;

if (l+1 > (MAX_SIZET - sizeof(TString))/sizeof(char))

luaM_toobig(L);

ts = cast(TString *, luaM_malloc(L, (l+1)*sizeof(char)+sizeof(TString)));

ts->tsv.len = l;

ts->tsv.hash = h;

ts->tsv.marked = luaC_white(G(L)); //这一步很关键标记白表示当前的字符串是活着的

ts->tsv.tt = LUA_TSTRING;

ts->tsv.reserved = 0;

//真正的字符串的内容是放在TString变量的后面的在TString+1的位置上

memcpy(ts+1, str, l*sizeof(char));

((char *)(ts+1))[l] = '\0'; /* ending 0 */

tb = &G(L)->strt;

h = lmod(h, tb->size);

ts->tsv.next = tb->hash[h]; /* chain new entry */

tb->hash[h] = obj2gco(ts); //将穿件出来的TString放入GlobalState的全局字符串表中

tb->nuse++;

if (tb->nuse > cast(lu_int32, tb->size) && tb->size <= MAX_INT/2)

luaS_resize(L, tb->size*2); /* too crowded */

return ts;

}

字符串的管理是与其他的GCObject分开的出于对字符串这种易重用资源的良好管理提高重用性吗?????

Userdata的创建

LUA_API void *lua_newuserdata (lua_State *L, size_t size) {

Udata *u;

lua_lock(L);

luaC_checkGC(L); //如果满足GC运行的条件会做一下单步的GC Singlestep 但是只做一步不会完成GC全过程

u = luaS_newudata(L, size, getcurrenv(L));

setuvalue(L, L->top, u); //创建一个Userdata的GCObject 同时用栈顶的Value指向这个GCObject*

api_incr_top(L);

lua_unlock(L);

return u + 1;

}

Udata *luaS_newudata (lua_State *L, size_t s, Table *e)

{

Udata *u;

if (s > MAX_SIZET - sizeof(Udata))

luaM_toobig(L);

u = cast(Udata *, luaM_malloc(L, s + sizeof(Udata))); //和TString一样真正的用户数据是跟在Udata后面的

u->uv.marked = luaC_white(G(L)); /* is not finalized */ 标记白色

u->uv.tt = LUA_TUSERDATA;

u->uv.len = s;

u->uv.metatable = NULL;

u->uv.env = e;

/* chain it on udata list (after main thread) */

u->uv.next = G(L)->mainthread->next;

G(L)->mainthread->next = obj2gco(u);

return u;

}

Userdata 放在main LuaState的next中特殊??? Userdata的管理比较特殊 Userdata不用显示地使用LuaC_link链入GlobalState的rootgc 因为他被链入了mainthread的next中所以也就隐式的被连接入了

rootgc中了

Table创建

LUA_API void lua_createtable (lua_State *L, int narray, int nrec) {

lua_lock(L);

luaC_checkGC(L);

sethvalue(L, L->top, luaH_new(L, narray, nrec)); 将栈顶的value指向这个table

api_incr_top(L);

lua_unlock(L);

}

创建新表

Table *luaH_new (lua_State *L, int narray, int nhash) {

Table *t = luaM_new(L, Table);

luaC_link(L, obj2gco(t), LUA_TTABLE); //传入GC链表

t->metatable = NULL;

t->flags = cast_byte(~0);

/* temporary values (kept only if some malloc fails) */

t->array = NULL;

t->sizearray = 0;

t->lsizenode = 0;

t->node = cast(Node *, dummynode);

setarrayvector(L, t, narray);

setnodevector(L, t, nhash);

return t;

}

//将GCObject 串入GlobalState的rootgc中

void luaC_link (lua_State *L, GCObject *o, lu_byte tt) {

global_State *g = G(L);

o->gch.next = g->rootgc;

g->rootgc = o;

o->gch.marked = luaC_white(g);

o->gch.tt = tt;

}

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);

cl = luaF_newCclosure(L, n, getcurrenv(L));

cl->c.f = fn;

L->top -= n;

while (n--)

setobj2n(L, &cl->c.upvalue[n], L->top+n);

setclvalue(L, L->top, cl); //将栈顶的Value指向Closure

lua_assert(iswhite(obj2gco(cl)));

api_incr_top(L);

lua_unlock(L);

}

//新建一个CClosure C闭包

Closure *luaF_newCclosure (lua_State *L, int nelems, Table *e)

{

Closure *c = cast(Closure *, luaM_malloc(L, sizeCclosure(nelems)));

luaC_link(L, obj2gco(c), LUA_TFUNCTION); //将c闭包串入gc root中

c->c.isC = 1;

c->c.env = e;

c->c.nupvalues = cast_byte(nelems);

return c;

}

新建一个lua 函数原型

Proto *luaF_newproto (lua_State *L)

{

Proto *f = luaM_new(L, Proto);

luaC_link(L, obj2gco(f), LUA_TPROTO); 将lua Proto函数原型连入rootgc中

f->k = NULL;

f->sizek = 0;

f->p = NULL;

f->sizep = 0;

f->code = NULL;

f->sizecode = 0;

f->sizelineinfo = 0;

f->sizeupvalues = 0;

f->nups = 0;

f->upvalues = NULL;

f->numparams = 0;

f->is_vararg = 0;

f->maxstacksize = 0;

f->lineinfo = NULL;

f->sizelocvars = 0;

f->locvars = NULL;

f->linedefined = 0;

f->lastlinedefined = 0;

f->source = NULL;

return f;

}

新建一个Function 的 Upval

UpVal *luaF_newupval (lua_State *L)

{

UpVal *uv = luaM_new(L, UpVal);

luaC_link(L, obj2gco(uv), LUA_TUPVAL); 将这个Upval链入到rootgc中

uv->v = &uv->u.value;

setnilvalue(uv->v);

return uv;

}

新建一个LuaState 这是mainLuaState

LUA_API lua_State *lua_newstate (lua_Alloc f, void *ud)

{

int i;

lua_State *L;

global_State *g;

void *l = (*f)(ud, NULL, 0, state_size(LG));

if (l == NULL)

return NULL;

L = tostate(l);

g = &((LG *)L)->g;

L->next = NULL;

L->tt = LUA_TTHREAD;

g->currentwhite = bit2mask(WHITE0BIT, FIXEDBIT);

L->marked = luaC_white(g); 标记为白色

set2bits(L->marked, FIXEDBIT, SFIXEDBIT);

preinit_state(L, g);

g->frealloc = f;

g->ud = ud;

g->mainthread = L;

g->uvhead.u.l.prev = &g->uvhead;

g->uvhead.u.l.next = &g->uvhead;

g->GCthreshold = 0; /* mark it as unfinished state */

g->strt.size = 0;

g->strt.nuse = 0;

g->strt.hash = NULL;

setnilvalue(registry(L));

luaZ_initbuffer(L, &g->buff);

g->panic = NULL;

g->gcstate = GCSpause;

g->rootgc = obj2gco(L); 由于是mainLuaState 所以就把rootgc直接指向LuaState

g->sweepstrgc = 0;

g->sweepgc = &g->rootgc;

g->gray = NULL;

g->grayagain = NULL;

g->weak = NULL;

g->tmudata = NULL;

g->totalbytes = sizeof(LG);

g->gcpause = LUAI_GCPAUSE;

g->gcstepmul = LUAI_GCMUL;

g->gcdept = 0;

for (i=0; i<NUM_TAGS; i++)

g->mt[i] = NULL;

if (luaD_rawrunprotected(L, f_luaopen, NULL) != 0)

{

/* memory allocation error: free partial state */

close_state(L);

L = NULL;

}

else

luai_userstateopen(L);

return L;

}

创建一个额外的LuaState 则需要

LUA_API lua_State *lua_newthread (lua_State *L)

{

lua_State *L1;

lua_lock(L);

luaC_checkGC(L);

L1 = luaE_newthread(L);

setthvalue(L, L->top, L1);

api_incr_top(L);

lua_unlock(L);

luai_userstatethread(L, L1);

return L1;

}

创建一个额外的LuaState

lua_State *luaE_newthread (lua_State *L)

{

lua_State *L1 = tostate(luaM_malloc(L, state_size(lua_State)));

luaC_link(L, obj2gco(L1), LUA_TTHREAD); 将其连入rootgc中

preinit_state(L1, G(L));

stack_init(L1, L); /* init stack */

setobj2n(L, gt(L1), gt(L)); /* share table of globals */

L1->hookmask = L->hookmask;

L1->basehookcount = L->basehookcount;

L1->hook = L->hook;

resethookcount(L1);

lua_assert(iswhite(obj2gco(L1)));

return L

}

到现在所有的GCObject中TString串入 GlobalState的全局字符串表 Udata连入luastate中的next 其余CClosure ,table,Lua proto,upvalue,luaState 都连入globalstate的rootgc中

值和变量的灭亡

luaGC 机制和过程

lua使用标记清除的算法来进行垃圾回收通过遍历可到达的对象并标记之后不可达的对象就可以删除了一般Lua的gc过程是不必直接调用的

LUA_API int lua_gc (lua_State *L, int what, int data) 可以用来控制gc

LUA_API int lua_gc (lua_State *L, int what, int data) {

int res = 0;

global_State *g;

lua_lock(L);

g = G(L);

switch (what)

{

case LUA_GCSTOP:

{

g->GCthreshold = MAX_LUMEM;

break;

}

case LUA_GCRESTART:

{

g->GCthreshold = g->totalbytes;

break;

}

case LUA_GCCOLLECT:

{

luaC_fullgc(L); 这里会把gc全部做一遍

break;

}

case LUA_GCCOUNT:

{

/* GC values are expressed in Kbytes: #bytes/2^10 */

res = cast_int(g->totalbytes >> 10);

break;

}

case LUA_GCCOUNTB:

{

res = cast_int(g->totalbytes & 0x3ff);

break;

}

case LUA_GCSTEP:

{ //这里会把gc往前推进一步

lu_mem a = (cast(lu_mem, data) << 10);

if (a <= g->totalbytes)

g->GCthreshold = g->totalbytes - a;

else

g->GCthreshold = 0;

while (g->GCthreshold <= g->totalbytes) {

luaC_step(L);

if (g->gcstate == GCSpause) { /* end of cycle? */

res = 1; /* signal it */

break;

}

break;

}

case LUA_GCSETPAUSE: {

res = g->gcpause;

g->gcpause = data;

break;

}

case LUA_GCSETSTEPMUL: {

res = g->gcstepmul;

g->gcstepmul = data;

break;

}

default: res = -1; /* invalid option */

}

lua_unlock(L);

return res;

}

隐式的gc过程都在这里

#define luaC_checkGC(L) { \

condhardstacktests(luaD_reallocstack(L, L->stacksize - EXTRA_STACK - 1)); \

if (G(L)->totalbytes >= G(L)->GCthreshold) \

luaC_step(L); } 检查如果分配内存过大 GC会向前执行一步

GC的单步执行就在这里

void luaC_step (lua_State *L)

{

global_State *g = G(L);

l_mem lim = (GCSTEPSIZE/100) * g->gcstepmul;

if (lim == 0)

lim = (MAX_LUMEM-1)/2; /* no limit */

g->gcdept += g->totalbytes - g->GCthreshold;

{

lim -= singlestep(L);

if (g->gcstate == GCSpause) gc过程做完了

break;

} while (lim > 0);

if (g->gcstate != GCSpause)

{

if (g->gcdept < GCSTEPSIZE)

g->GCthreshold = g->totalbytes + GCSTEPSIZE; /* - lim/g->gcstepmul;*/

else

{

g->gcdept -= GCSTEPSIZE;

g->GCthreshold = g->totalbytes;

}

else

{

lua_assert(g->totalbytes >= g->estimate);

setthreshold(g);

}

gc真正的单步执行在这里

static l_mem singlestep (lua_State *L) {

global_State *g = G(L);

/*lua_checkmemory(L);*/

switch (g->gcstate)

{

case GCSpause: {

markroot(L); /* start a new collection */

return 0;

}

case GCSpropagate: {

if (g->gray)

return propagatemark(g);

else { /* no more `gray' objects */

atomic(L); /* finish mark phase */

return 0;

}

case GCSsweepstring: {

lu_mem old = g->totalbytes;

sweepwholelist(L, &g->strt.hash[g->sweepstrgc++]);

if (g->sweepstrgc >= g->strt.size) /* nothing more to sweep? */

g->gcstate = GCSsweep; /* end sweep-string phase */

lua_assert(old >= g->totalbytes);

g->estimate -= old - g->totalbytes;

return GCSWEEPCOST;

}

case GCSsweep: {

lu_mem old = g->totalbytes;

g->sweepgc = sweeplist(L, g->sweepgc, GCSWEEPMAX);

if (*g->sweepgc == NULL) { /* nothing more to sweep? */

checkSizes(L);

g->gcstate = GCSfinalize; /* end sweep phase */

}

lua_assert(old >= g->totalbytes);

g->estimate -= old - g->totalbytes;

return GCSWEEPMAX*GCSWEEPCOST;

}

case GCSfinalize: {

if (g->tmudata) {

GCTM(L);

if (g->estimate > GCFINALIZECOST)

g->estimate -= GCFINALIZECOST;

return GCFINALIZECOST;

}

else {

g->gcstate = GCSpause; /* end collection */

g->gcdept = 0;

return 0;

}

default: lua_assert(0); return 0;

}

lua GC过程一共分为五步 Pause ,Propagate, SweepString,Sweep,finalize

1. Pause阶段将主要部分进行标记

static void markroot (lua_State *L) {

global_State *g = G(L);

g->gray = NULL; globalState中 Gray List是所有的待处理对象

g->grayagain = NULL;

g->weak = NULL;

markobject(g, g->mainthread);

/* make global table be traversed before main stack */

markvalue(g, gt(g->mainthread));

markvalue(g, registry(L));

markmt(g);

g->gcstate = GCSpropagate;

}

标记的东西有 globalstate中main LuaState, GlobalValue表, registry表, 以及markmt标记 basic type的metatables。这之后GC进入一个搜索阶段开始将仍然能够访问到的值进行标记

2. Propagate阶段将所有仍然存活的值进行标记这个过程是渐进的

case GCSpropagate: {

if (g->gray) //Propagate的终结在于gray待处理链表已经为空所有的存活对象已经全部扫描到了

return propagatemark(g);

else

{ /* no more `gray' objects */

atomic(L); /* finish mark phase */

return 0;

}

在递归渐进的过程中标记所有可以访问到的值初次进入这里的markroot中一共标记luaState 和 Table两种形式

static l_mem propagatemark (global_State *g) {

GCObject *o = g->gray;

lua_assert(isgray(o));

gray2black(o); //在渐进过程中所有可以访问到的gray物体都会被变成black的

switch (o->gch.tt)

{

case LUA_TTABLE: {

Table *h = gco2h(o);

g->gray = h->gclist;

if (traversetable(g, h)) /* table is weak? */ 如果table中有weak标记重新将table变为gray

black2gray(o); /* keep it gray */ 出于什么考虑这里并没有把table重新串回global的gray 链表 ???

return sizeof(Table) + sizeof(TValue) * h->sizearray +

sizeof(Node) * sizenode(h);

}

case LUA_TFUNCTION: {

Closure *cl = gco2cl(o);

g->gray = cl->c.gclist; //为什么只有CCLosure才有只对C 闭包做这个

traverseclosure(g, cl);

return (cl->c.isC) ? sizeCclosure(cl->c.nupvalues) :

sizeLclosure(cl->l.nupvalues);

}

case LUA_TTHREAD: {

lua_State *th = gco2th(o);

g->gray = th->gclist;

th->gclist = g->grayagain;

g->grayagain = o;

black2gray(o);

traversestack(g, th);

return sizeof(lua_State) + sizeof(TValue) * th->stacksize +

sizeof(CallInfo) * th->size_ci;

}

case LUA_TPROTO: {

Proto *p = gco2p(o);

g->gray = p->gclist;

traverseproto(g, p);

return sizeof(Proto) + sizeof(Instruction) * p->sizecode +

sizeof(Proto *) * p->sizep +

sizeof(TValue) * p->sizek +

sizeof(int) * p->sizelineinfo +

sizeof(LocVar) * p->sizelocvars +

sizeof(TString *) * p->sizeupvalues;

}

default: lua_assert(0); return 0;

}

//初始table无metatable 不标记weakkey 不标记weakvalue 全部都是强引用即只要table是活的内部的key 与 value就都是活的了

遍历table 同时将能够访问的值都标记

static int traversetable (global_State *g, Table *h) {

int i;

int weakkey = 0;

int weakvalue = 0;

const TValue *mode;

if (h->metatable)

markobject(g, h->metatable); 标记Table的metatable

mode = gfasttm(g, h->metatable, TM_MODE);

if (mode && ttisstring(mode)) { /* is there a weak mode? */

weakkey = (strchr(svalue(mode), 'k') != NULL); 获取table的weakkey 与 weakvalue标记标志

weakvalue = (strchr(svalue(mode), 'v') != NULL);

if (weakkey || weakvalue) { /* is really weak? */

h->marked &= ~(KEYWEAK | VALUEWEAK); /* clear bits */

h->marked |= cast_byte((weakkey << KEYWEAKBIT) |

(weakvalue << VALUEWEAKBIT));

h->gclist = g->weak; /* must be cleared after GC, ... */ 把这个table链入gc 的 weak 链表中出于什么考虑

g->weak = obj2gco(h); /* ... so put in the appropriate list */

}

if (weakkey && weakvalue)

return 1; //weakkey 和 weakvalue都存在这是一个彻底的weak table 他不能决定table自己内部的key 与 value的生死所以不用继续向下标记了

if (!weakvalue) { //如果没标记weak value 那么数组的部分的存活状况是由table来决定的所以数组部分统统标记

i = h->sizearray;

while (i--)

markvalue(g, &h->array[i]);

}

i = sizenode(h);

while (i--) {

Node *n = gnode(h, i);

lua_assert(ttype(gkey(n)) != LUA_TDEADKEY || ttisnil(gval(n)));

if (ttisnil(gval(n))) //table内的 key value对的value已经被置nil 了可以从table中移除这个key & value pair了

removeentry(n); /* remove empty entries */

else {

lua_assert(!ttisnil(gkey(n)));

if (!weakkey) markvalue(g, gkey(n)); // 没有标记weak key 则key的存活决定于table

if (!weakvalue) markvalue(g, gval(n)); // 没有标记weak value 则value的存活决定于table

}

return weakkey || weakvalue;

}

遍历闭包将可访问的值进行标记

static void traverseclosure (global_State *g, Closure *cl) {

markobject(g, cl->c.env); 标记闭包的环境表

if (cl->c.isC) { //标记UpVals 只要Closure可以访问到那么那些Upvals 也应该可以访问到

int i;

for (i=0; i<cl->c.nupvalues; i++) /* mark its upvalues */

markvalue(g, &cl->c.upvalue[i]);

}

else {

int i;

lua_assert(cl->l.nupvalues == cl->l.p->nups);

markobject(g, cl->l.p);

for (i=0; i<cl->l.nupvalues; i++) /* mark its upvalues */

markobject(g, cl->l.upvals[i]);

}

遍历LuaState 标记堆栈中的活动值对CallInfo的调用层次要继续看

static void traversestack (global_State *g, lua_State *l) {

StkId o, lim;

CallInfo *ci;

markvalue(g, gt(l)); //标注GlobalValues

lim = l->top;

//找到当前活动堆栈的顶端通过调用层次来从最基本CallInfo 到当前的CallInfo

for (ci = l->base_ci; ci <= l->ci; ci++)

{

lua_assert(ci->top <= l->stack_last);

if (lim < ci->top) lim = ci->top;

}

// StkId stack; /* stack base */ 从堆栈底开始

// StkId top; /* first free slot in the stack */ 到第一个可用堆栈

for (o = l->stack; o < l->top; o++)

markvalue(g, o); //这些堆栈数据时当前的LuaState都可以访问的数据

for (; o <= lim; o++)

setnilvalue(o); //堆栈中达不到的数据主动释放这一步可省略??

checkstacksizes(l, lim);

}

标记Lua 函数声明

static void traverseproto (global_State *g, Proto *f) {

int i;

if (f->source) stringmark(f->source); 标记lua的src字符串

for (i=0; i<f->sizek; i++) /* mark literals */

markvalue(g, &f->k[i]); 标记Lua Functino中用到的const 常量表

for (i=0; i<f->sizeupvalues; i++) { /* mark upvalue names */

if (f->upvalues[i]) 标记Lua Function中用到的Upvalue Names 注意是名字

stringmark(f->upvalues[i]);

}

for (i=0; i<f->sizep; i++) { /* mark nested protos */

if (f->p[i])

markobject(g, f->p[i]); 标记内嵌在lua Function中的 lua Function定义

}

for (i=0; i<f->sizelocvars; i++) { /* mark local-variable names */

if (f->locvars[i].varname)

stringmark(f->locvars[i].varname); 标记定义在lua Function内部的局部变量的Names 注意又是名字

}

Proto只是一个函数原型所以他标记的那些.. 运行机制 Proto运行以后产生CallInfo以后才会在LuaState 的 stack中产生变量与值

在真正mark的时候牵扯到一个递归的过程

static void reallymarkobject (global_State *g, GCObject *o) {

lua_assert(iswhite(o) && !isdead(g, o));

white2gray(o);

switch (o->gch.tt) {

case LUA_TSTRING: {

字符串mark不需要做额外的操作

return;

}

case LUA_TUSERDATA: {

Table *mt = gco2u(o)->metatable;

gray2black(o); /* udata are never gray */

if (mt) markobject(g, mt); 如果metatable存在 mark它这又是一个递归的过程

markobject(g, gco2u(o)->env); mark userdata的env环境表

return;

}

case LUA_TUPVAL: {

UpVal *uv = gco2uv(o);

markvalue(g, uv->v);

if (uv->v == &uv->u.value) /* closed? */

gray2black(o); /* open upvalues are never black */

return;

}

case LUA_TFUNCTION: {

gco2cl(o)->c.gclist = g->gray; 如果mark到 function 那么需要propagate

g->gray = o;

break;

}

case LUA_TTABLE: {

gco2h(o)->gclist = g->gray; table需要propagate

g->gray = o;

break;

}

case LUA_TTHREAD: {

gco2th(o)->gclist = g->gray; LuaState 需要propagate

g->gray = o;

break;

}

case LUA_TPROTO: {

gco2p(o)->gclist = g->gray; Proto需要propagate

g->gray = o;

break;

}

default: lua_assert(0);

}

static void atomic (lua_State *L) {

global_State *g = G(L);

size_t udsize; /* total size of userdata to be finalized */

/* remark occasional upvalues of (maybe) dead threads */

remarkupvals(g);

/* traverse objects cautch by write barrier and by 'remarkupvals' */

propagateall(g);

/* remark weak tables */

g->gray = g->weak;

g->weak = NULL;

lua_assert(!iswhite(obj2gco(g->mainthread)));

markobject(g, L); /* mark running thread */

markmt(g); /* mark basic metatables (again) */

propagateall(g);

/* remark gray again */

g->gray = g->grayagain;

g->grayagain = NULL;

propagateall(g);

udsize = luaC_separateudata(L, 0); /* separate userdata to be finalized */

marktmu(g); /* mark `preserved' userdata */

udsize += propagateall(g); /* remark, to propagate `preserveness' */

cleartable(g->weak); /* remove collected objects from weak tables */

/* flip current white */ //变换当前的white标志位这样新创建出来的对象都不会被计入这次的GC过程

g->currentwhite = cast_byte(otherwhite(g));

g->sweepstrgc = 0;

g->sweepgc = &g->rootgc; sweepgc 指向 rootgc 开始

g->gcstate = GCSsweepstring;

g->estimate = g->totalbytes - udsize; /* first estimate */

}

在整个propagate过程完成后进行当前白色位变换这样新创建出来的对象都不会被计入这次的GC过程之后sweepgc指向rootgc 然后进入SweepString过程开始垃圾清理

atomic中有一个重要的步骤是 luaC_separateudata 将已经死亡且需要调用 GC method函数的Userdata分出来放入globalState GCObject *tmudata; /* last element of list of userdata to be GC */ 在gc的最后在执行对这部分Userdata的垃圾回收没有GC函数的Userdata会被直接回收内存

清理字符串阶段在这一阶段所有的字符串会被清理

case GCSsweepstring: {

lu_mem old = g->totalbytes;

sweepwholelist(L, &g->strt.hash[g->sweepstrgc++]); g->sweepstrgc在当前的值为0

if (g->sweepstrgc >= g->strt.size) /* nothing more to sweep? */ 全部扫描完毕了进入扫除其他垃圾的阶段

g->gcstate = GCSsweep; /* end sweep-string phase */

lua_assert(old >= g->totalbytes);

g->estimate -= old - g->totalbytes;

return GCSWEEPCOST;

}

static GCObject **sweeplist (lua_State *L, GCObject **p, lu_mem count) {

GCObject *curr;

global_State *g = G(L);

int deadmask = otherwhite(g); 旧的白色位为死亡标志位

while ((curr = *p) != NULL && count-- > 0) {

if (curr->gch.tt == LUA_TTHREAD) /* sweep open upvalues of each thread */

sweepwholelist(L, &gco2th(curr)->openupval);

if ((curr->gch.marked ^ WHITEBITS) & deadmask) { /* not dead? */

lua_assert(!isdead(g, curr) || testbit(curr->gch.marked, FIXEDBIT));

makewhite(g, curr); /* make it white (for next cycle) */ //将未死的对象重新标记为current white

p = &curr->gch.next;

}

else { /* must erase `curr' */

lua_assert(isdead(g, curr) || deadmask == bitmask(SFIXEDBIT));

*p = curr->gch.next;

if (curr == g->rootgc) /* is the first element of the list? */

g->rootgc = curr->gch.next; /* adjust first */

freeobj(L, curr); //内存释放步骤

}

return p;

}

其他类型的垃圾清理阶段

case GCSsweep: {

lu_mem old = g->totalbytes;

g->sweepgc = sweeplist(L, g->sweepgc, GCSWEEPMAX);

if (*g->sweepgc == NULL) { /* nothing more to sweep? */

checkSizes(L);

g->gcstate = GCSfinalize; /* end sweep phase */

}

lua_assert(old >= g->totalbytes);

g->estimate -= old - g->totalbytes;

return GCSWEEPMAX*GCSWEEPCOST;

}

以及最后的finalize阶段

case GCSfinalize: {

if (g->tmudata) 如果有要死当时要执行 gc method的Userdata 执行它的gc method

{

//Userdata 在这一步内存还未被释放吗 ???

GCTM(L);

if (g->estimate > GCFINALIZECOST)

g->estimate -= GCFINALIZECOST;

return GCFINALIZECOST;

}

else 没有这次的gc过程结束了

{

g->gcstate = GCSpause; /* end collection */

g->gcdept = 0;

return 0;

}

//执行Userdata的GC method

static void GCTM (lua_State *L) {

global_State *g = G(L);

GCObject *o = g->tmudata->gch.next; /* get first element */

Udata *udata = rawgco2u(o);

const TValue *tm;

/* remove udata from `tmudata' */

if (o == g->tmudata) /* last element? */

g->tmudata = NULL;

else

g->tmudata->gch.next = udata->uv.next;

udata->uv.next = g->mainthread->next; /* return it to `root' list */

g->mainthread->next = o;

makewhite(g, o);

tm = fasttm(L, udata->uv.metatable, TM_GC);

if (tm != NULL) {

lu_byte oldah = L->allowhook;

lu_mem oldt = g->GCthreshold;

L->allowhook = 0; /* stop debug hooks during GC tag method */

g->GCthreshold = 2*g->totalbytes; /* avoid GC steps */

setobj2s(L, L->top, tm);

setuvalue(L, L->top+1, udata);

L->top += 2;

luaD_call(L, L->top - 2, 0);

L->allowhook = oldah; /* restore hooks */

g->GCthreshold = oldt; /* restore threshold */

}

GCTM将Userdata的GC method拿来执行以下同时为这个Userdata标记CurrentWhite 因为在前面标记带GC Method的死亡Userdata时已经为Userdata标记了finalize标记所以在下次的GC过程中它将不

在执行GC method 而直接进行内存释放所以一个带GC method的Userdata 它的完全回收过程会经历两个GC过程

/* move `dead' udata that need finalization to list `tmudata' */

size_t luaC_separateudata (lua_State *L, int all) {

......

if (!(iswhite(curr) || all) || isfinalized(gco2u(curr))) //一个已经执行难过GC Method的Userdata会被直接进行垃圾回收不会出现GC method重复执行的问题

p = &curr->gch.next; /* don't bother with them */

....

}

这样Lua 的 GC 垃圾回收就完了

上一篇 »初学HTML5的一点理解
下一篇 »关于html页面元素语义化的一点思考

关于Lua一点分析

相关推荐

TypeScript 模块

关于RUBY处理多语言转字符编码的一点经验 nkf

Lua笔记

Delphi使用server组件控制excel的一点经验

关于delphi点击webbrowser中任意一点的问题

小程序员对时间管理的一点观点阐述

C语言中调用Lua

使用apache下pig的一点总结