lgc.c 37 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197
  1. /*
  2. ** $Id: lgc.c,v 2.215.1.2 2017/08/31 16:15:27 roberto Exp $
  3. ** Garbage Collector
  4. ** See Copyright Notice in lua.h
  5. */
  6. #define lgc_c
  7. #define LUA_CORE
  8. #include "lprefix.h"
  9. #include <string.h>
  10. #include "lua.h"
  11. #include "ldebug.h"
  12. #include "ldo.h"
  13. #include "lfunc.h"
  14. #include "lgc.h"
  15. #include "lmem.h"
  16. #include "lobject.h"
  17. #include "lstate.h"
  18. #include "lstring.h"
  19. #include "ltable.h"
  20. #include "ltm.h"
  21. /*
  22. ** internal state for collector while inside the atomic phase. The
  23. ** collector should never be in this state while running regular code.
  24. */
  25. #define GCSinsideatomic (GCSpause + 1)
  26. /*
  27. ** cost of sweeping one element (the size of a small object divided
  28. ** by some adjust for the sweep speed)
  29. */
  30. #define GCSWEEPCOST ((sizeof(TString) + 4) / 4)
  31. /* maximum number of elements to sweep in each single step */
  32. #define GCSWEEPMAX (cast_int((GCSTEPSIZE / GCSWEEPCOST) / 4))
  33. /* cost of calling one finalizer */
  34. #define GCFINALIZECOST GCSWEEPCOST
  35. /*
  36. ** macro to adjust 'stepmul': 'stepmul' is actually used like
  37. ** 'stepmul / STEPMULADJ' (value chosen by tests)
  38. */
  39. #define STEPMULADJ 200
  40. /*
  41. ** macro to adjust 'pause': 'pause' is actually used like
  42. ** 'pause / PAUSEADJ' (value chosen by tests)
  43. */
  44. #define PAUSEADJ 100
  45. /*
  46. ** 'makewhite' erases all color bits then sets only the current white
  47. ** bit
  48. */
  49. #define maskcolors (~(bitmask(BLACKBIT) | WHITEBITS))
  50. #define makewhite(g,x) \
  51. (x->marked = cast_byte((x->marked & maskcolors) | luaC_white(g)))
  52. #define white2gray(x) resetbits(x->marked, WHITEBITS)
  53. #define black2gray(x) resetbit(x->marked, BLACKBIT)
  54. #define valiswhite(x) (iscollectable(x) && iswhite(gcvalue(x)))
  55. #define checkdeadkey(n) lua_assert(!ttisdeadkey(gkey(n)) || ttisnil(gval(n)))
  56. #define checkconsistency(obj) \
  57. lua_longassert(!iscollectable(obj) || righttt(obj))
  58. #define markvalue(g,o) { checkconsistency(o); \
  59. if (valiswhite(o)) reallymarkobject(g,gcvalue(o)); }
  60. #define markobject(g,t) { if (iswhite(t)) reallymarkobject(g, obj2gco(t)); }
  61. /*
  62. ** mark an object that can be NULL (either because it is really optional,
  63. ** or it was stripped as debug info, or inside an uncompleted structure)
  64. */
  65. #define markobjectN(g,t) { if (t) markobject(g,t); }
  66. static void reallymarkobject (global_State *g, GCObject *o);
  67. /*
  68. ** {======================================================
  69. ** Generic functions
  70. ** =======================================================
  71. */
  72. /*
  73. ** one after last element in a hash array
  74. */
  75. #define gnodelast(h) gnode(h, cast(size_t, sizenode(h)))
  76. /*
  77. ** link collectable object 'o' into list pointed by 'p'
  78. */
  79. #define linkgclist(o,p) ((o)->gclist = (p), (p) = obj2gco(o))
  80. /*
  81. ** If key is not marked, mark its entry as dead. This allows key to be
  82. ** collected, but keeps its entry in the table. A dead node is needed
  83. ** when Lua looks up for a key (it may be part of a chain) and when
  84. ** traversing a weak table (key might be removed from the table during
  85. ** traversal). Other places never manipulate dead keys, because its
  86. ** associated nil value is enough to signal that the entry is logically
  87. ** empty.
  88. */
  89. static void removeentry (Node *n) {
  90. lua_assert(ttisnil(gval(n)));
  91. if (valiswhite(gkey(n)))
  92. setdeadvalue(wgkey(n)); /* unused and unmarked key; remove it */
  93. }
  94. /*
  95. ** tells whether a key or value can be cleared from a weak
  96. ** table. Non-collectable objects are never removed from weak
  97. ** tables. Strings behave as 'values', so are never removed too. for
  98. ** other objects: if really collected, cannot keep them; for objects
  99. ** being finalized, keep them in keys, but not in values
  100. */
  101. static int iscleared (global_State *g, const TValue *o) {
  102. if (!iscollectable(o)) return 0;
  103. else if (ttisstring(o)) {
  104. markobject(g, tsvalue(o)); /* strings are 'values', so are never weak */
  105. return 0;
  106. }
  107. else return iswhite(gcvalue(o));
  108. }
  109. /*
  110. ** barrier that moves collector forward, that is, mark the white object
  111. ** being pointed by a black object. (If in sweep phase, clear the black
  112. ** object to white [sweep it] to avoid other barrier calls for this
  113. ** same object.)
  114. */
  115. void luaC_barrier_ (lua_State *L, GCObject *o, GCObject *v) {
  116. global_State *g = G(L);
  117. lua_assert(isblack(o) && iswhite(v) && !isdead(g, v) && !isdead(g, o));
  118. if (keepinvariant(g)) /* must keep invariant? */
  119. reallymarkobject(g, v); /* restore invariant */
  120. else { /* sweep phase */
  121. lua_assert(issweepphase(g));
  122. makewhite(g, o); /* mark main obj. as white to avoid other barriers */
  123. }
  124. }
  125. /*
  126. ** barrier that moves collector backward, that is, mark the black object
  127. ** pointing to a white object as gray again.
  128. */
  129. void luaC_barrierback_ (lua_State *L, Table *t) {
  130. global_State *g = G(L);
  131. lua_assert(isblack(t) && !isdead(g, t));
  132. black2gray(t); /* make table gray (again) */
  133. linkgclist(t, g->grayagain);
  134. }
  135. /*
  136. ** barrier for assignments to closed upvalues. Because upvalues are
  137. ** shared among closures, it is impossible to know the color of all
  138. ** closures pointing to it. So, we assume that the object being assigned
  139. ** must be marked.
  140. */
  141. void luaC_upvalbarrier_ (lua_State *L, UpVal *uv) {
  142. global_State *g = G(L);
  143. GCObject *o = gcvalue(uv->v);
  144. lua_assert(!upisopen(uv)); /* ensured by macro luaC_upvalbarrier */
  145. if (keepinvariant(g))
  146. markobject(g, o);
  147. }
  148. void luaC_fix (lua_State *L, GCObject *o) {
  149. global_State *g = G(L);
  150. lu_byte marked = getmarked(o);
  151. if((marked & WHITEBITS)==0 || (marked & bitmask(LFSBIT)))
  152. return; /* no point in trying to fix an object in LFS */
  153. lua_assert(g->allgc == o); /* object must be 1st in 'allgc' list! */
  154. white2gray(o); /* they will be gray forever */
  155. g->allgc = o->next; /* remove object from 'allgc' list */
  156. o->next = g->fixedgc; /* link it to 'fixedgc' list */
  157. g->fixedgc = o;
  158. }
  159. /*
  160. ** create a new collectable object (with given type and size) and link
  161. ** it to 'allgc' list.
  162. */
  163. GCObject *luaC_newobj (lua_State *L, int tt, size_t sz) {
  164. global_State *g = G(L);
  165. GCObject *o = cast(GCObject *, luaM_newobject(L, novariant(tt), sz));
  166. o->marked = luaC_white(g);
  167. o->tt = tt;
  168. o->next = g->allgc;
  169. g->allgc = o;
  170. return o;
  171. }
  172. /* }====================================================== */
  173. /*
  174. ** {======================================================
  175. ** Mark functions
  176. ** =======================================================
  177. */
  178. /*
  179. ** mark an object. Userdata, strings, and closed upvalues are visited
  180. ** and turned black here. Other objects are marked gray and added
  181. ** to appropriate list to be visited (and turned black) later. (Open
  182. ** upvalues are already linked in 'headuv' list.)
  183. */
  184. static void reallymarkobject (global_State *g, GCObject *o) {
  185. reentry:
  186. if (isLFSobj(o))
  187. return;
  188. /* DEBUG: Catch any attempt to mark an unmarked LFS object */
  189. lua_assert((unsigned)(((char *) o)-((char *) g->l_LFS)) > g->LFSsize);
  190. white2gray(o);
  191. switch (gettt(o)) {
  192. case LUA_TSHRSTR: {
  193. gray2black(o);
  194. g->GCmemtrav += sizelstring(gco2ts(o)->shrlen);
  195. break;
  196. }
  197. case LUA_TLNGSTR: {
  198. gray2black(o);
  199. g->GCmemtrav += sizelstring(gco2ts(o)->u.lnglen);
  200. break;
  201. }
  202. case LUA_TUSERDATA: {
  203. TValue uvalue;
  204. markobjectN(g, gco2u(o)->metatable); /* mark its metatable */
  205. gray2black(o);
  206. g->GCmemtrav += sizeudata(gco2u(o));
  207. getuservalue(g->mainthread, gco2u(o), &uvalue);
  208. if (valiswhite(&uvalue)) { /* markvalue(g, &uvalue); */
  209. o = gcvalue(&uvalue);
  210. goto reentry;
  211. }
  212. break;
  213. }
  214. case LUA_TLCL: {
  215. linkgclist(gco2lcl(o), g->gray);
  216. break;
  217. }
  218. case LUA_TCCL: {
  219. linkgclist(gco2ccl(o), g->gray);
  220. break;
  221. }
  222. case LUA_TTABLE: {
  223. linkgclist(gco2t(o), g->gray);
  224. break;
  225. }
  226. case LUA_TTHREAD: {
  227. linkgclist(gco2th(o), g->gray);
  228. break;
  229. }
  230. case LUA_TPROTO: {
  231. linkgclist(gco2p(o), g->gray);
  232. break;
  233. }
  234. default: lua_assert(0); break;
  235. }
  236. }
  237. /*
  238. ** mark metamethods for basic types
  239. */
  240. static void markmt (global_State *g) {
  241. int i;
  242. for (i=0; i < LUA_NUMTAGS; i++)
  243. markobjectN(g, g->mt[i]);
  244. }
  245. /*
  246. ** mark all objects in list of being-finalized
  247. */
  248. static void markbeingfnz (global_State *g) {
  249. GCObject *o;
  250. for (o = g->tobefnz; o != NULL; o = o->next)
  251. markobject(g, o);
  252. }
  253. /*
  254. ** Mark all values stored in marked open upvalues from non-marked threads.
  255. ** (Values from marked threads were already marked when traversing the
  256. ** thread.) Remove from the list threads that no longer have upvalues and
  257. ** not-marked threads.
  258. */
  259. static void remarkupvals (global_State *g) {
  260. lua_State *thread;
  261. lua_State **p = &g->twups;
  262. while ((thread = *p) != NULL) {
  263. lua_assert(!isblack(thread)); /* threads are never black */
  264. if (isgray(thread) && thread->openupval != NULL)
  265. p = &thread->twups; /* keep marked thread with upvalues in the list */
  266. else { /* thread is not marked or without upvalues */
  267. UpVal *uv;
  268. *p = thread->twups; /* remove thread from the list */
  269. thread->twups = thread; /* mark that it is out of list */
  270. for (uv = thread->openupval; uv != NULL; uv = uv->u.open.next) {
  271. if (uv->u.open.touched) {
  272. markvalue(g, uv->v); /* remark upvalue's value */
  273. uv->u.open.touched = 0;
  274. }
  275. }
  276. }
  277. }
  278. }
  279. /*
  280. ** mark root set and reset all gray lists, to start a new collection
  281. */
  282. static void restartcollection (global_State *g) {
  283. g->gray = g->grayagain = NULL;
  284. g->weak = g->allweak = g->ephemeron = NULL;
  285. markobject(g, g->mainthread);
  286. markvalue(g, &g->l_registry);
  287. markmt(g);
  288. markbeingfnz(g); /* mark any finalizing object left from previous cycle */
  289. }
  290. /* }====================================================== */
  291. /*
  292. ** {======================================================
  293. ** Traverse functions
  294. ** =======================================================
  295. */
  296. /*
  297. ** Traverse a table with weak values and link it to proper list. During
  298. ** propagate phase, keep it in 'grayagain' list, to be revisited in the
  299. ** atomic phase. In the atomic phase, if table has any white value,
  300. ** put it in 'weak' list, to be cleared.
  301. */
  302. static void traverseweakvalue (global_State *g, Table *h) {
  303. Node *n, *limit = gnodelast(h);
  304. /* if there is array part, assume it may have white values (it is not
  305. worth traversing it now just to check) */
  306. int hasclears = (h->sizearray > 0);
  307. for (n = gnode(h, 0); n < limit; n++) { /* traverse hash part */
  308. checkdeadkey(n);
  309. if (ttisnil(gval(n))) /* entry is empty? */
  310. removeentry(n); /* remove it */
  311. else {
  312. lua_assert(!ttisnil(gkey(n)));
  313. markvalue(g, gkey(n)); /* mark key */
  314. if (!hasclears && iscleared(g, gval(n))) /* is there a white value? */
  315. hasclears = 1; /* table will have to be cleared */
  316. }
  317. }
  318. if (g->gcstate == GCSpropagate)
  319. linkgclist(h, g->grayagain); /* must retraverse it in atomic phase */
  320. else if (hasclears)
  321. linkgclist(h, g->weak); /* has to be cleared later */
  322. }
  323. /*
  324. ** Traverse an ephemeron table and link it to proper list. Returns true
  325. ** iff any object was marked during this traversal (which implies that
  326. ** convergence has to continue). During propagation phase, keep table
  327. ** in 'grayagain' list, to be visited again in the atomic phase. In
  328. ** the atomic phase, if table has any white->white entry, it has to
  329. ** be revisited during ephemeron convergence (as that key may turn
  330. ** black). Otherwise, if it has any white key, table has to be cleared
  331. ** (in the atomic phase).
  332. */
  333. static int traverseephemeron (global_State *g, Table *h) {
  334. int marked = 0; /* true if an object is marked in this traversal */
  335. int hasclears = 0; /* true if table has white keys */
  336. int hasww = 0; /* true if table has entry "white-key -> white-value" */
  337. Node *n, *limit = gnodelast(h);
  338. unsigned int i;
  339. /* traverse array part */
  340. for (i = 0; i < h->sizearray; i++) {
  341. if (valiswhite(&h->array[i])) {
  342. marked = 1;
  343. reallymarkobject(g, gcvalue(&h->array[i]));
  344. }
  345. }
  346. /* traverse hash part */
  347. for (n = gnode(h, 0); n < limit; n++) {
  348. checkdeadkey(n);
  349. if (ttisnil(gval(n))) /* entry is empty? */
  350. removeentry(n); /* remove it */
  351. else if (iscleared(g, gkey(n))) { /* key is not marked (yet)? */
  352. hasclears = 1; /* table must be cleared */
  353. if (valiswhite(gval(n))) /* value not marked yet? */
  354. hasww = 1; /* white-white entry */
  355. }
  356. else if (valiswhite(gval(n))) { /* value not marked yet? */
  357. marked = 1;
  358. reallymarkobject(g, gcvalue(gval(n))); /* mark it now */
  359. }
  360. }
  361. /* link table into proper list */
  362. if (g->gcstate == GCSpropagate)
  363. linkgclist(h, g->grayagain); /* must retraverse it in atomic phase */
  364. else if (hasww) /* table has white->white entries? */
  365. linkgclist(h, g->ephemeron); /* have to propagate again */
  366. else if (hasclears) /* table has white keys? */
  367. linkgclist(h, g->allweak); /* may have to clean white keys */
  368. return marked;
  369. }
  370. static void traversestrongtable (global_State *g, Table *h) {
  371. Node *n, *limit = gnodelast(h);
  372. unsigned int i;
  373. for (i = 0; i < h->sizearray; i++) /* traverse array part */
  374. markvalue(g, &h->array[i]);
  375. for (n = gnode(h, 0); n < limit; n++) { /* traverse hash part */
  376. checkdeadkey(n);
  377. if (ttisnil(gval(n))) /* entry is empty? */
  378. removeentry(n); /* remove it */
  379. else {
  380. lua_assert(!ttisnil(gkey(n)));
  381. markvalue(g, gkey(n)); /* mark key */
  382. markvalue(g, gval(n)); /* mark value */
  383. }
  384. }
  385. }
  386. static lu_mem traversetable (global_State *g, Table *h) {
  387. const char *weakkey, *weakvalue;
  388. const TValue *mode = gfasttm(g, h->metatable, TM_MODE);
  389. markobjectN(g, h->metatable);
  390. if (mode && ttisstring(mode) && /* is there a weak mode? */
  391. ((weakkey = strchr(svalue(mode), 'k')),
  392. (weakvalue = strchr(svalue(mode), 'v')),
  393. (weakkey || weakvalue))) { /* is really weak? */
  394. black2gray(h); /* keep table gray */
  395. if (!weakkey) /* strong keys? */
  396. traverseweakvalue(g, h);
  397. else if (!weakvalue) /* strong values? */
  398. traverseephemeron(g, h);
  399. else /* all weak */
  400. linkgclist(h, g->allweak); /* nothing to traverse now */
  401. }
  402. else /* not weak */
  403. traversestrongtable(g, h);
  404. return sizeof(Table) + sizeof(TValue) * h->sizearray +
  405. sizeof(Node) * cast(size_t, allocsizenode(h));
  406. }
  407. /*
  408. ** Traverse a prototype. (While a prototype is being build, its
  409. ** arrays can be larger than needed; the extra slots are filled with
  410. ** NULL, so the use of 'markobjectN')
  411. */
  412. static int traverseproto (global_State *g, Proto *f) {
  413. int i;
  414. markobjectN(g, f->source);
  415. for (i = 0; i < f->sizek; i++) /* mark literals */
  416. markvalue(g, &f->k[i]);
  417. for (i = 0; i < f->sizeupvalues; i++) /* mark upvalue names */
  418. markobjectN(g, f->upvalues[i].name);
  419. for (i = 0; i < f->sizep; i++) /* mark nested protos */
  420. markobjectN(g, f->p[i]);
  421. for (i = 0; i < f->sizelocvars; i++) /* mark local-variable names */
  422. markobjectN(g, f->locvars[i].varname);
  423. return sizeof(Proto) + sizeof(Instruction) * f->sizecode +
  424. sizeof(Proto *) * f->sizep +
  425. sizeof(TValue) * f->sizek +
  426. sizeof(char) * f->sizelineinfo +
  427. sizeof(LocVar) * f->sizelocvars +
  428. sizeof(Upvaldesc) * f->sizeupvalues;
  429. }
  430. static lu_mem traverseCclosure (global_State *g, CClosure *cl) {
  431. int i;
  432. for (i = 0; i < cl->nupvalues; i++) /* mark its upvalues */
  433. markvalue(g, &cl->upvalue[i]);
  434. return sizeCclosure(cl->nupvalues);
  435. }
  436. /*
  437. ** open upvalues point to values in a thread, so those values should
  438. ** be marked when the thread is traversed except in the atomic phase
  439. ** (because then the value cannot be changed by the thread and the
  440. ** thread may not be traversed again)
  441. */
  442. static lu_mem traverseLclosure (global_State *g, LClosure *cl) {
  443. int i;
  444. if (!isLFSobj(cl->p))
  445. markobjectN(g, cl->p); /* mark its prototype */
  446. for (i = 0; i < cl->nupvalues; i++) { /* mark its upvalues */
  447. UpVal *uv = cl->upvals[i];
  448. if (uv != NULL) {
  449. if (upisopen(uv) && g->gcstate != GCSinsideatomic)
  450. uv->u.open.touched = 1; /* can be marked in 'remarkupvals' */
  451. else
  452. markvalue(g, uv->v);
  453. }
  454. }
  455. return sizeLclosure(cl->nupvalues);
  456. }
  457. static lu_mem traversethread (global_State *g, lua_State *th) {
  458. StkId o = th->stack;
  459. if (o == NULL)
  460. return 1; /* stack not completely built yet */
  461. lua_assert(g->gcstate == GCSinsideatomic ||
  462. th->openupval == NULL || isintwups(th));
  463. for (; o < th->top; o++) /* mark live elements in the stack */
  464. markvalue(g, o);
  465. if (g->gcstate == GCSinsideatomic) { /* final traversal? */
  466. StkId lim = th->stack + th->stacksize; /* real end of stack */
  467. for (; o < lim; o++) /* clear not-marked stack slice */
  468. setnilvalue(o);
  469. /* 'remarkupvals' may have removed thread from 'twups' list */
  470. if (!isintwups(th) && th->openupval != NULL) {
  471. th->twups = g->twups; /* link it back to the list */
  472. g->twups = th;
  473. }
  474. }
  475. else if (g->gckind != KGC_EMERGENCY)
  476. luaD_shrinkstack(th); /* do not change stack in emergency cycle */
  477. return (sizeof(lua_State) + sizeof(TValue) * th->stacksize +
  478. sizeof(CallInfo) * th->nci);
  479. }
  480. /*
  481. ** traverse one gray object, turning it to black (except for threads,
  482. ** which are always gray).
  483. */
  484. static void propagatemark (global_State *g) {
  485. lu_mem size;
  486. GCObject *o = g->gray;
  487. lua_assert(isgray(o));
  488. gray2black(o);
  489. switch (gettt(o)) {
  490. case LUA_TTABLE: {
  491. Table *h = gco2t(o);
  492. g->gray = h->gclist; /* remove from 'gray' list */
  493. size = traversetable(g, h);
  494. break;
  495. }
  496. case LUA_TLCL: {
  497. LClosure *cl = gco2lcl(o);
  498. g->gray = cl->gclist; /* remove from 'gray' list */
  499. size = traverseLclosure(g, cl);
  500. break;
  501. }
  502. case LUA_TCCL: {
  503. CClosure *cl = gco2ccl(o);
  504. g->gray = cl->gclist; /* remove from 'gray' list */
  505. size = traverseCclosure(g, cl);
  506. break;
  507. }
  508. case LUA_TTHREAD: {
  509. lua_State *th = gco2th(o);
  510. g->gray = th->gclist; /* remove from 'gray' list */
  511. linkgclist(th, g->grayagain); /* insert into 'grayagain' list */
  512. black2gray(o);
  513. size = traversethread(g, th);
  514. break;
  515. }
  516. case LUA_TPROTO: {
  517. Proto *p = gco2p(o);
  518. g->gray = p->gclist; /* remove from 'gray' list */
  519. size = traverseproto(g, p);
  520. break;
  521. }
  522. default: lua_assert(0); return;
  523. }
  524. g->GCmemtrav += size;
  525. }
  526. static void propagateall (global_State *g) {
  527. while (g->gray) propagatemark(g);
  528. }
  529. static void convergeephemerons (global_State *g) {
  530. int changed;
  531. do {
  532. GCObject *w;
  533. GCObject *next = g->ephemeron; /* get ephemeron list */
  534. g->ephemeron = NULL; /* tables may return to this list when traversed */
  535. changed = 0;
  536. while ((w = next) != NULL) {
  537. next = gco2t(w)->gclist;
  538. if (traverseephemeron(g, gco2t(w))) { /* traverse marked some value? */
  539. propagateall(g); /* propagate changes */
  540. changed = 1; /* will have to revisit all ephemeron tables */
  541. }
  542. }
  543. } while (changed);
  544. }
  545. /* }====================================================== */
  546. /*
  547. ** {======================================================
  548. ** Sweep Functions
  549. ** =======================================================
  550. */
  551. /*
  552. ** clear entries with unmarked keys from all weaktables in list 'l' up
  553. ** to element 'f'
  554. */
  555. static void clearkeys (global_State *g, GCObject *l, GCObject *f) {
  556. for (; l != f; l = gco2t(l)->gclist) {
  557. Table *h = gco2t(l);
  558. Node *n, *limit = gnodelast(h);
  559. for (n = gnode(h, 0); n < limit; n++) {
  560. if (!ttisnil(gval(n)) && (iscleared(g, gkey(n)))) {
  561. setnilvalue(gval(n)); /* remove value ... */
  562. }
  563. if (ttisnil(gval(n))) /* is entry empty? */
  564. removeentry(n); /* remove entry from table */
  565. }
  566. }
  567. }
  568. /*
  569. ** clear entries with unmarked values from all weaktables in list 'l' up
  570. ** to element 'f'
  571. */
  572. static void clearvalues (global_State *g, GCObject *l, GCObject *f) {
  573. for (; l != f; l = gco2t(l)->gclist) {
  574. Table *h = gco2t(l);
  575. Node *n, *limit = gnodelast(h);
  576. unsigned int i;
  577. for (i = 0; i < h->sizearray; i++) {
  578. TValue *o = &h->array[i];
  579. if (iscleared(g, o)) /* value was collected? */
  580. setnilvalue(o); /* remove value */
  581. }
  582. for (n = gnode(h, 0); n < limit; n++) {
  583. if (!ttisnil(gval(n)) && iscleared(g, gval(n))) {
  584. setnilvalue(gval(n)); /* remove value ... */
  585. removeentry(n); /* and remove entry from table */
  586. }
  587. }
  588. }
  589. }
  590. void luaC_upvdeccount (lua_State *L, UpVal *uv) {
  591. lua_assert(uv->refcount > 0);
  592. uv->refcount--;
  593. if (uv->refcount == 0 && !upisopen(uv))
  594. luaM_free(L, uv);
  595. }
  596. static void freeLclosure (lua_State *L, LClosure *cl) {
  597. int i;
  598. for (i = 0; i < cl->nupvalues; i++) {
  599. UpVal *uv = cl->upvals[i];
  600. if (uv)
  601. luaC_upvdeccount(L, uv);
  602. }
  603. luaM_freemem(L, cl, sizeLclosure(cl->nupvalues));
  604. }
  605. static void freeobj (lua_State *L, GCObject *o) {
  606. switch (gettt(o)) {
  607. case LUA_TPROTO: luaF_freeproto(L, gco2p(o)); break;
  608. case LUA_TLCL: {
  609. freeLclosure(L, gco2lcl(o));
  610. break;
  611. }
  612. case LUA_TCCL: {
  613. luaM_freemem(L, o, sizeCclosure(gco2ccl(o)->nupvalues));
  614. break;
  615. }
  616. case LUA_TTABLE: luaH_free(L, gco2t(o)); break;
  617. case LUA_TTHREAD: luaE_freethread(L, gco2th(o)); break;
  618. case LUA_TUSERDATA: luaM_freemem(L, o, sizeudata(gco2u(o))); break;
  619. case LUA_TSHRSTR:
  620. luaS_remove(L, gco2ts(o)); /* remove it from hash table */
  621. luaM_freemem(L, o, sizelstring(gco2ts(o)->shrlen));
  622. break;
  623. case LUA_TLNGSTR: {
  624. luaM_freemem(L, o, sizelstring(gco2ts(o)->u.lnglen));
  625. break;
  626. }
  627. default: lua_assert(0);
  628. }
  629. }
  630. #define sweepwholelist(L,p) sweeplist(L,p,MAX_LUMEM)
  631. static GCObject **sweeplist (lua_State *L, GCObject **p, lu_mem count);
  632. /*
  633. ** sweep at most 'count' elements from a list of GCObjects erasing dead
  634. ** objects, where a dead object is one marked with the old (non current)
  635. ** white; change all non-dead objects back to white, preparing for next
  636. ** collection cycle. Return where to continue the traversal or NULL if
  637. ** list is finished.
  638. */
  639. static GCObject **sweeplist (lua_State *L, GCObject **p, lu_mem count) {
  640. global_State *g = G(L);
  641. int ow = otherwhite(g);
  642. int white = luaC_white(g); /* current white */
  643. while (*p != NULL && count-- > 0) {
  644. GCObject *curr = *p;
  645. int marked = curr->marked;
  646. if (isdeadm(ow, marked)) { /* is 'curr' dead? */
  647. *p = curr->next; /* remove 'curr' from list */
  648. freeobj(L, curr); /* erase 'curr' */
  649. }
  650. else { /* change mark to 'white' */
  651. curr->marked = cast_byte((marked & maskcolors) | white);
  652. p = &curr->next; /* go to next element */
  653. }
  654. }
  655. return (*p == NULL) ? NULL : p;
  656. }
  657. /*
  658. ** sweep a list until a live object (or end of list)
  659. */
  660. static GCObject **sweeptolive (lua_State *L, GCObject **p) {
  661. GCObject **old = p;
  662. do {
  663. p = sweeplist(L, p, 1);
  664. } while (p == old);
  665. return p;
  666. }
  667. /* }====================================================== */
  668. /*
  669. ** {======================================================
  670. ** Finalization
  671. ** =======================================================
  672. */
  673. /*
  674. ** If possible, shrink string table
  675. */
  676. static void checkSizes (lua_State *L, global_State *g) {
  677. if (g->gckind != KGC_EMERGENCY) {
  678. l_mem olddebt = g->GCdebt;
  679. if (g->strt.nuse < g->strt.size / 4) /* string table too big? */
  680. luaS_resize(L, g->strt.size / 2); /* shrink it a little */
  681. g->GCestimate += g->GCdebt - olddebt; /* update estimate */
  682. }
  683. }
  684. static GCObject *udata2finalize (global_State *g) {
  685. GCObject *o = g->tobefnz; /* get first element */
  686. lua_assert(tofinalize(o));
  687. g->tobefnz = o->next; /* remove it from 'tobefnz' list */
  688. o->next = g->allgc; /* return it to 'allgc' list */
  689. g->allgc = o;
  690. resetbit(o->marked, FINALIZEDBIT); /* object is "normal" again */
  691. if (issweepphase(g))
  692. makewhite(g, o); /* "sweep" object */
  693. return o;
  694. }
  695. static void dothecall (lua_State *L, void *ud) {
  696. UNUSED(ud);
  697. luaD_callnoyield(L, L->top - 2, 0);
  698. }
  699. static void GCTM (lua_State *L, int propagateerrors) {
  700. global_State *g = G(L);
  701. const TValue *tm;
  702. TValue v;
  703. setgcovalue(L, &v, udata2finalize(g));
  704. tm = luaT_gettmbyobj(L, &v, TM_GC);
  705. if (tm != NULL && ttisfunction(tm)) { /* is there a finalizer? */
  706. int status;
  707. lu_byte oldah = L->allowhook;
  708. int running = g->gcrunning;
  709. L->allowhook = 0; /* stop debug hooks during GC metamethod */
  710. g->gcrunning = 0; /* avoid GC steps */
  711. setobj2s(L, L->top, tm); /* push finalizer... */
  712. setobj2s(L, L->top + 1, &v); /* ... and its argument */
  713. L->top += 2; /* and (next line) call the finalizer */
  714. L->ci->callstatus |= CIST_FIN; /* will run a finalizer */
  715. status = luaD_pcall(L, dothecall, NULL, savestack(L, L->top - 2), 0);
  716. L->ci->callstatus &= ~CIST_FIN; /* not running a finalizer anymore */
  717. L->allowhook = oldah; /* restore hooks */
  718. g->gcrunning = running; /* restore state */
  719. if (status != LUA_OK && propagateerrors) { /* error while running __gc? */
  720. if (status == LUA_ERRRUN) { /* is there an error object? */
  721. const char *msg = (ttisstring(L->top - 1))
  722. ? svalue(L->top - 1)
  723. : "no message";
  724. luaO_pushfstring(L, "error in __gc metamethod (%s)", msg);
  725. status = LUA_ERRGCMM; /* error in __gc metamethod */
  726. }
  727. luaD_throw(L, status); /* re-throw error */
  728. }
  729. }
  730. }
  731. /*
  732. ** call a few (up to 'g->gcfinnum') finalizers
  733. */
  734. static int runafewfinalizers (lua_State *L) {
  735. global_State *g = G(L);
  736. unsigned int i;
  737. lua_assert(!g->tobefnz || g->gcfinnum > 0);
  738. for (i = 0; g->tobefnz && i < g->gcfinnum; i++)
  739. GCTM(L, 1); /* call one finalizer */
  740. g->gcfinnum = (!g->tobefnz) ? 0 /* nothing more to finalize? */
  741. : g->gcfinnum * 2; /* else call a few more next time */
  742. return i;
  743. }
  744. /*
  745. ** call all pending finalizers
  746. */
  747. static void callallpendingfinalizers (lua_State *L) {
  748. global_State *g = G(L);
  749. while (g->tobefnz)
  750. GCTM(L, 0);
  751. }
  752. /*
  753. ** find last 'next' field in list 'p' list (to add elements in its end)
  754. */
  755. static GCObject **findlast (GCObject **p) {
  756. while (*p != NULL)
  757. p = &(*p)->next;
  758. return p;
  759. }
  760. /*
  761. ** move all unreachable objects (or 'all' objects) that need
  762. ** finalization from list 'finobj' to list 'tobefnz' (to be finalized)
  763. */
  764. static void separatetobefnz (global_State *g, int all) {
  765. GCObject *curr;
  766. GCObject **p = &g->finobj;
  767. GCObject **lastnext = findlast(&g->tobefnz);
  768. while ((curr = *p) != NULL) { /* traverse all finalizable objects */
  769. lua_assert(tofinalize(curr));
  770. if (!(iswhite(curr) || all)) /* not being collected? */
  771. p = &curr->next; /* don't bother with it */
  772. else {
  773. *p = curr->next; /* remove 'curr' from 'finobj' list */
  774. curr->next = *lastnext; /* link at the end of 'tobefnz' list */
  775. *lastnext = curr;
  776. lastnext = &curr->next;
  777. }
  778. }
  779. }
  780. /*
  781. ** if object 'o' has a finalizer, remove it from 'allgc' list (must
  782. ** search the list to find it) and link it in 'finobj' list.
  783. */
  784. void luaC_checkfinalizer (lua_State *L, GCObject *o, Table *mt) {
  785. global_State *g = G(L);
  786. if (tofinalize(o) || /* obj. is already marked... */
  787. gfasttm(g, mt, TM_GC) == NULL) /* or has no finalizer? */
  788. return; /* nothing to be done */
  789. else { /* move 'o' to 'finobj' list */
  790. GCObject **p;
  791. if (issweepphase(g)) {
  792. makewhite(g, o); /* "sweep" object 'o' */
  793. if (g->sweepgc == &o->next) /* should not remove 'sweepgc' object */
  794. g->sweepgc = sweeptolive(L, g->sweepgc); /* change 'sweepgc' */
  795. }
  796. /* search for pointer pointing to 'o' */
  797. for (p = &g->allgc; *p != o; p = &(*p)->next) { /* empty */ }
  798. *p = o->next; /* remove 'o' from 'allgc' list */
  799. o->next = g->finobj; /* link it in 'finobj' list */
  800. g->finobj = o;
  801. l_setbit(o->marked, FINALIZEDBIT); /* mark it as such */
  802. }
  803. }
  804. /* }====================================================== */
  805. /*
  806. ** {======================================================
  807. ** GC control
  808. ** =======================================================
  809. */
  810. /*
  811. ** Set a reasonable "time" to wait before starting a new GC cycle; cycle
  812. ** will start when memory use hits threshold. (Division by 'estimate'
  813. ** should be OK: it cannot be zero (because Lua cannot even start with
  814. ** less than PAUSEADJ bytes).
  815. */
  816. static void setpause (global_State *g) {
  817. l_mem threshold, debt;
  818. l_mem estimate = g->GCestimate / PAUSEADJ; /* adjust 'estimate' */
  819. lua_assert(estimate > 0);
  820. threshold = (g->gcpause < MAX_LMEM / estimate) /* overflow? */
  821. ? estimate * g->gcpause /* no overflow */
  822. : MAX_LMEM; /* overflow; truncate to maximum */
  823. debt = gettotalbytes(g) - threshold;
  824. luaE_setdebt(g, debt);
  825. }
  826. /*
  827. ** Enter first sweep phase.
  828. ** The call to 'sweeplist' tries to make pointer point to an object
  829. ** inside the list (instead of to the header), so that the real sweep do
  830. ** not need to skip objects created between "now" and the start of the
  831. ** real sweep.
  832. */
  833. static void entersweep (lua_State *L) {
  834. global_State *g = G(L);
  835. g->gcstate = GCSswpallgc;
  836. lua_assert(g->sweepgc == NULL);
  837. g->sweepgc = sweeplist(L, &g->allgc, 1);
  838. }
  839. void luaC_freeallobjects (lua_State *L) {
  840. global_State *g = G(L);
  841. separatetobefnz(g, 1); /* separate all objects with finalizers */
  842. lua_assert(g->finobj == NULL);
  843. callallpendingfinalizers(L);
  844. lua_assert(g->tobefnz == NULL);
  845. g->currentwhite = WHITEBITS; /* this "white" makes all objects look dead */
  846. g->gckind = KGC_NORMAL;
  847. sweepwholelist(L, &g->finobj);
  848. sweepwholelist(L, &g->allgc);
  849. sweepwholelist(L, &g->fixedgc); /* collect fixed objects */
  850. lua_assert(g->strt.nuse == 0);
  851. }
  852. static l_mem atomic (lua_State *L) {
  853. global_State *g = G(L);
  854. l_mem work;
  855. GCObject *origweak, *origall;
  856. GCObject *grayagain = g->grayagain; /* save original list */
  857. lua_assert(g->ephemeron == NULL && g->weak == NULL);
  858. lua_assert(!iswhite(g->mainthread));
  859. g->gcstate = GCSinsideatomic;
  860. g->GCmemtrav = 0; /* start counting work */
  861. markobject(g, L); /* mark running thread */
  862. /* registry and global metatables may be changed by API */
  863. markvalue(g, &g->l_registry);
  864. markmt(g); /* mark global metatables */
  865. /* remark occasional upvalues of (maybe) dead threads */
  866. remarkupvals(g);
  867. propagateall(g); /* propagate changes */
  868. work = g->GCmemtrav; /* stop counting (do not recount 'grayagain') */
  869. g->gray = grayagain;
  870. propagateall(g); /* traverse 'grayagain' list */
  871. g->GCmemtrav = 0; /* restart counting */
  872. convergeephemerons(g);
  873. /* at this point, all strongly accessible objects are marked. */
  874. /* Clear values from weak tables, before checking finalizers */
  875. clearvalues(g, g->weak, NULL);
  876. clearvalues(g, g->allweak, NULL);
  877. origweak = g->weak; origall = g->allweak;
  878. work += g->GCmemtrav; /* stop counting (objects being finalized) */
  879. separatetobefnz(g, 0); /* separate objects to be finalized */
  880. g->gcfinnum = 1; /* there may be objects to be finalized */
  881. markbeingfnz(g); /* mark objects that will be finalized */
  882. propagateall(g); /* remark, to propagate 'resurrection' */
  883. g->GCmemtrav = 0; /* restart counting */
  884. convergeephemerons(g);
  885. /* at this point, all resurrected objects are marked. */
  886. /* remove dead objects from weak tables */
  887. clearkeys(g, g->ephemeron, NULL); /* clear keys from all ephemeron tables */
  888. clearkeys(g, g->allweak, NULL); /* clear keys from all 'allweak' tables */
  889. /* clear values from resurrected weak tables */
  890. clearvalues(g, g->weak, origweak);
  891. clearvalues(g, g->allweak, origall);
  892. luaS_clearcache(g);
  893. g->currentwhite = cast_byte(otherwhite(g)); /* flip current white */
  894. work += g->GCmemtrav; /* complete counting */
  895. return work; /* estimate of memory marked by 'atomic' */
  896. }
  897. static lu_mem sweepstep (lua_State *L, global_State *g,
  898. int nextstate, GCObject **nextlist) {
  899. if (g->sweepgc) {
  900. l_mem olddebt = g->GCdebt;
  901. g->sweepgc = sweeplist(L, g->sweepgc, GCSWEEPMAX);
  902. g->GCestimate += g->GCdebt - olddebt; /* update estimate */
  903. if (g->sweepgc) /* is there still something to sweep? */
  904. return (GCSWEEPMAX * GCSWEEPCOST);
  905. }
  906. /* else enter next state */
  907. g->gcstate = nextstate;
  908. g->sweepgc = nextlist;
  909. return 0;
  910. }
  911. static lu_mem singlestep (lua_State *L) {
  912. global_State *g = G(L);
  913. switch (g->gcstate) {
  914. case GCSpause: {
  915. g->GCmemtrav = g->strt.size * sizeof(GCObject*);
  916. restartcollection(g);
  917. g->gcstate = GCSpropagate;
  918. return g->GCmemtrav;
  919. }
  920. case GCSpropagate: {
  921. g->GCmemtrav = 0;
  922. lua_assert(g->gray);
  923. propagatemark(g);
  924. if (g->gray == NULL) /* no more gray objects? */
  925. g->gcstate = GCSatomic; /* finish propagate phase */
  926. return g->GCmemtrav; /* memory traversed in this step */
  927. }
  928. case GCSatomic: {
  929. lu_mem work;
  930. propagateall(g); /* make sure gray list is empty */
  931. work = atomic(L); /* work is what was traversed by 'atomic' */
  932. entersweep(L);
  933. g->GCestimate = gettotalbytes(g); /* first estimate */;
  934. return work;
  935. }
  936. case GCSswpallgc: { /* sweep "regular" objects */
  937. return sweepstep(L, g, GCSswpfinobj, &g->finobj);
  938. }
  939. case GCSswpfinobj: { /* sweep objects with finalizers */
  940. return sweepstep(L, g, GCSswptobefnz, &g->tobefnz);
  941. }
  942. case GCSswptobefnz: { /* sweep objects to be finalized */
  943. return sweepstep(L, g, GCSswpend, NULL);
  944. }
  945. case GCSswpend: { /* finish sweeps */
  946. makewhite(g, g->mainthread); /* sweep main thread */
  947. checkSizes(L, g);
  948. g->gcstate = GCScallfin;
  949. return 0;
  950. }
  951. case GCScallfin: { /* call remaining finalizers */
  952. if (g->tobefnz && g->gckind != KGC_EMERGENCY) {
  953. int n = runafewfinalizers(L);
  954. return (n * GCFINALIZECOST);
  955. }
  956. else { /* emergency mode or no more finalizers */
  957. g->gcstate = GCSpause; /* finish collection */
  958. return 0;
  959. }
  960. }
  961. default: lua_assert(0); return 0;
  962. }
  963. }
  964. /*
  965. ** advances the garbage collector until it reaches a state allowed
  966. ** by 'statemask'
  967. */
  968. void luaC_runtilstate (lua_State *L, int statesmask) {
  969. global_State *g = G(L);
  970. while (!testbit(statesmask, g->gcstate))
  971. singlestep(L);
  972. }
  973. /*
  974. ** get GC debt and convert it from Kb to 'work units' (avoid zero debt
  975. ** and overflows)
  976. */
  977. static l_mem getdebt (global_State *g) {
  978. l_mem debt = g->GCdebt;
  979. int stepmul = g->gcstepmul;
  980. if (debt <= 0) return 0; /* minimal debt */
  981. else {
  982. debt = (debt / STEPMULADJ) + 1;
  983. debt = (debt < MAX_LMEM / stepmul) ? debt * stepmul : MAX_LMEM;
  984. return debt;
  985. }
  986. }
  987. /*
  988. ** performs a basic GC step when collector is running
  989. */
  990. #ifdef LUA_USE_ESP8266 /*DEBUG*/
  991. extern void dbg_printf(const char *fmt, ...);
  992. #define CCOUNT_REG ({ int32_t r; asm volatile("rsr %0, ccount" : "=r"(r)); r;})
  993. #else /*DEBUG*/
  994. #define dbg_printf(...)
  995. #define CCOUNT_REG 0
  996. #endif /*DEBUG*/
  997. void luaC_step (lua_State *L) {
  998. global_State *g = G(L);
  999. l_mem debt = getdebt(g); /* GC deficit (be paid now) */
  1000. if (!g->gcrunning) { /* not running? */
  1001. luaE_setdebt(g, -GCSTEPSIZE * 10); /* avoid being called too often */
  1002. return;
  1003. }
  1004. do { /* repeat until pause or enough "credit" (negative debt) */
  1005. /*DEBUG int32_t start = CCOUNT_REG; */
  1006. lu_mem work = singlestep(L); /* perform one single step */
  1007. debt -= work;
  1008. /*DEBUG dbg_printf("singlestep - %d, %d, %u \n", debt, lua_freeheap(), CCOUNT_REG-start); */
  1009. } while (debt > -GCSTEPSIZE && g->gcstate != GCSpause);
  1010. if (g->gcstate == GCSpause)
  1011. setpause(g); /* pause until next cycle */
  1012. else {
  1013. /*DEBUG int32_t start = CCOUNT_REG; */
  1014. debt = (debt / g->gcstepmul) * STEPMULADJ; /* convert 'work units' to Kb */
  1015. luaE_setdebt(g, debt);
  1016. runafewfinalizers(L);
  1017. /*DEBUG dbg_printf("new debt - %d, %d, %u \n", debt, lua_freeheap(), CCOUNT_REG-start); */
  1018. }
  1019. }
  1020. /*
  1021. ** Performs a full GC cycle; if 'isemergency', set a flag to avoid
  1022. ** some operations which could change the interpreter state in some
  1023. ** unexpected ways (running finalizers and shrinking some structures).
  1024. ** Before running the collection, check 'keepinvariant'; if it is true,
  1025. ** there may be some objects marked as black, so the collector has
  1026. ** to sweep all objects to turn them back to white (as white has not
  1027. ** changed, nothing will be collected).
  1028. */
  1029. void luaC_fullgc (lua_State *L, int isemergency) {
  1030. global_State *g = G(L);
  1031. lua_assert(g->gckind == KGC_NORMAL);
  1032. if (isemergency) g->gckind = KGC_EMERGENCY; /* set flag */
  1033. if (keepinvariant(g)) { /* black objects? */
  1034. entersweep(L); /* sweep everything to turn them back to white */
  1035. }
  1036. /* finish any pending sweep phase to start a new cycle */
  1037. luaC_runtilstate(L, bitmask(GCSpause));
  1038. luaC_runtilstate(L, ~bitmask(GCSpause)); /* start new collection */
  1039. luaC_runtilstate(L, bitmask(GCScallfin)); /* run up to finalizers */
  1040. /* estimate must be correct after a full GC cycle */
  1041. lua_assert(g->GCestimate == gettotalbytes(g));
  1042. luaC_runtilstate(L, bitmask(GCSpause)); /* finish collection */
  1043. g->gckind = KGC_NORMAL;
  1044. setpause(g);
  1045. }
  1046. /* }====================================================== */