自学教程：C++ sweepwholelist函数代码示例

void luaC_freeall (lua_State *L) {  global_State *g = G(L);  int i;  g->currentwhite = WHITEBITS | bitmask(SFIXEDBIT);  /* mask to collect all elements */  sweepwholelist(L, &g->rootgc);  for (i = 0; i < g->strt.size; i++)  /* free all string lists */    sweepwholelist(L, &g->strt.hash[i]);}

void luaC_freeallobjects (lua_State *L) {  global_State *g = G(L);  separatetobefnz(g, 1);  /* separate all objects with finalizers */  lua_assert(g->finobj == NULL);  callallpendingfinalizers(L, 0);  lua_assert(g->tobefnz == NULL);  g->currentwhite = WHITEBITS; /* this "white" makes all objects look dead */  g->gckind = KGC_NORMAL;  sweepwholelist(L, &g->finobj);  sweepwholelist(L, &g->allgc);  sweepwholelist(L, &g->fixedgc);  /* collect fixed objects */  lua_assert(g->strt.nuse == 0);}

void luaC_freeallobjects (lua_State *L) {	global_State *g = G(L);	int i;	separatetobefnz(L, 1);  /* separate all objects with finalizers */	lua_assert(g->finobj == NULL);	callallpendingfinalizers(L, 0);	g->currentwhite = WHITEBITS; /* this "white" makes all objects look dead */	g->gckind = KGC_NORMAL;	sweepwholelist(L, &g->finobj);  /* finalizers can create objs. in 'finobj' */	sweepwholelist(L, &g->allgc);	for (i = 0; i < g->strt.size; i++)  /* free all string lists */	sweepwholelist(L, &g->strt.hash[i]);	lua_assert(g->strt.nuse == 0);}

static l_mem singlestep (lua_State *L) {  global_State *g = G(L);  switch (g->gcstate) {    case GCSpause: {      if (!isgenerational(g))        markroot(g);  /* start a new collection */      /* in any case, root must be marked */      lua_assert(!iswhite(obj2gco(g->mainthread))              && !iswhite(gcvalue(&g->l_registry)));      g->gcstate = GCSpropagate;      return GCROOTCOST;    }    case GCSpropagate: {      if (g->gray)        return propagatemark(g);      else {  /* no more `gray' objects */        g->gcstate = GCSatomic;  /* finish mark phase */        atomic(L);        return GCATOMICCOST;      }    }    case GCSsweepstring: {      if (g->sweepstrgc < g->strt.size) {        sweepwholelist(L, &g->strt.hash[g->sweepstrgc++]);        return GCSWEEPCOST;      }      else {  /* no more strings to sweep */        g->sweepgc = &g->finobj;  /* prepare to sweep finalizable objects */        g->gcstate = GCSsweepudata;        return 0;      }    }    case GCSsweepudata: {      if (*g->sweepgc) {        g->sweepgc = sweeplist(L, g->sweepgc, GCSWEEPMAX);        return GCSWEEPMAX*GCSWEEPCOST;      }      else {        g->sweepgc = &g->allgc;  /* go to next phase */        g->gcstate = GCSsweep;        return GCSWEEPCOST;      }    }    case GCSsweep: {      if (*g->sweepgc) {        g->sweepgc = sweeplist(L, g->sweepgc, GCSWEEPMAX);        return GCSWEEPMAX*GCSWEEPCOST;      }      else {        /* sweep main thread */        GCObject *mt = obj2gco(g->mainthread);        sweeplist(L, &mt, 1);        checkSizes(L);        g->gcstate = GCSpause;  /* finish collection */        return GCSWEEPCOST;      }    }    default: lua_assert(0); return 0;  }}

/*** sweep the (open) upvalues of a thread and resize its stack and** list of call-info structures.*/static void sweepthread (lua_State *L, lua_State *L1) {	if (L1->stack == NULL) return;  /* stack not completely built yet */	sweepwholelist(L, &L1->openupval);  /* sweep open upvalues */	luaE_freeCI(L1);  /* free extra CallInfo slots */	/* should not change the stack during an emergency gc cycle */	if (G(L)->gckind != KGC_EMERGENCY)	luaD_shrinkstack(L1);}

static void sweepstrstep (global_State *g, lua_State *L) {  lu_mem old = g->totalbytes;  sweepwholelist(L, &g->strt.hash[g->sweepstrgc++]);  if (g->sweepstrgc >= g->strt.size)  /* nothing more to sweep? */    g->gcstate = GCSsweep;  /* end sweep-string phase */  lua_assert(old >= g->totalbytes);  g->estimate -= old - g->totalbytes;}

