|
|
|
@ -1,5 +1,5 @@ |
|
|
|
/*
|
|
|
|
** $Id: lgc.c,v 1.25 1999/08/16 20:52:00 roberto Exp roberto $ |
|
|
|
** $Id: lgc.c,v 1.26 1999/09/27 18:00:25 roberto Exp roberto $ |
|
|
|
** Garbage Collector |
|
|
|
** See Copyright Notice in lua.h |
|
|
|
*/ |
|
|
|
@ -8,8 +8,8 @@ |
|
|
|
#include "ldo.h" |
|
|
|
#include "lfunc.h" |
|
|
|
#include "lgc.h" |
|
|
|
#include "lmem.h" |
|
|
|
#include "lobject.h" |
|
|
|
#include "lref.h" |
|
|
|
#include "lstate.h" |
|
|
|
#include "lstring.h" |
|
|
|
#include "ltable.h" |
|
|
|
@ -21,138 +21,15 @@ |
|
|
|
static int markobject (TObject *o); |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
** ======================================================= |
|
|
|
** REF mechanism |
|
|
|
** ======================================================= |
|
|
|
*/ |
|
|
|
|
|
|
|
|
|
|
|
int luaC_ref (const TObject *o, int lock) { |
|
|
|
int ref; |
|
|
|
if (ttype(o) == LUA_T_NIL) |
|
|
|
ref = LUA_REFNIL; |
|
|
|
else { |
|
|
|
for (ref=0; ref<L->refSize; ref++) |
|
|
|
if (L->refArray[ref].status == FREE) |
|
|
|
break; |
|
|
|
if (ref == L->refSize) { /* no more empty spaces? */ |
|
|
|
luaM_growvector(L->refArray, L->refSize, 1, struct ref, refEM, MAX_INT); |
|
|
|
L->refSize++; |
|
|
|
} |
|
|
|
L->refArray[ref].o = *o; |
|
|
|
L->refArray[ref].status = lock ? LOCK : HOLD; |
|
|
|
} |
|
|
|
return ref; |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
void lua_unref (int ref) { |
|
|
|
if (ref >= 0 && ref < L->refSize) |
|
|
|
L->refArray[ref].status = FREE; |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
const TObject *luaC_getref (int ref) { |
|
|
|
if (ref == LUA_REFNIL) |
|
|
|
return &luaO_nilobject; |
|
|
|
if (ref >= 0 && ref < L->refSize && |
|
|
|
(L->refArray[ref].status == LOCK || L->refArray[ref].status == HOLD)) |
|
|
|
return &L->refArray[ref].o; |
|
|
|
else |
|
|
|
return NULL; |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
static void travlock (void) { |
|
|
|
int i; |
|
|
|
for (i=0; i<L->refSize; i++) |
|
|
|
if (L->refArray[i].status == LOCK) |
|
|
|
markobject(&L->refArray[i].o); |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
static int ismarked (const TObject *o) { |
|
|
|
/* valid only for locked objects */ |
|
|
|
switch (o->ttype) { |
|
|
|
case LUA_T_STRING: case LUA_T_USERDATA: |
|
|
|
return o->value.ts->head.marked; |
|
|
|
case LUA_T_ARRAY: |
|
|
|
return o->value.a->head.marked; |
|
|
|
case LUA_T_CLOSURE: |
|
|
|
return o->value.cl->head.marked; |
|
|
|
case LUA_T_PROTO: |
|
|
|
return o->value.tf->head.marked; |
|
|
|
#ifdef DEBUG |
|
|
|
case LUA_T_LINE: case LUA_T_CLMARK: |
|
|
|
case LUA_T_CMARK: case LUA_T_PMARK: |
|
|
|
LUA_INTERNALERROR("invalid type"); |
|
|
|
#endif |
|
|
|
default: /* nil, number or cproto */ |
|
|
|
return 1; |
|
|
|
} |
|
|
|
} |
|
|
|
/* mark a string; marks bigger than 1 cannot be changed */ |
|
|
|
#define strmark(s) {if ((s)->marked == 0) (s)->marked = 1;} |
|
|
|
|
|
|
|
|
|
|
|
static void invalidaterefs (void) { |
|
|
|
int i; |
|
|
|
for (i=0; i<L->refSize; i++) |
|
|
|
if (L->refArray[i].status == HOLD && !ismarked(&L->refArray[i].o)) |
|
|
|
L->refArray[i].status = COLLECTED; |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
void luaC_hashcallIM (Hash *l) { |
|
|
|
TObject t; |
|
|
|
ttype(&t) = LUA_T_ARRAY; |
|
|
|
for (; l; l=(Hash *)l->head.next) { |
|
|
|
avalue(&t) = l; |
|
|
|
luaD_gcIM(&t); |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
void luaC_strcallIM (TaggedString *l) { |
|
|
|
TObject o; |
|
|
|
ttype(&o) = LUA_T_USERDATA; |
|
|
|
for (; l; l=(TaggedString *)l->head.next) |
|
|
|
if (l->constindex == -1) { /* is userdata? */ |
|
|
|
tsvalue(&o) = l; |
|
|
|
luaD_gcIM(&o); |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
static GCnode *listcollect (GCnode *l) { |
|
|
|
GCnode *frees = NULL; |
|
|
|
while (l) { |
|
|
|
GCnode *next = l->next; |
|
|
|
l->marked = 0; |
|
|
|
while (next && !next->marked) { |
|
|
|
l->next = next->next; |
|
|
|
next->next = frees; |
|
|
|
frees = next; |
|
|
|
next = l->next; |
|
|
|
} |
|
|
|
l = next; |
|
|
|
} |
|
|
|
return frees; |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
** mark a string; marks bigger than 1 cannot be changed. |
|
|
|
*/ |
|
|
|
#define strmark(s) {if ((s)->head.marked == 0) (s)->head.marked = 1;} |
|
|
|
|
|
|
|
|
|
|
|
static void protomark (TProtoFunc *f) { |
|
|
|
if (!f->head.marked) { |
|
|
|
if (!f->marked) { |
|
|
|
int i; |
|
|
|
f->head.marked = 1; |
|
|
|
f->marked = 1; |
|
|
|
strmark(f->source); |
|
|
|
for (i=f->nconsts-1; i>=0; i--) |
|
|
|
markobject(&f->consts[i]); |
|
|
|
@ -161,9 +38,9 @@ static void protomark (TProtoFunc *f) { |
|
|
|
|
|
|
|
|
|
|
|
static void closuremark (Closure *f) { |
|
|
|
if (!f->head.marked) { |
|
|
|
if (!f->marked) { |
|
|
|
int i; |
|
|
|
f->head.marked = 1; |
|
|
|
f->marked = 1; |
|
|
|
for (i=f->nelems; i>=0; i--) |
|
|
|
markobject(&f->consts[i]); |
|
|
|
} |
|
|
|
@ -171,9 +48,9 @@ static void closuremark (Closure *f) { |
|
|
|
|
|
|
|
|
|
|
|
static void hashmark (Hash *h) { |
|
|
|
if (!h->head.marked) { |
|
|
|
if (!h->marked) { |
|
|
|
int i; |
|
|
|
h->head.marked = 1; |
|
|
|
h->marked = 1; |
|
|
|
for (i=nhash(h)-1; i>=0; i--) { |
|
|
|
Node *n = node(h,i); |
|
|
|
if (ttype(ref(n)) != LUA_T_NIL) { |
|
|
|
@ -187,7 +64,7 @@ static void hashmark (Hash *h) { |
|
|
|
|
|
|
|
static void globalmark (void) { |
|
|
|
TaggedString *g; |
|
|
|
for (g=(TaggedString *)L->rootglobal.next; g; g=(TaggedString *)g->head.next){ |
|
|
|
for (g=L->rootglobal; g; g=g->next) { |
|
|
|
LUA_ASSERT(g->constindex >= 0, "userdata in global list"); |
|
|
|
if (g->u.s.globalval.ttype != LUA_T_NIL) { |
|
|
|
markobject(&g->u.s.globalval); |
|
|
|
@ -197,6 +74,21 @@ static void globalmark (void) { |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
static void travstack (void) { |
|
|
|
StkId i; |
|
|
|
for (i = (L->stack.top-1)-L->stack.stack; i>=0; i--) |
|
|
|
markobject(L->stack.stack+i); |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
static void travlock (void) { |
|
|
|
int i; |
|
|
|
for (i=0; i<L->refSize; i++) |
|
|
|
if (L->refArray[i].status == LOCK) |
|
|
|
markobject(&L->refArray[i].o); |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
static int markobject (TObject *o) { |
|
|
|
switch (ttype(o)) { |
|
|
|
case LUA_T_USERDATA: case LUA_T_STRING: |
|
|
|
@ -217,36 +109,138 @@ static int markobject (TObject *o) { |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
static void collectproto (void) { |
|
|
|
TProtoFunc **p = &L->rootproto; |
|
|
|
TProtoFunc *next; |
|
|
|
while ((next = *p) != NULL) { |
|
|
|
if (next->marked) { |
|
|
|
next->marked = 0; |
|
|
|
p = &next->next; |
|
|
|
} |
|
|
|
else { |
|
|
|
*p = next->next; |
|
|
|
luaF_freeproto(next); |
|
|
|
} |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
static void collectclosure (void) { |
|
|
|
Closure **p = &L->rootcl; |
|
|
|
Closure *next; |
|
|
|
while ((next = *p) != NULL) { |
|
|
|
if (next->marked) { |
|
|
|
next->marked = 0; |
|
|
|
p = &next->next; |
|
|
|
} |
|
|
|
else { |
|
|
|
*p = next->next; |
|
|
|
luaF_freeclosure(next); |
|
|
|
} |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
static void collecttable (void) { |
|
|
|
Hash **p = &L->roottable; |
|
|
|
Hash *next; |
|
|
|
while ((next = *p) != NULL) { |
|
|
|
if (next->marked) { |
|
|
|
next->marked = 0; |
|
|
|
p = &next->next; |
|
|
|
} |
|
|
|
else { |
|
|
|
*p = next->next; |
|
|
|
luaH_free(next); |
|
|
|
} |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
static void clear_global_list (void) { |
|
|
|
TaggedString **p = &L->rootglobal; |
|
|
|
TaggedString *next; |
|
|
|
while ((next = *p) != NULL) { |
|
|
|
if (next->marked) p = &next->next; |
|
|
|
else *p = next->next; |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
** collect all elements with `marked' < `limit'. |
|
|
|
** with limit=1, that means all unmarked elements; |
|
|
|
** with limit=MAX_INT, that means all elements (but EMPTY). |
|
|
|
*/ |
|
|
|
static void collectstring (int limit) { |
|
|
|
TObject o; /* to call userdata 'gc' tag method */ |
|
|
|
int i; |
|
|
|
ttype(&o) = LUA_T_USERDATA; |
|
|
|
clear_global_list(); |
|
|
|
for (i=0; i<NUM_HASHS; i++) { |
|
|
|
stringtable *tb = &L->string_root[i]; |
|
|
|
int j; |
|
|
|
for (j=0; j<tb->size; j++) { |
|
|
|
TaggedString *t = tb->hash[j]; |
|
|
|
if (t == NULL) continue; |
|
|
|
if (t->marked < limit) { |
|
|
|
if (t->constindex == -1) { /* is userdata? */ |
|
|
|
tsvalue(&o) = t; |
|
|
|
luaD_gcIM(&o); |
|
|
|
} |
|
|
|
luaS_free(t); |
|
|
|
tb->hash[j] = &luaS_EMPTY; |
|
|
|
} |
|
|
|
else if (t->marked == 1) |
|
|
|
t->marked = 0; |
|
|
|
} |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
#ifdef LUA_COMPAT_GC |
|
|
|
static void tableTM (void) { |
|
|
|
Hash *p; |
|
|
|
TObject o; |
|
|
|
ttype(&o) = LUA_T_ARRAY; |
|
|
|
for (p = L->roottable; p; p = p->next) { |
|
|
|
if (!p->marked) { |
|
|
|
avalue(&o) = p; |
|
|
|
luaD_gcIM(&o); |
|
|
|
} |
|
|
|
} |
|
|
|
} |
|
|
|
#else |
|
|
|
#define tableTM() /* do nothing */ |
|
|
|
#endif |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
static void markall (void) { |
|
|
|
luaD_travstack(markobject); /* mark stack objects */ |
|
|
|
travstack(); /* mark stack objects */ |
|
|
|
globalmark(); /* mark global variable values and names */ |
|
|
|
travlock(); /* mark locked objects */ |
|
|
|
luaT_travtagmethods(markobject); /* mark fallbacks */ |
|
|
|
luaT_travtagmethods(markobject); /* mark tag methods */ |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
void luaC_collect (int all) { |
|
|
|
L->GCthreshold *= 4; /* to avoid GC during GC */ |
|
|
|
tableTM(); /* call TM for tables (if LUA_COMPAT_GC) */ |
|
|
|
collecttable(); |
|
|
|
collectstring(all?MAX_INT:1); |
|
|
|
collectproto(); |
|
|
|
collectclosure(); |
|
|
|
luaD_gcIM(&luaO_nilobject); /* GC tag method for nil (signal end of GC) */ |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
long lua_collectgarbage (long limit) { |
|
|
|
unsigned long recovered = L->nblocks; /* to subtract nblocks after gc */ |
|
|
|
Hash *freetable; |
|
|
|
TaggedString *freestr; |
|
|
|
TProtoFunc *freefunc; |
|
|
|
Closure *freeclos; |
|
|
|
markall(); |
|
|
|
invalidaterefs(); |
|
|
|
freestr = luaS_collector(); |
|
|
|
freetable = (Hash *)listcollect(&(L->roottable)); |
|
|
|
freefunc = (TProtoFunc *)listcollect(&(L->rootproto)); |
|
|
|
freeclos = (Closure *)listcollect(&(L->rootcl)); |
|
|
|
L->GCthreshold *= 4; /* to avoid GC during GC */ |
|
|
|
luaC_hashcallIM(freetable); /* GC tag methods for tables */ |
|
|
|
luaC_strcallIM(freestr); /* GC tag methods for userdata */ |
|
|
|
luaD_gcIM(&luaO_nilobject); /* GC tag method for nil (signal end of GC) */ |
|
|
|
luaH_free(freetable); |
|
|
|
luaS_free(freestr); |
|
|
|
luaF_freeproto(freefunc); |
|
|
|
luaF_freeclosure(freeclos); |
|
|
|
recovered = recovered-L->nblocks; |
|
|
|
luaR_invalidaterefs(); |
|
|
|
luaC_collect(0); |
|
|
|
recovered = recovered - L->nblocks; |
|
|
|
L->GCthreshold = (limit == 0) ? 2*L->nblocks : L->nblocks+limit; |
|
|
|
return recovered; |
|
|
|
} |
|
|
|
|
Roberto Ierusalimschy
25 years ago