lgc.c
上传用户:yisoukefu
上传日期:2020-08-09
资源大小:39506k
文件大小:20k
源码类别:

其他游戏

开发平台:

Visual C++

  1. /*
  2. ** $Id: lgc.c,v 2.37 2005/12/22 16:19:56 roberto Exp $
  3. ** Garbage Collector
  4. ** See Copyright Notice in lua.h
  5. */
  6. #include <string.h>
  7. #define lgc_c
  8. #define LUA_CORE
  9. #include "lua.h"
  10. #include "ldebug.h"
  11. #include "ldo.h"
  12. #include "lfunc.h"
  13. #include "lgc.h"
  14. #include "lmem.h"
  15. #include "lobject.h"
  16. #include "lstate.h"
  17. #include "lstring.h"
  18. #include "ltable.h"
  19. #include "ltm.h"
  20. #define GCSTEPSIZE 1024u
  21. #define GCSWEEPMAX 40
  22. #define GCSWEEPCOST 10
  23. #define GCFINALIZECOST 100
  24. #define maskmarks cast_byte(~(bitmask(BLACKBIT)|WHITEBITS))
  25. #define makewhite(g,x)
  26.    ((x)->gch.marked = cast_byte(((x)->gch.marked & maskmarks) | luaC_white(g)))
  27. #define white2gray(x) reset2bits((x)->gch.marked, WHITE0BIT, WHITE1BIT)
  28. #define black2gray(x) resetbit((x)->gch.marked, BLACKBIT)
  29. #define stringmark(s) reset2bits((s)->tsv.marked, WHITE0BIT, WHITE1BIT)
  30. #define isfinalized(u) testbit((u)->marked, FINALIZEDBIT)
  31. #define markfinalized(u) l_setbit((u)->marked, FINALIZEDBIT)
  32. #define KEYWEAK         bitmask(KEYWEAKBIT)
  33. #define VALUEWEAK       bitmask(VALUEWEAKBIT)
  34. #define markvalue(g,o) { checkconsistency(o); 
  35.   if (iscollectable(o) && iswhite(gcvalue(o))) reallymarkobject(g,gcvalue(o)); }
  36. #define markobject(g,t) { if (iswhite(obj2gco(t))) 
  37. reallymarkobject(g, obj2gco(t)); }
  38. #define setthreshold(g)  (g->GCthreshold = (g->estimate/100) * g->gcpause)
  39. static void removeentry (Node *n) {
  40.   lua_assert(ttisnil(gval(n)));
  41.   if (iscollectable(gkey(n)))
  42.     setttype(gkey(n), LUA_TDEADKEY);  /* dead key; remove it */
  43. }
  44. static void reallymarkobject (global_State *g, GCObject *o) {
  45.   lua_assert(iswhite(o) && !isdead(g, o));
  46.   white2gray(o);
  47.   switch (o->gch.tt) {
  48.     case LUA_TSTRING: {
  49.       return;
  50.     }
  51.     case LUA_TUSERDATA: {
  52.       Table *mt = gco2u(o)->metatable;
  53.       gray2black(o);  /* udata are never gray */
  54.       if (mt) markobject(g, mt);
  55.       markobject(g, gco2u(o)->env);
  56.       return;
  57.     }
  58.     case LUA_TUPVAL: {
  59.       UpVal *uv = gco2uv(o);
  60.       markvalue(g, uv->v);
  61.       if (uv->v == &uv->u.value)  /* closed? */
  62.         gray2black(o);  /* open upvalues are never black */
  63.       return;
  64.     }
  65.     case LUA_TFUNCTION: {
  66.       gco2cl(o)->c.gclist = g->gray;
  67.       g->gray = o;
  68.       break;
  69.     }
  70.     case LUA_TTABLE: {
  71.       gco2h(o)->gclist = g->gray;
  72.       g->gray = o;
  73.       break;
  74.     }
  75.     case LUA_TTHREAD: {
  76.       gco2th(o)->gclist = g->gray;
  77.       g->gray = o;
  78.       break;
  79.     }
  80.     case LUA_TPROTO: {
  81.       gco2p(o)->gclist = g->gray;
  82.       g->gray = o;
  83.       break;
  84.     }
  85.     default: lua_assert(0);
  86.   }
  87. }
  88. static void marktmu (global_State *g) {
  89.   GCObject *u = g->tmudata;
  90.   if (u) {
  91.     do {
  92.       u = u->gch.next;
  93.       makewhite(g, u);  /* may be marked, if left from previous GC */
  94.       reallymarkobject(g, u);
  95.     } while (u != g->tmudata);
  96.   }
  97. }
  98. /* move `dead' udata that need finalization to list `tmudata' */
  99. size_t luaC_separateudata (lua_State *L, int all) {
  100.   global_State *g = G(L);
  101.   size_t deadmem = 0;
  102.   GCObject **p = &g->mainthread->next;
  103.   GCObject *curr;
  104.   while ((curr = *p) != NULL) {
  105.     if (!(iswhite(curr) || all) || isfinalized(gco2u(curr)))
  106.       p = &curr->gch.next;  /* don't bother with them */
  107.     else if (fasttm(L, gco2u(curr)->metatable, TM_GC) == NULL) {
  108.       markfinalized(gco2u(curr));  /* don't need finalization */
  109.       p = &curr->gch.next;
  110.     }
  111.     else {  /* must call its gc method */
  112.       deadmem += sizeudata(gco2u(curr));
  113.       markfinalized(gco2u(curr));
  114.       *p = curr->gch.next;
  115.       /* link `curr' at the end of `tmudata' list */
  116.       if (g->tmudata == NULL)  /* list is empty? */
  117.         g->tmudata = curr->gch.next = curr;  /* creates a circular list */
  118.       else {
  119.         curr->gch.next = g->tmudata->gch.next;
  120.         g->tmudata->gch.next = curr;
  121.         g->tmudata = curr;
  122.       }
  123.     }
  124.   }
  125.   return deadmem;
  126. }
  127. static int traversetable (global_State *g, Table *h) {
  128.   int i;
  129.   int weakkey = 0;
  130.   int weakvalue = 0;
  131.   const TValue *mode;
  132.   if (h->metatable)
  133.     markobject(g, h->metatable);
  134.   mode = gfasttm(g, h->metatable, TM_MODE);
  135.   if (mode && ttisstring(mode)) {  /* is there a weak mode? */
  136.     weakkey = (strchr(svalue(mode), 'k') != NULL);
  137.     weakvalue = (strchr(svalue(mode), 'v') != NULL);
  138.     if (weakkey || weakvalue) {  /* is really weak? */
  139.       h->marked &= ~(KEYWEAK | VALUEWEAK);  /* clear bits */
  140.       h->marked |= cast_byte((weakkey << KEYWEAKBIT) |
  141.                              (weakvalue << VALUEWEAKBIT));
  142.       h->gclist = g->weak;  /* must be cleared after GC, ... */
  143.       g->weak = obj2gco(h);  /* ... so put in the appropriate list */
  144.     }
  145.   }
  146.   if (weakkey && weakvalue) return 1;
  147.   if (!weakvalue) {
  148.     i = h->sizearray;
  149.     while (i--)
  150.       markvalue(g, &h->array[i]);
  151.   }
  152.   i = sizenode(h);
  153.   while (i--) {
  154.     Node *n = gnode(h, i);
  155.     lua_assert(ttype(gkey(n)) != LUA_TDEADKEY || ttisnil(gval(n)));
  156.     if (ttisnil(gval(n)))
  157.       removeentry(n);  /* remove empty entries */
  158.     else {
  159.       lua_assert(!ttisnil(gkey(n)));
  160.       if (!weakkey) markvalue(g, gkey(n));
  161.       if (!weakvalue) markvalue(g, gval(n));
  162.     }
  163.   }
  164.   return weakkey || weakvalue;
  165. }
  166. /*
  167. ** All marks are conditional because a GC may happen while the
  168. ** prototype is still being created
  169. */
  170. static void traverseproto (global_State *g, Proto *f) {
  171.   int i;
  172.   if (f->source) stringmark(f->source);
  173.   for (i=0; i<f->sizek; i++)  /* mark literals */
  174.     markvalue(g, &f->k[i]);
  175.   for (i=0; i<f->sizeupvalues; i++) {  /* mark upvalue names */
  176.     if (f->upvalues[i])
  177.       stringmark(f->upvalues[i]);
  178.   }
  179.   for (i=0; i<f->sizep; i++) {  /* mark nested protos */
  180.     if (f->p[i])
  181.       markobject(g, f->p[i]);
  182.   }
  183.   for (i=0; i<f->sizelocvars; i++) {  /* mark local-variable names */
  184.     if (f->locvars[i].varname)
  185.       stringmark(f->locvars[i].varname);
  186.   }
  187. }
  188. static void traverseclosure (global_State *g, Closure *cl) {
  189.   markobject(g, cl->c.env);
  190.   if (cl->c.isC) {
  191.     int i;
  192.     for (i=0; i<cl->c.nupvalues; i++)  /* mark its upvalues */
  193.       markvalue(g, &cl->c.upvalue[i]);
  194.   }
  195.   else {
  196.     int i;
  197.     lua_assert(cl->l.nupvalues == cl->l.p->nups);
  198.     markobject(g, cl->l.p);
  199.     for (i=0; i<cl->l.nupvalues; i++)  /* mark its upvalues */
  200.       markobject(g, cl->l.upvals[i]);
  201.   }
  202. }
  203. static void checkstacksizes (lua_State *L, StkId max) {
  204.   int ci_used = cast_int(L->ci - L->base_ci);  /* number of `ci' in use */
  205.   int s_used = cast_int(max - L->stack);  /* part of stack in use */
  206.   if (L->size_ci > LUAI_MAXCALLS)  /* handling overflow? */
  207.     return;  /* do not touch the stacks */
  208.   if (4*ci_used < L->size_ci && 2*BASIC_CI_SIZE < L->size_ci)
  209.     luaD_reallocCI(L, L->size_ci/2);  /* still big enough... */
  210.   condhardstacktests(luaD_reallocCI(L, ci_used + 1));
  211.   if (4*s_used < L->stacksize &&
  212.       2*(BASIC_STACK_SIZE+EXTRA_STACK) < L->stacksize)
  213.     luaD_reallocstack(L, L->stacksize/2);  /* still big enough... */
  214.   condhardstacktests(luaD_reallocstack(L, s_used));
  215. }
  216. static void traversestack (global_State *g, lua_State *l) {
  217.   StkId o, lim;
  218.   CallInfo *ci;
  219.   markvalue(g, gt(l));
  220.   lim = l->top;
  221.   for (ci = l->base_ci; ci <= l->ci; ci++) {
  222.     lua_assert(ci->top <= l->stack_last);
  223.     if (lim < ci->top) lim = ci->top;
  224.   }
  225.   for (o = l->stack; o < l->top; o++)
  226.     markvalue(g, o);
  227.   for (; o <= lim; o++)
  228.     setnilvalue(o);
  229.   checkstacksizes(l, lim);
  230. }
  231. /*
  232. ** traverse one gray object, turning it to black.
  233. ** Returns `quantity' traversed.
  234. */
  235. static l_mem propagatemark (global_State *g) {
  236.   GCObject *o = g->gray;
  237.   lua_assert(isgray(o));
  238.   gray2black(o);
  239.   switch (o->gch.tt) {
  240.     case LUA_TTABLE: {
  241.       Table *h = gco2h(o);
  242.       g->gray = h->gclist;
  243.       if (traversetable(g, h))  /* table is weak? */
  244.         black2gray(o);  /* keep it gray */
  245.       return sizeof(Table) + sizeof(TValue) * h->sizearray +
  246.                              sizeof(Node) * sizenode(h);
  247.     }
  248.     case LUA_TFUNCTION: {
  249.       Closure *cl = gco2cl(o);
  250.       g->gray = cl->c.gclist;
  251.       traverseclosure(g, cl);
  252.       return (cl->c.isC) ? sizeCclosure(cl->c.nupvalues) :
  253.                            sizeLclosure(cl->l.nupvalues);
  254.     }
  255.     case LUA_TTHREAD: {
  256.       lua_State *th = gco2th(o);
  257.       g->gray = th->gclist;
  258.       th->gclist = g->grayagain;
  259.       g->grayagain = o;
  260.       black2gray(o);
  261.       traversestack(g, th);
  262.       return sizeof(lua_State) + sizeof(TValue) * th->stacksize +
  263.                                  sizeof(CallInfo) * th->size_ci;
  264.     }
  265.     case LUA_TPROTO: {
  266.       Proto *p = gco2p(o);
  267.       g->gray = p->gclist;
  268.       traverseproto(g, p);
  269.       return sizeof(Proto) + sizeof(Instruction) * p->sizecode +
  270.                              sizeof(Proto *) * p->sizep +
  271.                              sizeof(TValue) * p->sizek + 
  272.                              sizeof(int) * p->sizelineinfo +
  273.                              sizeof(LocVar) * p->sizelocvars +
  274.                              sizeof(TString *) * p->sizeupvalues;
  275.     }
  276.     default: lua_assert(0); return 0;
  277.   }
  278. }
  279. static void propagateall (global_State *g) {
  280.   while (g->gray) propagatemark(g);
  281. }
  282. /*
  283. ** The next function tells whether a key or value can be cleared from
  284. ** a weak table. Non-collectable objects are never removed from weak
  285. ** tables. Strings behave as `values', so are never removed too. for
  286. ** other objects: if really collected, cannot keep them; for userdata
  287. ** being finalized, keep them in keys, but not in values
  288. */
  289. static int iscleared (const TValue *o, int iskey) {
  290.   if (!iscollectable(o)) return 0;
  291.   if (ttisstring(o)) {
  292.     stringmark(rawtsvalue(o));  /* strings are `values', so are never weak */
  293.     return 0;
  294.   }
  295.   return iswhite(gcvalue(o)) ||
  296.     (ttisuserdata(o) && (!iskey && isfinalized(uvalue(o))));
  297. }
  298. /*
  299. ** clear collected entries from weaktables
  300. */
  301. static void cleartable (GCObject *l) {
  302.   while (l) {
  303.     Table *h = gco2h(l);
  304.     int i = h->sizearray;
  305.     lua_assert(testbit(h->marked, VALUEWEAKBIT) ||
  306.                testbit(h->marked, KEYWEAKBIT));
  307.     if (testbit(h->marked, VALUEWEAKBIT)) {
  308.       while (i--) {
  309.         TValue *o = &h->array[i];
  310.         if (iscleared(o, 0))  /* value was collected? */
  311.           setnilvalue(o);  /* remove value */
  312.       }
  313.     }
  314.     i = sizenode(h);
  315.     while (i--) {
  316.       Node *n = gnode(h, i);
  317.       if (!ttisnil(gval(n)) &&  /* non-empty entry? */
  318.           (iscleared(key2tval(n), 1) || iscleared(gval(n), 0))) {
  319.         setnilvalue(gval(n));  /* remove value ... */
  320.         removeentry(n);  /* remove entry from table */
  321.       }
  322.     }
  323.     l = h->gclist;
  324.   }
  325. }
  326. static void freeobj (lua_State *L, GCObject *o) {
  327.   switch (o->gch.tt) {
  328.     case LUA_TPROTO: luaF_freeproto(L, gco2p(o)); break;
  329.     case LUA_TFUNCTION: luaF_freeclosure(L, gco2cl(o)); break;
  330.     case LUA_TUPVAL: luaF_freeupval(L, gco2uv(o)); break;
  331.     case LUA_TTABLE: luaH_free(L, gco2h(o)); break;
  332.     case LUA_TTHREAD: {
  333.       lua_assert(gco2th(o) != L && gco2th(o) != G(L)->mainthread);
  334.       luaE_freethread(L, gco2th(o));
  335.       break;
  336.     }
  337.     case LUA_TSTRING: {
  338.       G(L)->strt.nuse--;
  339.       luaM_freemem(L, o, sizestring(gco2ts(o)));
  340.       break;
  341.     }
  342.     case LUA_TUSERDATA: {
  343.       luaM_freemem(L, o, sizeudata(gco2u(o)));
  344.       break;
  345.     }
  346.     default: lua_assert(0);
  347.   }
  348. }
  349. #define sweepwholelist(L,p) sweeplist(L,p,MAX_LUMEM)
  350. static GCObject **sweeplist (lua_State *L, GCObject **p, lu_mem count) {
  351.   GCObject *curr;
  352.   global_State *g = G(L);
  353.   int deadmask = otherwhite(g);
  354.   while ((curr = *p) != NULL && count-- > 0) {
  355.     if (curr->gch.tt == LUA_TTHREAD)  /* sweep open upvalues of each thread */
  356.       sweepwholelist(L, &gco2th(curr)->openupval);
  357.     if ((curr->gch.marked ^ WHITEBITS) & deadmask) {  /* not dead? */
  358.       lua_assert(!isdead(g, curr) || testbit(curr->gch.marked, FIXEDBIT));
  359.       makewhite(g, curr);  /* make it white (for next cycle) */
  360.       p = &curr->gch.next;
  361.     }
  362.     else {  /* must erase `curr' */
  363.       lua_assert(isdead(g, curr) || deadmask == bitmask(SFIXEDBIT));
  364.       *p = curr->gch.next;
  365.       if (curr == g->rootgc)  /* is the first element of the list? */
  366.         g->rootgc = curr->gch.next;  /* adjust first */
  367.       freeobj(L, curr);
  368.     }
  369.   }
  370.   return p;
  371. }
  372. static void checkSizes (lua_State *L) {
  373.   global_State *g = G(L);
  374.   /* check size of string hash */
  375.   if (g->strt.nuse < cast(lu_int32, g->strt.size/4) &&
  376.       g->strt.size > MINSTRTABSIZE*2)
  377.     luaS_resize(L, g->strt.size/2);  /* table is too big */
  378.   /* check size of buffer */
  379.   if (luaZ_sizebuffer(&g->buff) > LUA_MINBUFFER*2) {  /* buffer too big? */
  380.     size_t newsize = luaZ_sizebuffer(&g->buff) / 2;
  381.     luaZ_resizebuffer(L, &g->buff, newsize);
  382.   }
  383. }
  384. static void GCTM (lua_State *L) {
  385.   global_State *g = G(L);
  386.   GCObject *o = g->tmudata->gch.next;  /* get first element */
  387.   Udata *udata = rawgco2u(o);
  388.   const TValue *tm;
  389.   /* remove udata from `tmudata' */
  390.   if (o == g->tmudata)  /* last element? */
  391.     g->tmudata = NULL;
  392.   else
  393.     g->tmudata->gch.next = udata->uv.next;
  394.   udata->uv.next = g->mainthread->next;  /* return it to `root' list */
  395.   g->mainthread->next = o;
  396.   makewhite(g, o);
  397.   tm = fasttm(L, udata->uv.metatable, TM_GC);
  398.   if (tm != NULL) {
  399.     lu_byte oldah = L->allowhook;
  400.     lu_mem oldt = g->GCthreshold;
  401.     L->allowhook = 0;  /* stop debug hooks during GC tag method */
  402.     g->GCthreshold = 2*g->totalbytes;  /* avoid GC steps */
  403.     setobj2s(L, L->top, tm);
  404.     setuvalue(L, L->top+1, udata);
  405.     L->top += 2;
  406.     luaD_call(L, L->top - 2, 0);
  407.     L->allowhook = oldah;  /* restore hooks */
  408.     g->GCthreshold = oldt;  /* restore threshold */
  409.   }
  410. }
  411. /*
  412. ** Call all GC tag methods
  413. */
  414. void luaC_callGCTM (lua_State *L) {
  415.   while (G(L)->tmudata)
  416.     GCTM(L);
  417. }
  418. void luaC_freeall (lua_State *L) {
  419.   global_State *g = G(L);
  420.   int i;
  421.   g->currentwhite = WHITEBITS | bitmask(SFIXEDBIT);  /* mask to collect all elements */
  422.   sweepwholelist(L, &g->rootgc);
  423.   for (i = 0; i < g->strt.size; i++)  /* free all string lists */
  424.     sweepwholelist(L, &g->strt.hash[i]);
  425. }
  426. static void markmt (global_State *g) {
  427.   int i;
  428.   for (i=0; i<NUM_TAGS; i++)
  429.     if (g->mt[i]) markobject(g, g->mt[i]);
  430. }
  431. /* mark root set */
  432. static void markroot (lua_State *L) {
  433.   global_State *g = G(L);
  434.   g->gray = NULL;
  435.   g->grayagain = NULL;
  436.   g->weak = NULL;
  437.   markobject(g, g->mainthread);
  438.   /* make global table be traversed before main stack */
  439.   markvalue(g, gt(g->mainthread));
  440.   markvalue(g, registry(L));
  441.   markmt(g);
  442.   g->gcstate = GCSpropagate;
  443. }
  444. static void remarkupvals (global_State *g) {
  445.   UpVal *uv;
  446.   for (uv = g->uvhead.u.l.next; uv != &g->uvhead; uv = uv->u.l.next) {
  447.     lua_assert(uv->u.l.next->u.l.prev == uv && uv->u.l.prev->u.l.next == uv);
  448.     if (isgray(obj2gco(uv)))
  449.       markvalue(g, uv->v);
  450.   }
  451. }
  452. static void atomic (lua_State *L) {
  453.   global_State *g = G(L);
  454.   size_t udsize;  /* total size of userdata to be finalized */
  455.   /* remark occasional upvalues of (maybe) dead threads */
  456.   remarkupvals(g);
  457.   /* traverse objects cautch by write barrier and by 'remarkupvals' */
  458.   propagateall(g);
  459.   /* remark weak tables */
  460.   g->gray = g->weak;
  461.   g->weak = NULL;
  462.   lua_assert(!iswhite(obj2gco(g->mainthread)));
  463.   markobject(g, L);  /* mark running thread */
  464.   markmt(g);  /* mark basic metatables (again) */
  465.   propagateall(g);
  466.   /* remark gray again */
  467.   g->gray = g->grayagain;
  468.   g->grayagain = NULL;
  469.   propagateall(g);
  470.   udsize = luaC_separateudata(L, 0);  /* separate userdata to be finalized */
  471.   marktmu(g);  /* mark `preserved' userdata */
  472.   propagateall(g);  /* remark, to propagate `preserveness' */
  473.   cleartable(g->weak);  /* remove collected objects from weak tables */
  474.   /* flip current white */
  475.   g->currentwhite = cast_byte(otherwhite(g));
  476.   g->sweepstrgc = 0;
  477.   g->sweepgc = &g->rootgc;
  478.   g->gcstate = GCSsweepstring;
  479.   g->estimate = g->totalbytes - udsize;  /* first estimate */
  480. }
  481. static l_mem singlestep (lua_State *L) {
  482.   global_State *g = G(L);
  483.   /*lua_checkmemory(L);*/
  484.   switch (g->gcstate) {
  485.     case GCSpause: {
  486.       markroot(L);  /* start a new collection */
  487.       return 0;
  488.     }
  489.     case GCSpropagate: {
  490.       if (g->gray)
  491.         return propagatemark(g);
  492.       else {  /* no more `gray' objects */
  493.         atomic(L);  /* finish mark phase */
  494.         return 0;
  495.       }
  496.     }
  497.     case GCSsweepstring: {
  498.       lu_mem old = g->totalbytes;
  499.       sweepwholelist(L, &g->strt.hash[g->sweepstrgc++]);
  500.       if (g->sweepstrgc >= g->strt.size)  /* nothing more to sweep? */
  501.         g->gcstate = GCSsweep;  /* end sweep-string phase */
  502.       lua_assert(old >= g->totalbytes);
  503.       g->estimate -= old - g->totalbytes;
  504.       return GCSWEEPCOST;
  505.     }
  506.     case GCSsweep: {
  507.       lu_mem old = g->totalbytes;
  508.       g->sweepgc = sweeplist(L, g->sweepgc, GCSWEEPMAX);
  509.       if (*g->sweepgc == NULL) {  /* nothing more to sweep? */
  510.         checkSizes(L);
  511.         g->gcstate = GCSfinalize;  /* end sweep phase */
  512.       }
  513.       lua_assert(old >= g->totalbytes);
  514.       g->estimate -= old - g->totalbytes;
  515.       return GCSWEEPMAX*GCSWEEPCOST;
  516.     }
  517.     case GCSfinalize: {
  518.       if (g->tmudata) {
  519.         GCTM(L);
  520.         return GCFINALIZECOST;
  521.       }
  522.       else {
  523.         g->gcstate = GCSpause;  /* end collection */
  524.         g->gcdept = 0;
  525.         return 0;
  526.       }
  527.     }
  528.     default: lua_assert(0); return 0;
  529.   }
  530. }
  531. void luaC_step (lua_State *L) {
  532.   global_State *g = G(L);
  533.   l_mem lim = (GCSTEPSIZE/100) * g->gcstepmul;
  534.   if (lim == 0)
  535.     lim = (MAX_LUMEM-1)/2;  /* no limit */
  536.   g->gcdept += g->totalbytes - g->GCthreshold;
  537.   do {
  538.     lim -= singlestep(L);
  539.     if (g->gcstate == GCSpause)
  540.       break;
  541.   } while (lim > 0);
  542.   if (g->gcstate != GCSpause) {
  543.     if (g->gcdept < GCSTEPSIZE)
  544.       g->GCthreshold = g->totalbytes + GCSTEPSIZE;  /* - lim/g->gcstepmul;*/
  545.     else {
  546.       g->gcdept -= GCSTEPSIZE;
  547.       g->GCthreshold = g->totalbytes;
  548.     }
  549.   }
  550.   else {
  551.     lua_assert(g->totalbytes >= g->estimate);
  552.     setthreshold(g);
  553.   }
  554. }
  555. void luaC_fullgc (lua_State *L) {
  556.   global_State *g = G(L);
  557.   if (g->gcstate <= GCSpropagate) {
  558.     /* reset sweep marks to sweep all elements (returning them to white) */
  559.     g->sweepstrgc = 0;
  560.     g->sweepgc = &g->rootgc;
  561.     /* reset other collector lists */
  562.     g->gray = NULL;
  563.     g->grayagain = NULL;
  564.     g->weak = NULL;
  565.     g->gcstate = GCSsweepstring;
  566.   }
  567.   lua_assert(g->gcstate != GCSpause && g->gcstate != GCSpropagate);
  568.   /* finish any pending sweep phase */
  569.   while (g->gcstate != GCSfinalize) {
  570.     lua_assert(g->gcstate == GCSsweepstring || g->gcstate == GCSsweep);
  571.     singlestep(L);
  572.   }
  573.   markroot(L);
  574.   while (g->gcstate != GCSpause) {
  575.     singlestep(L);
  576.   }
  577.   setthreshold(g);
  578. }
  579. void luaC_barrierf (lua_State *L, GCObject *o, GCObject *v) {
  580.   global_State *g = G(L);
  581.   lua_assert(isblack(o) && iswhite(v) && !isdead(g, v) && !isdead(g, o));
  582.   lua_assert(g->gcstate != GCSfinalize && g->gcstate != GCSpause);
  583.   lua_assert(ttype(&o->gch) != LUA_TTABLE);
  584.   /* must keep invariant? */
  585.   if (g->gcstate == GCSpropagate)
  586.     reallymarkobject(g, v);  /* restore invariant */
  587.   else  /* don't mind */
  588.     makewhite(g, o);  /* mark as white just to avoid other barriers */
  589. }
  590. void luaC_barrierback (lua_State *L, Table *t) {
  591.   global_State *g = G(L);
  592.   GCObject *o = obj2gco(t);
  593.   lua_assert(isblack(o) && !isdead(g, o));
  594.   lua_assert(g->gcstate != GCSfinalize && g->gcstate != GCSpause);
  595.   black2gray(o);  /* make table gray (again) */
  596.   t->gclist = g->grayagain;
  597.   g->grayagain = o;
  598. }
  599. void luaC_link (lua_State *L, GCObject *o, lu_byte tt) {
  600.   global_State *g = G(L);
  601.   o->gch.next = g->rootgc;
  602.   g->rootgc = o;
  603.   o->gch.marked = luaC_white(g);
  604.   o->gch.tt = tt;
  605. }
  606. void luaC_linkupval (lua_State *L, UpVal *uv) {
  607.   global_State *g = G(L);
  608.   GCObject *o = obj2gco(uv);
  609.   o->gch.next = g->rootgc;  /* link upvalue into `rootgc' list */
  610.   g->rootgc = o;
  611.   if (isgray(o)) { 
  612.     if (g->gcstate == GCSpropagate) {
  613.       gray2black(o);  /* closed upvalues need barrier */
  614.       luaC_barrier(L, uv, uv->v);
  615.     }
  616.     else {  /* sweep phase: sweep it (turning it into white) */
  617.       makewhite(g, o);
  618.       lua_assert(g->gcstate != GCSfinalize && g->gcstate != GCSpause);
  619.     }
  620.   }
  621. }