static l_mem singlestep(lua_State *L) {    global_State *g = G(L);    /*lua_checkmemory(L);*/    switch (g->gcstate) {    case GCSpause: {        markroot(L); /* start a new collection */        return 0;    }    case GCSpropagate: {        if (g->gray)            return propagatemark(g);        else { /* no more `gray' objects */            atomic(L); /* finish mark phase */            return 0;        }    }    case GCSsweepstring: {        lu_mem old = g->totalbytes;        sweepwholelist(L, &g->strt.hash[g->sweepstrgc++]);        if (g->sweepstrgc >= g->strt.size) /* nothing more to sweep? */            g->gcstate = GCSsweep; /* end sweep-string phase */        lua_assert(old >= g->totalbytes);        g->estimate -= old - g->totalbytes;        return GCSWEEPCOST;    }    case GCSsweep: {        lu_mem old = g->totalbytes;        g->sweepgc = sweeplist(L, g->sweepgc, GCSWEEPMAX);        if (*g->sweepgc == NULL) { /* nothing more to sweep? */            checkSizes(L);            g->gcstate = GCSfinalize; /* end sweep phase */        }        lua_assert(old >= g->totalbytes);        g->estimate -= old - g->totalbytes;        return GCSWEEPMAX * GCSWEEPCOST;    }    case GCSfinalize: {        if (g->tmudata) {            GCTM(L);            if (g->estimate > GCFINALIZECOST)                g->estimate -= GCFINALIZECOST;            return GCFINALIZECOST;        } else {            g->gcstate = GCSpause; /* end collection */            g->gcdept = 0;            return 0;        }    }    default:        lua_assert(0);        return 0;    }}

// lua的gc状态机，执行顺序和下面的状态的从大到小开始一致static l_mem singlestep (lua_State *L) {  global_State *g = G(L);  /*lua_checkmemory(L);*/  switch (g->gcstate) {    case GCSpause: {// 初始状态      markroot(L);  /* start a new collection */// 主要就是标记主线程对象(也就是从白色染成灰色)      return 0;    }    case GCSpropagate: {// 这个状态也是一个标记过程，并且会被进入多次，也就是分布迭代      if (g->gray)// 如果gray对象一直存在的话，反复调用propagatemark函数，等所有的gray对象都被标记了，就会进入atomic函数处理        return propagatemark(g);      else {  /* no more `gray' objects */        atomic(L);  /* finish mark phase */// 原子操作        return 0;      }    }    case GCSsweepstring: {// 清理字符串的阶段      lu_mem old = g->totalbytes;      sweepwholelist(L, &g->strt.hash[g->sweepstrgc++]);      if (g->sweepstrgc >= g->strt.size)  /* nothing more to sweep? */        g->gcstate = GCSsweep;  /* end sweep-string phase */      lua_assert(old >= g->totalbytes);      g->estimate -= old - g->totalbytes;      return GCSWEEPCOST;    }    case GCSsweep: {      lu_mem old = g->totalbytes;      g->sweepgc = sweeplist(L, g->sweepgc, GCSWEEPMAX);      if (*g->sweepgc == NULL) {  /* nothing more to sweep? */        checkSizes(L);        g->gcstate = GCSfinalize;  /* end sweep phase */      }      lua_assert(old >= g->totalbytes);      g->estimate -= old - g->totalbytes;      return GCSWEEPMAX*GCSWEEPCOST;    }    case GCSfinalize: {      if (g->tmudata) {        GCTM(L);        if (g->estimate > GCFINALIZECOST)          g->estimate -= GCFINALIZECOST;        return GCFINALIZECOST;      }      else {        g->gcstate = GCSpause;  /* end collection */        g->gcdept = 0;        return 0;      }    }    default: lua_assert(0); return 0;  }}

static lu_mem singlestep (lua_State *L) {	global_State *g = G(L);	switch (g->gcstate) {	case GCSpause: {		/* start to count memory traversed */		g->GCmemtrav = g->strt.size * sizeof(GCObject*);		lua_assert(!isgenerational(g));		restartcollection(g);		g->gcstate = GCSpropagate;		return g->GCmemtrav;	}	case GCSpropagate: {		if (g->gray) {		lu_mem oldtrav = g->GCmemtrav;		propagatemark(g);		return g->GCmemtrav - oldtrav;  /* memory traversed in this step */		}		else {  /* no more `gray' objects */		lu_mem work;		int sw;		g->gcstate = GCSatomic;  /* finish mark phase */		g->GCestimate = g->GCmemtrav;  /* save what was counted */;		work = atomic(L);  /* add what was traversed by 'atomic' */		g->GCestimate += work;  /* estimate of total memory traversed */		sw = entersweep(L);		return work + sw * GCSWEEPCOST;		}	}	case GCSsweepstring: {		int i;		for (i = 0; i < GCSWEEPMAX && g->sweepstrgc + i < g->strt.size; i++)		sweepwholelist(L, &g->strt.hash[g->sweepstrgc + i]);		g->sweepstrgc += i;		if (g->sweepstrgc >= g->strt.size)  /* no more strings to sweep? */		g->gcstate = GCSsweepudata;		return i * GCSWEEPCOST;	}	case GCSsweepudata: {		if (g->sweepfin) {		g->sweepfin = sweeplist(L, g->sweepfin, GCSWEEPMAX);		return GCSWEEPMAX*GCSWEEPCOST;		}		else {		g->gcstate = GCSsweep;		return 0;		}	}	case GCSsweep: {		if (g->sweepgc) {		g->sweepgc = sweeplist(L, g->sweepgc, GCSWEEPMAX);		return GCSWEEPMAX*GCSWEEPCOST;		}		else {		/* sweep main thread */		GCObject *mt = obj2gco(g->mainthread);		sweeplist(L, &mt, 1);		checkSizes(L);		g->gcstate = GCSpause;  /* finish collection */		return GCSWEEPCOST;		}	}	default: lua_assert(0); return 0;	}}

