mirrors/lua
1
0
Fork 0
mirror of https://github.com/lua/lua synced 2025-04-06 13:02:54 +03:00
Code Issues Packages Projects Releases Wiki Activity

all objects with several children (tables, closures, stacks, prototypes)

Browse Source 
go to `gray' queue
This commit is contained in:
Roberto Ierusalimschy 2002-11-13 09:49:19 -02:00
parent 2f91f95d94
commit 3010eb0536
2 changed files with 199 additions and 163 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

346
lgc.c
View File

@ -1,5 +1,5 @@
/* /*
** $Id: lgc.c,v 1.155 2002/11/07 15:37:10 roberto Exp roberto $ ** $Id: lgc.c,v 1.156 2002/11/11 11:52:43 roberto Exp roberto $
** Garbage Collector ** Garbage Collector
** See Copyright Notice in lua.h ** See Copyright Notice in lua.h
*/ */
@ -21,11 +21,11 @@
typedef struct GCState { typedef struct GCState {
Table *tmark; /* list of marked tables to be visited */ GCObject *tmark; /* list of marked objects to be traversed */
Table *wk; /* list of visited key-weak tables (to be cleared after GC) */ GCObject *wk; /* list of traversed key-weak tables (to be cleared) */
Table *wv; /* list of visited value-weak tables */ GCObject *wv; /* list of traversed value-weak tables */
Table *wkv; /* list of visited key-value weak tables */ GCObject *wkv; /* list of traversed key-value weak tables */
lua_State *L; global_State *G;
} GCState; } GCState;
@ -47,8 +47,6 @@ typedef struct GCState {
#define markfinalized(u) resetbit((u)->uv.marked, 1) #define markfinalized(u) resetbit((u)->uv.marked, 1)
static void reallymarkobject (GCState *st, GCObject *o);
#define markobject(st,o) { checkconsistency(o); \ #define markobject(st,o) { checkconsistency(o); \
if (iscollectable(o) && !ismarked(gcvalue(o))) reallymarkobject(st,gcvalue(o)); } if (iscollectable(o) && !ismarked(gcvalue(o))) reallymarkobject(st,gcvalue(o)); }
@ -56,30 +54,138 @@ static void reallymarkobject (GCState *st, GCObject *o);
if (iscollectable(o) && !ismarked(gcvalue(o)) && (c)) \ if (iscollectable(o) && !ismarked(gcvalue(o)) && (c)) \
reallymarkobject(st,gcvalue(o)); } reallymarkobject(st,gcvalue(o)); }
#define marktable(st,t) { if (!ismarked(cast(GCObject *, t))) \ #define markvalue(st,t) { if (!ismarked(valtogco(t))) \
reallymarkobject(st, cast(GCObject *, (t))); } reallymarkobject(st, valtogco(t)); }
static void markproto (Proto *f) {
if (!f->marked) { static void reallymarkobject (GCState *st, GCObject *o) {
int i; lua_assert(!ismarked(o));
f->marked = 1; setbit(o->gch.marked, 0); /* mark object */
strmark(f->source); switch (o->gch.tt) {
for (i=0; i<f->sizek; i++) { case LUA_TUSERDATA: {
if (ttisstring(f->k+i)) markvalue(st, gcotou(o)->uv.metatable);
strmark(tsvalue(f->k+i)); break;
} }
for (i=0; i<f->sizep; i++) case LUA_TFUNCTION: {
markproto(f->p[i]); gcotocl(o)->c.gclist = st->tmark;
for (i=0; i<f->sizelocvars; i++) /* mark local-variable names */ st->tmark = o;
strmark(f->locvars[i].varname); break;
}
case LUA_TTABLE: {
gcotoh(o)->gclist = st->tmark;
st->tmark = o;
break;
}
case LUA_TTHREAD: {
gcototh(o)->gclist = st->tmark;
st->tmark = o;
break;
}
case LUA_TPROTO: {
gcotop(o)->gclist = st->tmark;
st->tmark = o;
break;
}
default: lua_assert(o->gch.tt == LUA_TSTRING);
} }
}
static void marktmu (GCState *st) {
GCObject *u;
for (u = st->G->tmudata; u; u = u->gch.next) {
unmark(u); /* may be marked, if left from previous GC */
reallymarkobject(st, u);
}
}
/* move `dead' udata that need finalization to list `tmudata' */
static void separateudata (lua_State *L) {
GCObject **p = &G(L)->rootudata;
GCObject *curr;
GCObject *collected = NULL; /* to collect udata with gc event */
GCObject **lastcollected = &collected;
while ((curr = *p) != NULL) {
lua_assert(curr->gch.tt == LUA_TUSERDATA);
if (ismarked(curr) || isfinalized(gcotou(curr)))
p = &curr->gch.next; /* don't bother with them */
else if (fasttm(L, gcotou(curr)->uv.metatable, TM_GC) == NULL) {
markfinalized(gcotou(curr)); /* don't need finalization */
p = &curr->gch.next;
}
else { /* must call its gc method */
*p = curr->gch.next;
curr->gch.next = NULL; /* link `curr' at the end of `collected' list */
*lastcollected = curr;
lastcollected = &curr->gch.next;
}
}
/* insert collected udata with gc event into `tmudata' list */
*lastcollected = G(L)->tmudata;
G(L)->tmudata = collected;
}
static void removekey (Node *n) {
setnilvalue(val(n)); /* remove corresponding value ... */
if (iscollectable(key(n)))
setttype(key(n), LUA_TNONE); /* dead key; remove it */
}
static void traversetable (GCState *st, Table *h) {
int i;
int weakkey = 0;
int weakvalue = 0;
markvalue(st, h->metatable);
lua_assert(h->lsizenode || h->node == st->G->dummynode);
if (h->mode & (WEAKKEY | WEAKVALUE)) { /* weak table? */
GCObject **weaklist;
weakkey = h->mode & WEAKKEY;
weakvalue = h->mode & WEAKVALUE;
weaklist = (weakkey && weakvalue) ? &st->wkv :
(weakkey) ? &st->wk :
&st->wv;
h->gclist = *weaklist; /* must be cleared after GC, ... */
*weaklist = valtogco(h); /* ... so put in the appropriate list */
}
if (!weakvalue) {
i = sizearray(h);
while (i--)
markobject(st, &h->array[i]);
}
i = sizenode(h);
while (i--) {
Node *n = node(h, i);
if (!ttisnil(val(n))) {
lua_assert(!ttisnil(key(n)));
condmarkobject(st, key(n), !weakkey);
condmarkobject(st, val(n), !weakvalue);
}
}
}
static void traverseproto (GCState *st, Proto *f) {
int i;
strmark(f->source);
for (i=0; i<f->sizek; i++) {
if (ttisstring(f->k+i))
strmark(tsvalue(f->k+i));
}
for (i=0; i<f->sizep; i++)
markvalue(st, f->p[i]);
for (i=0; i<f->sizelocvars; i++) /* mark local-variable names */
strmark(f->locvars[i].varname);
lua_assert(luaG_checkcode(f)); lua_assert(luaG_checkcode(f));
} }
static void markclosure (GCState *st, Closure *cl) { static void traverseclosure (GCState *st, Closure *cl) {
if (cl->c.isC) { if (cl->c.isC) {
int i; int i;
for (i=0; i<cl->c.nupvalues; i++) /* mark its upvalues */ for (i=0; i<cl->c.nupvalues; i++) /* mark its upvalues */
@ -88,8 +194,8 @@ static void markclosure (GCState *st, Closure *cl) {
else { else {
int i; int i;
lua_assert(cl->l.nupvalues == cl->l.p->nupvalues); lua_assert(cl->l.nupvalues == cl->l.p->nupvalues);
marktable(st, hvalue(&cl->l.g)); markvalue(st, hvalue(&cl->l.g));
markproto(cl->l.p); markvalue(st, cl->l.p);
for (i=0; i<cl->l.nupvalues; i++) { /* mark its upvalues */ for (i=0; i<cl->l.nupvalues; i++) { /* mark its upvalues */
UpVal *u = cl->l.upvals[i]; UpVal *u = cl->l.upvals[i];
if (!u->marked) { if (!u->marked) {
@ -111,7 +217,7 @@ static void checkstacksizes (lua_State *L, StkId max) {
} }
static void markstack (GCState *st, lua_State *L1) { static void traversestack (GCState *st, lua_State *L1) {
StkId o, lim; StkId o, lim;
CallInfo *ci; CallInfo *ci;
markobject(st, gt(L1)); markobject(st, gt(L1));
@ -127,110 +233,35 @@ static void markstack (GCState *st, lua_State *L1) {
} }
static void reallymarkobject (GCState *st, GCObject *o) {
setbit(o->gch.marked, 0); /* mark object */
switch (o->gch.tt) {
case LUA_TFUNCTION: {
markclosure(st, &o->cl);
break;
}
case LUA_TUSERDATA: {
marktable(st, (&o->u)->uv.metatable);
break;
}
case LUA_TTABLE: {
(&o->h)->gclist = st->tmark; /* chain it for later traversal */
st->tmark = &o->h;
break;
}
case LUA_TTHREAD: {
markstack(st, &o->th);
break;
}
}
}
static void marktmu (GCState *st) {
GCObject *u;
for (u = G(st->L)->tmudata; u; u = u->uv.next)
reallymarkobject(st, u);
}
/* move `dead' udata that need finalization to list `tmudata' */
static void separateudata (lua_State *L) {
GCObject **p = &G(L)->rootudata;
GCObject *curr;
GCObject *collected = NULL; /* to collect udata with gc event */
GCObject **lastcollected = &collected;
while ((curr = *p) != NULL) {
lua_assert(curr->gch.tt == LUA_TUSERDATA);
if (ismarked(curr) || isfinalized(&curr->u))
p = &curr->uv.next; /* don't bother with them */
else if (fasttm(L, (&curr->u)->uv.metatable, TM_GC) == NULL) {
markfinalized(&curr->u); /* don't need finalization */
p = &curr->uv.next;
}
else { /* must call its gc method */
*p = curr->uv.next;
curr->uv.next = NULL; /* link `curr' at the end of `collected' list */
*lastcollected = curr;
lastcollected = &curr->uv.next;
}
}
/* insert collected udata with gc event into `tmudata' list */
*lastcollected = G(L)->tmudata;
G(L)->tmudata = collected;
}
static void removekey (Node *n) {
setnilvalue(val(n)); /* remove corresponding value ... */
if (iscollectable(key(n)))
setttype(key(n), LUA_TNONE); /* dead key; remove it */
}
static void traversetable (GCState *st, Table *h) {
int i;
int weakkey = 0;
int weakvalue = 0;
marktable(st, h->metatable);
lua_assert(h->lsizenode || h->node == G(st->L)->dummynode);
if (h->mode & (WEAKKEY | WEAKVALUE)) { /* weak table? */
Table **weaklist;
weakkey = h->mode & WEAKKEY;
weakvalue = h->mode & WEAKVALUE;
weaklist = (weakkey && weakvalue) ? &st->wkv :
(weakkey) ? &st->wk :
&st->wv;
h->gclist = *weaklist; /* must be cleared after GC, ... */
*weaklist = h; /* ... so put in the appropriate list */
}
if (!weakvalue) {
i = sizearray(h);
while (i--)
markobject(st, &h->array[i]);
}
i = sizenode(h);
while (i--) {
Node *n = node(h, i);
if (!ttisnil(val(n))) {
lua_assert(!ttisnil(key(n)));
condmarkobject(st, key(n), !weakkey);
condmarkobject(st, val(n), !weakvalue);
}
}
}
static void propagatemarks (GCState *st) { static void propagatemarks (GCState *st) {
while (st->tmark) { /* traverse marked tables */ while (st->tmark) { /* traverse marked objects */
Table *h = st->tmark; /* get first table from list */ switch (st->tmark->gch.tt) {
st->tmark = h->gclist; /* remove it from list */ case LUA_TTABLE: {
traversetable(st, h); Table *h = gcotoh(st->tmark);
st->tmark = h->gclist;
traversetable(st, h);
break;
}
case LUA_TFUNCTION: {
Closure *cl = gcotocl(st->tmark);
st->tmark = cl->c.gclist;
traverseclosure(st, cl);
break;
}
case LUA_TTHREAD: {
lua_State *th = gcototh(st->tmark);
st->tmark = th->gclist;
traversestack(st, th);
break;
}
case LUA_TPROTO: {
Proto *p = gcotop(st->tmark);
st->tmark = p->gclist;
traverseproto(st, p);
break;
}
default: lua_assert(0);
}
} }
} }
@ -245,8 +276,9 @@ static int valismarked (const TObject *o) {
/* /*
** clear collected keys from weaktables ** clear collected keys from weaktables
*/ */
static void cleartablekeys (Table *h) { static void cleartablekeys (GCObject *l) {
for (; h; h = h->gclist) { while (l) {
Table *h = gcotoh(l);
int i = sizenode(h); int i = sizenode(h);
lua_assert(h->mode & WEAKKEY); lua_assert(h->mode & WEAKKEY);
while (i--) { while (i--) {
@ -254,6 +286,7 @@ static void cleartablekeys (Table *h) {
if (!valismarked(key(n))) /* key was collected? */ if (!valismarked(key(n))) /* key was collected? */
removekey(n); /* remove entry from table */ removekey(n); /* remove entry from table */
} }
l = h->gclist;
} }
} }
@ -261,8 +294,9 @@ static void cleartablekeys (Table *h) {
/* /*
** clear collected values from weaktables ** clear collected values from weaktables
*/ */
static void cleartablevalues (Table *h) { static void cleartablevalues (GCObject *l) {
for (; h; h = h->gclist) { while (l) {
Table *h = gcotoh(l);
int i = sizearray(h); int i = sizearray(h);
lua_assert(h->mode & WEAKVALUE); lua_assert(h->mode & WEAKVALUE);
while (i--) { while (i--) {
@ -276,27 +310,28 @@ static void cleartablevalues (Table *h) {
if (!valismarked(val(n))) /* value was collected? */ if (!valismarked(val(n))) /* value was collected? */
removekey(n); /* remove entry from table */ removekey(n); /* remove entry from table */
} }
l = h->gclist;
} }
} }
static void freeobj (lua_State *L, GCObject *o) { static void freeobj (lua_State *L, GCObject *o) {
switch (o->gch.tt) { switch (o->gch.tt) {
case LUA_TPROTO: luaF_freeproto(L, &o->p); break; case LUA_TPROTO: luaF_freeproto(L, gcotop(o)); break;
case LUA_TFUNCTION: luaF_freeclosure(L, &o->cl); break; case LUA_TFUNCTION: luaF_freeclosure(L, gcotocl(o)); break;
case LUA_TUPVAL: luaM_freelem(L, &o->uv); break; case LUA_TUPVAL: luaM_freelem(L, gcotouv(o)); break;
case LUA_TTABLE: luaH_free(L, &o->h); break; case LUA_TTABLE: luaH_free(L, gcotoh(o)); break;
case LUA_TTHREAD: { case LUA_TTHREAD: {
lua_assert(&o->th != L && &o->th != G(L)->mainthread); lua_assert(gcototh(o) != L && gcototh(o) != G(L)->mainthread);
luaE_freethread(L, &o->th); luaE_freethread(L, gcototh(o));
break; break;
} }
case LUA_TSTRING: { case LUA_TSTRING: {
luaM_free(L, o, sizestring((&o->ts)->tsv.len)); luaM_free(L, o, sizestring(gcotots(o)->tsv.len));
break; break;
} }
case LUA_TUSERDATA: { case LUA_TUSERDATA: {
luaM_free(L, o, sizeudata((&o->u)->uv.len)); luaM_free(L, o, sizeudata(gcotou(o)->uv.len));
break; break;
} }
default: lua_assert(0); default: lua_assert(0);
@ -360,14 +395,15 @@ static void callGCTM (lua_State *L) {
setallowhook(L, 0); /* stop debug hooks during GC tag methods */ setallowhook(L, 0); /* stop debug hooks during GC tag methods */
L->top++; /* reserve space to keep udata while runs its gc method */ L->top++; /* reserve space to keep udata while runs its gc method */
while (G(L)->tmudata != NULL) { while (G(L)->tmudata != NULL) {
GCObject *udata = G(L)->tmudata; GCObject *o = G(L)->tmudata;
Udata *udata = gcotou(o);
G(L)->tmudata = udata->uv.next; /* remove udata from `tmudata' */ G(L)->tmudata = udata->uv.next; /* remove udata from `tmudata' */
udata->uv.next = G(L)->rootudata; /* return it to `root' list */ udata->uv.next = G(L)->rootudata; /* return it to `root' list */
G(L)->rootudata = udata; G(L)->rootudata = o;
setuvalue(L->top - 1, &udata->u); /* keep a reference to it */ setuvalue(L->top - 1, udata); /* keep a reference to it */
unmark(udata); unmark(o);
markfinalized(&udata->u); markfinalized(udata);
do1gcTM(L, &udata->u); do1gcTM(L, udata);
} }
L->top--; L->top--;
setallowhook(L, oldah); /* restore hooks */ setallowhook(L, oldah); /* restore hooks */
@ -389,23 +425,23 @@ void luaC_sweep (lua_State *L, int all) {
/* mark root set */ /* mark root set */
static void markroot (GCState *st) { static void markroot (GCState *st, lua_State *L) {
lua_State *L = st->L; global_State *G = st->G;
markobject(st, defaultmeta(L)); markobject(st, defaultmeta(L));
markobject(st, registry(L)); markobject(st, registry(L));
markstack(st, G(L)->mainthread); traversestack(st, G->mainthread);
if (L != G(L)->mainthread) /* another thread is running? */ if (L != G->mainthread) /* another thread is running? */
reallymarkobject(st, cast(GCObject *, L)); /* cannot collect it */ markvalue(st, L); /* cannot collect it */
} }
static void mark (lua_State *L) { static void mark (lua_State *L) {
GCState st; GCState st;
Table *wkv; GCObject *wkv;
st.L = L; st.G = G(L);
st.tmark = NULL; st.tmark = NULL;
st.wkv = st.wk = st.wv = NULL; st.wkv = st.wk = st.wv = NULL;
markroot(&st); markroot(&st, L);
propagatemarks(&st); /* mark all reachable objects */ propagatemarks(&st); /* mark all reachable objects */
cleartablevalues(st.wkv); cleartablevalues(st.wkv);
cleartablevalues(st.wv); cleartablevalues(st.wv);

16
lobject.h
View File

@ -1,5 +1,5 @@
/* /*
** $Id: lobject.h,v 1.151 2002/11/04 12:31:44 roberto Exp roberto $ ** $Id: lobject.h,v 1.152 2002/11/07 15:37:10 roberto Exp roberto $
** Type definitions for Lua objects ** Type definitions for Lua objects
** See Copyright Notice in lua.h ** See Copyright Notice in lua.h
*/ */
@ -219,6 +219,7 @@ typedef struct Proto {
int sizep; /* size of `p' */ int sizep; /* size of `p' */
int sizelocvars; int sizelocvars;
int lineDefined; int lineDefined;
GCObject *gclist;
lu_byte nupvalues; lu_byte nupvalues;
lu_byte numparams; lu_byte numparams;
lu_byte is_vararg; lu_byte is_vararg;
@ -249,19 +250,18 @@ typedef struct UpVal {
** Closures ** Closures
*/ */
#define ClosureHeader \
CommonHeader; lu_byte isC; lu_byte nupvalues; GCObject *gclist
typedef struct CClosure { typedef struct CClosure {
CommonHeader; ClosureHeader;
lu_byte isC; /* 0 for Lua functions, 1 for C functions */
lu_byte nupvalues;
lua_CFunction f; lua_CFunction f;
TObject upvalue[1]; TObject upvalue[1];
} CClosure; } CClosure;
typedef struct LClosure { typedef struct LClosure {
CommonHeader; ClosureHeader;
lu_byte isC;
lu_byte nupvalues; /* first five fields must be equal to CClosure!! */
struct Proto *p; struct Proto *p;
TObject g; /* global table for this closure */ TObject g; /* global table for this closure */
UpVal *upvals[1]; UpVal *upvals[1];
@ -298,7 +298,7 @@ typedef struct Table {
TObject *array; /* array part */ TObject *array; /* array part */
Node *node; Node *node;
Node *firstfree; /* this position is free; all positions after it are full */ Node *firstfree; /* this position is free; all positions after it are full */
struct Table *gclist; GCObject *gclist;
int sizearray; /* size of `array' array */ int sizearray; /* size of `array' array */
} Table; } Table;