root/src/lua/src/lgc.c

Revision 22d1941d0ca5ba7027cdfa51ce34bd1d8fb1931e, 19.6 kB (checked in by Theo Schlossnagle <jesus@omniti.com>, 10 years ago)

take the version out... it is what it is

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