diff options
author | David Walter Seikel | 2012-01-23 23:36:30 +1000 |
---|---|---|
committer | David Walter Seikel | 2012-01-23 23:36:30 +1000 |
commit | 6523585c66c04cea54df50013df8886b589847d8 (patch) | |
tree | 0b22aee7064166d88595eda260ca2d17c0773da5 /libraries/LuaJIT-1.1.7/src/lgc.c | |
parent | Update the EFL to what I'm actually using, coz I'm using some stuff not yet r... (diff) | |
download | SledjHamr-6523585c66c04cea54df50013df8886b589847d8.zip SledjHamr-6523585c66c04cea54df50013df8886b589847d8.tar.gz SledjHamr-6523585c66c04cea54df50013df8886b589847d8.tar.bz2 SledjHamr-6523585c66c04cea54df50013df8886b589847d8.tar.xz |
Add luaproc and LuaJIT libraries.
Two versions of LuaJIT, the stable release, and the dev version. Try the dev version first, until ih fails badly.
Diffstat (limited to 'libraries/LuaJIT-1.1.7/src/lgc.c')
-rw-r--r-- | libraries/LuaJIT-1.1.7/src/lgc.c | 711 |
1 files changed, 711 insertions, 0 deletions
diff --git a/libraries/LuaJIT-1.1.7/src/lgc.c b/libraries/LuaJIT-1.1.7/src/lgc.c new file mode 100644 index 0000000..d9e0b78 --- /dev/null +++ b/libraries/LuaJIT-1.1.7/src/lgc.c | |||
@@ -0,0 +1,711 @@ | |||
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 | |||