static void cleartable (lua_State *L, GCObject *l) {#elsestatic void cleartable (GCObject *l) {#endif /* LUA_REFCOUNT */  while (l) {    Table *h = gco2h(l);    int i = h->sizearray;    lua_assert(testbit(h->marked, VALUEWEAKBIT) ||               testbit(h->marked, KEYWEAKBIT));    if (testbit(h->marked, VALUEWEAKBIT)) {      while (i--) {        TValue *o = &h->array[i];#if LUA_REFCOUNT        if (iscleared(o, 0)) { /* value was collected? */          if (iscollectable(o))            o->value.gc->gch.ref--;          setnilvalue2n(l, o);  /* remove value */        }#else        if (iscleared(o, 0))  /* value was collected? */          setnilvalue(o);  /* remove value */#endif /* LUA_REFCOUNT */      }    }    i = sizenode(h);    while (i--) {      Node *n = gnode(h, i);      if (!ttisnil(gval(n)) &&  /* non-empty entry? */          (iscleared(key2tval(n), 1) || iscleared(gval(n), 0))) {#if LUA_REFCOUNT        if (iscollectable(gval(n)))          gval(n)->value.gc->gch.ref--;        setnilvalue2n(L, gval(n));  /* remove value ... */#else        setnilvalue(gval(n));  /* remove value ... */#endif /* LUA_REFCOUNT */        removeentry(n);  /* remove entry from table */      }    }    l = h->gclist;  }}static void freeobj (lua_State *L, GCObject *o) {  switch (o->gch.tt) {    case LUA_TPROTO: luaF_freeproto(L, gco2p(o)); break;    case LUA_TFUNCTION: luaF_freeclosure(L, gco2cl(o)); break;    case LUA_TUPVAL: luaF_freeupval(L, gco2uv(o)); break;    case LUA_TTABLE: luaH_free(L, gco2h(o)); break;    case LUA_TTHREAD: {      lua_assert(gco2th(o) != L && gco2th(o) != G(L)->mainthread);      luaE_freethread(L, gco2th(o));      break;    }    case LUA_TSTRING: {      G(L)->strt.nuse--;      luaM_freemem(L, o, sizestring(gco2ts(o)));      break;    }#if LUA_WIDESTRING    case LUA_TWSTRING: {      G(L)->strt.nuse--;      luaM_freemem(L, o, sizestring(gco2ts(o)));      break;    }#endif /* LUA_WIDESTRING */    case LUA_TUSERDATA: {      luaM_freemem(L, o, sizeudata(gco2u(o)));      break;    }    default: lua_assert(0);  }}#define sweepwholelist(L,p)	sweeplist(L,p,MAX_LUMEM)static GCObject **sweeplist (lua_State *L, GCObject **p, lu_mem count) {  GCObject *curr;  global_State *g = G(L);  int deadmask = otherwhite(g);  while ((curr = *p) != NULL && count-- > 0) {    if (curr->gch.tt == LUA_TTHREAD)  /* sweep open upvalues of each thread */      sweepwholelist(L, &gco2th(curr)->openupval);    if ((curr->gch.marked ^ WHITEBITS) & deadmask) {  /* not dead? */      lua_assert(!isdead(g, curr) || testbit(curr->gch.marked, FIXEDBIT));      makewhite(g, curr);  /* make it white (for next cycle) */      p = &curr->gch.next;    }    else {  /* must erase `curr' */      lua_assert(isdead(g, curr) || deadmask == bitmask(SFIXEDBIT));#if LUA_REFCOUNT      if (curr->gch.prev)        curr->gch.prev->gch.next = curr->gch.next;      if (curr->gch.next)        curr->gch.next->gch.prev = (GCObject*)p;#endif /* LUA_REFCOUNT *///.........这里部分代码省略.........