opensources
/
lua
mirror of https://github.com/lua/lua.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Browse Source

(huge) simplification of GC management

pull/9/head
Roberto Ierusalimschy 15 years ago
parent
2d5931ebc8
commit
ce444bff33
4 changed files with 50 additions and 110 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 133
      lgc.c
  2. 7
      lgc.h
  3. 14
      lstate.c
  4. 6
      lstate.h

133
lgc.c
View File

@ -1,5 +1,5 @@
/*
** $Id: lgc.c,v 2.60 2009/11/06 17:06:19 roberto Exp roberto $
** $Id: lgc.c,v 2.61 2009/11/09 18:29:21 roberto Exp roberto $
** Garbage Collector
** See Copyright Notice in lua.h
*/
@ -52,9 +52,6 @@
reallymarkobject(g, obj2gco(t)); }
#define setthreshold(g) (g->GCthreshold = (g->estimate/100) * g->gcpause)
static void reallymarkobject (global_State *g, GCObject *o);
@ -94,6 +91,7 @@ static int iscleared (const TValue *o, int iskey) {
(ttisuserdata(o) && (!iskey && isfinalized(uvalue(o))));
}
void luaC_barrierf (lua_State *L, GCObject *o, GCObject *v) {
global_State *g = G(L);
lua_assert(isblack(o) && iswhite(v) && !isdead(g, v) && !isdead(g, o));
@ -363,7 +361,6 @@ static void traverseproto (global_State *g, Proto *f) {
}
static void traverseclosure (global_State *g, Closure *cl) {
markobject(g, cl->c.env);
if (cl->c.isC) {
@ -443,10 +440,8 @@ static l_mem propagatemark (global_State *g) {
}
static size_t propagateall (global_State *g) {
size_t m = 0;
while (g->gray) m += propagatemark(g);
return m;
static void propagateall (global_State *g) {
while (g->gray) propagatemark(g);
}
@ -615,6 +610,8 @@ static void GCTM (lua_State *L, int propagateerrors) {
setuvalue(L, L->top+1, udata);
L->top += 2;
status = luaD_pcall(L, dothecall, NULL, savestack(L, L->top - 2), 0);
L->allowhook = oldah; /* restore hooks */
g->GCthreshold = oldt; /* restore threshold */
if (status != LUA_OK && propagateerrors) { /* error while running __gc? */
if (status == LUA_ERRRUN) { /* is there an error msg.? */
luaO_pushfstring(L, "error in __gc tag method (%s)",
@ -623,24 +620,13 @@ static void GCTM (lua_State *L, int propagateerrors) {
}
luaD_throw(L, status); /* re-send error */
}
L->allowhook = oldah; /* restore hooks */
g->GCthreshold = oldt; /* restore threshold */
}
}
/*
** Call all GC tag methods (without raising errors)
*/
void luaC_callAllGCTM (lua_State *L) {
while (G(L)->tobefnz) GCTM(L, 0);
}
/* move 'dead' udata that need finalization to list 'tobefnz' */
size_t luaC_separateudata (lua_State *L, int all) {
void luaC_separateudata (lua_State *L, int all) {
global_State *g = G(L);
size_t deadmem = 0; /* total size of all objects to be finalized */
GCObject **p = &g->mainthread->next;
GCObject *curr;
GCObject **lastnext = &g->tobefnz;
@ -653,7 +639,6 @@ size_t luaC_separateudata (lua_State *L, int all) {
p = &gch(curr)->next; /* don't bother with it */
else {
l_setbit(gch(curr)->marked, FINALIZEDBIT); /* won't be finalized again */
deadmem += sizeudata(gco2u(curr));
*p = gch(curr)->next; /* remove 'curr' from 'rootgc' list */
/* link 'curr' at the end of 'tobefnz' list */
gch(curr)->next = *lastnext;
@ -661,7 +646,6 @@ size_t luaC_separateudata (lua_State *L, int all) {
lastnext = &gch(curr)->next;
}
}
return deadmem;
}
@ -691,15 +675,15 @@ void luaC_checkfinalizer (lua_State *L, Udata *u) {
** =======================================================
*/
void luaC_freeall (lua_State *L) {
void luaC_freeallobjects (lua_State *L) {
global_State *g = G(L);
int i;
lua_assert(g->tobefnz == NULL);
/* mask to collect all elements */
while (g->tobefnz) GCTM(L, 0); /* Call all pending finalizers */
/* following "white" makes all objects look dead */
g->currentwhite = WHITEBITS | bitmask(SFIXEDBIT);
sweepwholelist(L, &g->rootgc);
lua_assert(g->rootgc == obj2gco(g->mainthread));
lua_assert(g->mainthread->next == NULL);
lua_assert(g->rootgc == obj2gco(g->mainthread) &&
g->mainthread->next == NULL);
for (i = 0; i < g->strt.size; i++) /* free all string lists */
sweepwholelist(L, &g->strt.hash[i]);
lua_assert(g->strt.nuse == 0);
@ -708,49 +692,37 @@ void luaC_freeall (lua_State *L) {
static void atomic (lua_State *L) {
global_State *g = G(L);
size_t udsize; /* total size of userdata to be finalized */
/* global table and registry may be changed by API */
g->gcstate = GCSatomic;
lua_assert(!iswhite(obj2gco(g->mainthread)));
markobject(g, L); /* mark running thread */
/* global table, registry, and global metatables may be changed by API */
markvalue(g, &g->l_gt);
markvalue(g, &g->l_registry);
markmt(g); /* mark basic metatables */
/* remark occasional upvalues of (maybe) dead threads */
g->gcstate = GCSatomic;
remarkupvals(g);
/* traverse objects caught 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);
/* at this point, all strongly accessible objects are marked.
Start marking weakily accessible objects. */
traverselistofgrays(g, &g->weak); /* remark weak tables */
traverselistofgrays(g, &g->ephemeron); /* remark ephemeron tables */
traverselistofgrays(g, &g->grayagain); /* remark gray again */
convergeephemerons(g);
udsize = luaC_separateudata(L, 0); /* separate userdata to be finalized */
luaC_separateudata(L, 0); /* separate userdata to be finalized */
markbeingfnz(g); /* mark userdata that will be finalized */
udsize += propagateall(g); /* remark, to propagate `preserveness' */
propagateall(g); /* remark, to propagate `preserveness' */
convergeephemerons(g);
/* remove collected objects from weak tables */
cleartable(g->weak);
cleartable(g->ephemeron);
cleartable(g->allweak);
/* flip current white */
g->currentwhite = cast_byte(otherwhite(g));
g->sweepstrgc = 0;
g->currentwhite = cast_byte(otherwhite(g)); /* flip current white */
g->sweepstrgc = 0; /* go to sweep phase */
g->gcstate = GCSsweepstring;
lua_assert(g->totalbytes > udsize);
g->estimate = g->totalbytes - udsize; /* first estimate */
}
#define correctestimate(g,s) { \
lu_mem old = g->totalbytes; s; \
lua_assert(old >= g->totalbytes); \
if (g->estimate >= old - g->totalbytes) \
g->estimate -= (old - g->totalbytes);}
static l_mem singlestep (lua_State *L) {
global_State *g = G(L);
/*lua_checkmemory(L);*/
@ -768,7 +740,7 @@ static l_mem singlestep (lua_State *L) {
}
}
case GCSsweepstring: {
correctestimate(g, sweepwholelist(L, &g->strt.hash[g->sweepstrgc++]));
sweepwholelist(L, &g->strt.hash[g->sweepstrgc++]);
if (g->sweepstrgc >= g->strt.size) { /* nothing more to sweep? */
g->sweepgc = &g->rootgc;
g->gcstate = GCSsweep; /* sweep all other objects */
@ -776,7 +748,7 @@ static l_mem singlestep (lua_State *L) {
return GCSWEEPCOST;
}
case GCSsweep: {
correctestimate(g, g->sweepgc = sweeplist(L, g->sweepgc, GCSWEEPMAX));
g->sweepgc = sweeplist(L, g->sweepgc, GCSWEEPMAX);
if (*g->sweepgc == NULL) /* nothing more to sweep? */
g->gcstate = GCSfinalize; /* end sweep phase */
return GCSWEEPMAX*GCSWEEPCOST;
@ -784,14 +756,11 @@ static l_mem singlestep (lua_State *L) {
case GCSfinalize: {
if (g->tobefnz) {
GCTM(L, 1);
if (g->estimate > GCFINALIZECOST)
g->estimate -= GCFINALIZECOST;
return GCFINALIZECOST;
}
else {
correctestimate(g, checkSizes(L));
checkSizes(L);
g->gcstate = GCSpause; /* end collection */
g->gcdept = 0;
return 0;
}
}
@ -802,29 +771,17 @@ static l_mem singlestep (lua_State *L) {
void luaC_step (lua_State *L) {
global_State *g = G(L);
l_mem lim = (GCSTEPSIZE/100) * g->gcstepmul;
l_mem lim = (GCSTEPSIZE/100) * g->gcstepmul; /* how much to work */
lu_mem debt = g->totalbytes - g->GCthreshold;
lua_assert(g->gckind == KGC_NORMAL);
if (lim == 0)
lim = (MAX_LUMEM-1)/2; /* no limit */
g->gcdept += g->totalbytes - g->GCthreshold;
do {
do { /* always perform at least one single step */
lim -= singlestep(L);
if (g->gcstate == GCSpause)
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 {
if (g->estimate > g->totalbytes)
g->estimate = g->totalbytes;
setthreshold(g);
}
} while (lim > 0 && g->gcstate != GCSpause);
g->GCthreshold = (g->gcstate != GCSpause)
? g->totalbytes + GCSTEPSIZE
: (g->totalbytes/100) * g->gcpause;
/* compensate if GC is "behind schedule" (has some debt to pay) */
if (g->GCthreshold > debt) g->GCthreshold -= debt;
}
@ -832,21 +789,15 @@ void luaC_fullgc (lua_State *L, int isemergency) {
global_State *g = G(L);
lua_assert(g->gckind == KGC_NORMAL);
g->gckind = isemergency ? KGC_EMERGENCY : KGC_FORCED;
if (g->gcstate <= GCSpropagate) {
/* reset other collector lists */
g->gray = NULL;
g->grayagain = NULL;
g->weak = g->ephemeron = g->allweak = NULL;
if (g->gcstate == GCSpropagate) { /* marking phase? */
/* must sweep all objects to turn them back to white
(as white does not change, nothing will be collected) */
g->sweepstrgc = 0;
g->gcstate = GCSsweepstring;
}
lua_assert(g->gcstate != GCSpause && g->gcstate != GCSpropagate);
/* finish any pending sweep phase */
while (g->gcstate != GCSfinalize) {
lua_assert(issweep(g));
singlestep(L);
}
markroot(L);
while (issweep(g)) singlestep(L);
markroot(L); /* start a new collection */
/* run collector up to finalizers */
while (g->gcstate != GCSfinalize)
singlestep(L);
@ -855,7 +806,7 @@ void luaC_fullgc (lua_State *L, int isemergency) {
while (g->gcstate != GCSpause)
singlestep(L);
}
setthreshold(g);
g->GCthreshold = (g->totalbytes/100) * g->gcpause;
}
/* }====================================================== */

7
lgc.h
View File

@ -1,5 +1,5 @@
/*
** $Id: lgc.h,v 2.21 2009/06/08 19:35:59 roberto Exp roberto $
** $Id: lgc.h,v 2.22 2009/11/17 11:56:03 roberto Exp roberto $
** Garbage Collector
** See Copyright Notice in lua.h
*/
@ -95,9 +95,8 @@
#define luaC_objbarriert(L,t,o) \
{ if (iswhite(obj2gco(o)) && isblack(obj2gco(t))) luaC_barrierback(L,t); }
LUAI_FUNC size_t luaC_separateudata (lua_State *L, int all);
LUAI_FUNC void luaC_callAllGCTM (lua_State *L);
LUAI_FUNC void luaC_freeall (lua_State *L);
LUAI_FUNC void luaC_separateudata (lua_State *L, int all);
LUAI_FUNC void luaC_freeallobjects (lua_State *L);
LUAI_FUNC void luaC_step (lua_State *L);
LUAI_FUNC void luaC_fullgc (lua_State *L, int isemergency);
LUAI_FUNC void luaC_link (lua_State *L, GCObject *o, lu_byte tt);

14
lstate.c
View File

@ -1,5 +1,5 @@
/*
** $Id: lstate.c,v 2.62 2009/10/05 16:44:33 roberto Exp roberto $
** $Id: lstate.c,v 2.63 2009/10/23 19:12:19 roberto Exp roberto $
** Global State
** See Copyright Notice in lua.h
*/
@ -139,7 +139,6 @@ static void f_luaopen (lua_State *L, void *ud) {
luaT_init(L);
luaX_init(L);
luaS_fix(luaS_newliteral(L, MEMERRMSG));
g->estimate = g->totalbytes;
g->GCthreshold = 4*g->totalbytes;
}
@ -170,7 +169,7 @@ static void preinit_state (lua_State *L, global_State *g) {
static void close_state (lua_State *L) {
global_State *g = G(L);
luaF_close(L, L->stack); /* close all upvalues for this thread */
luaC_freeall(L); /* collect all objects */
luaC_freeallobjects(L); /* collect all objects */
luaM_freearray(L, G(L)->strt.hash, G(L)->strt.size);
luaZ_freebuffer(L, &g->buff);
freestack(L);
@ -241,16 +240,10 @@ LUA_API lua_State *lua_newstate (lua_Alloc f, void *ud) {
g->version = lua_version(NULL);
g->gcstate = GCSpause;
g->rootgc = obj2gco(L);
g->sweepstrgc = 0;
g->sweepgc = &g->rootgc;
g->gray = NULL;
g->grayagain = NULL;
g->weak = g->ephemeron = g->allweak = NULL;
g->tobefnz = NULL;
g->estimate = g->totalbytes = sizeof(LG);
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) != LUA_OK) {
/* memory allocation error: free partial state */
@ -269,7 +262,6 @@ LUA_API void lua_close (lua_State *L) {
luaF_close(L, L->stack); /* close all upvalues for this thread */
luaC_separateudata(L, 1); /* separate all udata with GC metamethods */
lua_assert(L->next == NULL);
luaC_callAllGCTM(L); /* call GC metamethods for all udata */
luai_userstateclose(L);
close_state(L);
}

6
lstate.h
View File

@ -1,5 +1,5 @@
/*
** $Id: lstate.h,v 2.46 2009/07/15 17:26:14 roberto Exp roberto $
** $Id: lstate.h,v 2.47 2009/10/23 19:12:19 roberto Exp roberto $
** Global State
** See Copyright Notice in lua.h
*/
@ -132,10 +132,8 @@ typedef struct global_State {
GCObject *allweak; /* list of all-weak tables */
GCObject *tobefnz; /* list of userdata to be GC */
Mbuffer buff; /* temporary buffer for string concatentation */
lu_mem GCthreshold;
lu_mem GCthreshold; /* when totalbytes > GCthreshold, run GC step */
lu_mem totalbytes; /* number of bytes currently allocated */
lu_mem estimate; /* an estimate of number of bytes actually in use */
lu_mem gcdept; /* how much GC is `behind schedule' */
int gcpause; /* size of pause between successive GCs */
int gcstepmul; /* GC `granularity' */
lua_CFunction panic; /* to be called in unprotected errors */

Write Preview
Loading…
Cancel
Save