|
1866
|
1 /*
|
|
|
2 ** $Id: lgc.h,v 2.58 2012/09/11 12:53:08 roberto Exp $
|
|
|
3 ** Garbage Collector
|
|
|
4 ** See Copyright Notice in lua.h
|
|
|
5 */
|
|
|
6
|
|
|
7 #ifndef lgc_h
|
|
|
8 #define lgc_h
|
|
|
9
|
|
|
10
|
|
|
11 #include "lobject.h"
|
|
|
12 #include "lstate.h"
|
|
|
13
|
|
|
14 /*
|
|
|
15 ** Collectable objects may have one of three colors: white, which
|
|
|
16 ** means the object is not marked; gray, which means the
|
|
|
17 ** object is marked, but its references may be not marked; and
|
|
|
18 ** black, which means that the object and all its references are marked.
|
|
|
19 ** The main invariant of the garbage collector, while marking objects,
|
|
|
20 ** is that a black object can never point to a white one. Moreover,
|
|
|
21 ** any gray object must be in a "gray list" (gray, grayagain, weak,
|
|
|
22 ** allweak, ephemeron) so that it can be visited again before finishing
|
|
|
23 ** the collection cycle. These lists have no meaning when the invariant
|
|
|
24 ** is not being enforced (e.g., sweep phase).
|
|
|
25 */
|
|
|
26
|
|
|
27
|
|
|
28
|
|
|
29 /* how much to allocate before next GC step */
|
|
|
30 #if !defined(GCSTEPSIZE)
|
|
|
31 /* ~100 small strings */
|
|
|
32 #define GCSTEPSIZE (cast_int(100 * sizeof(TString)))
|
|
|
33 #endif
|
|
|
34
|
|
|
35
|
|
|
36 /*
|
|
|
37 ** Possible states of the Garbage Collector
|
|
|
38 */
|
|
|
39 #define GCSpropagate 0
|
|
|
40 #define GCSatomic 1
|
|
|
41 #define GCSsweepstring 2
|
|
|
42 #define GCSsweepudata 3
|
|
|
43 #define GCSsweep 4
|
|
|
44 #define GCSpause 5
|
|
|
45
|
|
|
46
|
|
|
47 #define issweepphase(g) \
|
|
|
48 (GCSsweepstring <= (g)->gcstate && (g)->gcstate <= GCSsweep)
|
|
|
49
|
|
|
50 #define isgenerational(g) ((g)->gckind == KGC_GEN)
|
|
|
51
|
|
|
52 /*
|
|
|
53 ** macros to tell when main invariant (white objects cannot point to black
|
|
|
54 ** ones) must be kept. During a non-generational collection, the sweep
|
|
|
55 ** phase may break the invariant, as objects turned white may point to
|
|
|
56 ** still-black objects. The invariant is restored when sweep ends and
|
|
|
57 ** all objects are white again. During a generational collection, the
|
|
|
58 ** invariant must be kept all times.
|
|
|
59 */
|
|
|
60
|
|
|
61 #define keepinvariant(g) (isgenerational(g) || g->gcstate <= GCSatomic)
|
|
|
62
|
|
|
63
|
|
|
64 /*
|
|
|
65 ** Outside the collector, the state in generational mode is kept in
|
|
|
66 ** 'propagate', so 'keepinvariant' is always true.
|
|
|
67 */
|
|
|
68 #define keepinvariantout(g) \
|
|
|
69 check_exp(g->gcstate == GCSpropagate || !isgenerational(g), \
|
|
|
70 g->gcstate <= GCSatomic)
|
|
|
71
|
|
|
72
|
|
|
73 /*
|
|
|
74 ** some useful bit tricks
|
|
|
75 */
|
|
|
76 #define resetbits(x,m) ((x) &= cast(lu_byte, ~(m)))
|
|
|
77 #define setbits(x,m) ((x) |= (m))
|
|
|
78 #define testbits(x,m) ((x) & (m))
|
|
|
79 #define bitmask(b) (1<<(b))
|
|
|
80 #define bit2mask(b1,b2) (bitmask(b1) | bitmask(b2))
|
|
|
81 #define l_setbit(x,b) setbits(x, bitmask(b))
|
|
|
82 #define resetbit(x,b) resetbits(x, bitmask(b))
|
|
|
83 #define testbit(x,b) testbits(x, bitmask(b))
|
|
|
84
|
|
|
85
|
|
|
86 /* Layout for bit use in `marked' field: */
|
|
|
87 #define WHITE0BIT 0 /* object is white (type 0) */
|
|
|
88 #define WHITE1BIT 1 /* object is white (type 1) */
|
|
|
89 #define BLACKBIT 2 /* object is black */
|
|
|
90 #define FINALIZEDBIT 3 /* object has been separated for finalization */
|
|
|
91 #define SEPARATED 4 /* object is in 'finobj' list or in 'tobefnz' */
|
|
|
92 #define FIXEDBIT 5 /* object is fixed (should not be collected) */
|
|
|
93 #define OLDBIT 6 /* object is old (only in generational mode) */
|
|
|
94 /* bit 7 is currently used by tests (luaL_checkmemory) */
|
|
|
95
|
|
|
96 #define WHITEBITS bit2mask(WHITE0BIT, WHITE1BIT)
|
|
|
97
|
|
|
98
|
|
|
99 #define iswhite(x) testbits((x)->gch.marked, WHITEBITS)
|
|
|
100 #define isblack(x) testbit((x)->gch.marked, BLACKBIT)
|
|
|
101 #define isgray(x) /* neither white nor black */ \
|
|
|
102 (!testbits((x)->gch.marked, WHITEBITS | bitmask(BLACKBIT)))
|
|
|
103
|
|
|
104 #define isold(x) testbit((x)->gch.marked, OLDBIT)
|
|
|
105
|
|
|
106 /* MOVE OLD rule: whenever an object is moved to the beginning of
|
|
|
107 a GC list, its old bit must be cleared */
|
|
|
108 #define resetoldbit(o) resetbit((o)->gch.marked, OLDBIT)
|
|
|
109
|
|
|
110 #define otherwhite(g) (g->currentwhite ^ WHITEBITS)
|
|
|
111 #define isdeadm(ow,m) (!(((m) ^ WHITEBITS) & (ow)))
|
|
|
112 #define isdead(g,v) isdeadm(otherwhite(g), (v)->gch.marked)
|
|
|
113
|
|
|
114 #define changewhite(x) ((x)->gch.marked ^= WHITEBITS)
|
|
|
115 #define gray2black(x) l_setbit((x)->gch.marked, BLACKBIT)
|
|
|
116
|
|
|
117 #define valiswhite(x) (iscollectable(x) && iswhite(gcvalue(x)))
|
|
|
118
|
|
|
119 #define luaC_white(g) cast(lu_byte, (g)->currentwhite & WHITEBITS)
|
|
|
120
|
|
|
121
|
|
|
122 #define luaC_condGC(L,c) \
|
|
|
123 {if (G(L)->GCdebt > 0) {c;}; condchangemem(L);}
|
|
|
124 #define luaC_checkGC(L) luaC_condGC(L, luaC_step(L);)
|
|
|
125
|
|
|
126
|
|
|
127 #define luaC_barrier(L,p,v) { if (valiswhite(v) && isblack(obj2gco(p))) \
|
|
|
128 luaC_barrier_(L,obj2gco(p),gcvalue(v)); }
|
|
|
129
|
|
|
130 #define luaC_barrierback(L,p,v) { if (valiswhite(v) && isblack(obj2gco(p))) \
|
|
|
131 luaC_barrierback_(L,p); }
|
|
|
132
|
|
|
133 #define luaC_objbarrier(L,p,o) \
|
|
|
134 { if (iswhite(obj2gco(o)) && isblack(obj2gco(p))) \
|
|
|
135 luaC_barrier_(L,obj2gco(p),obj2gco(o)); }
|
|
|
136
|
|
|
137 #define luaC_objbarrierback(L,p,o) \
|
|
|
138 { if (iswhite(obj2gco(o)) && isblack(obj2gco(p))) luaC_barrierback_(L,p); }
|
|
|
139
|
|
|
140 #define luaC_barrierproto(L,p,c) \
|
|
|
141 { if (isblack(obj2gco(p))) luaC_barrierproto_(L,p,c); }
|
|
|
142
|
|
|
143 LUAI_FUNC void luaC_freeallobjects (lua_State *L);
|
|
|
144 LUAI_FUNC void luaC_step (lua_State *L);
|
|
|
145 LUAI_FUNC void luaC_forcestep (lua_State *L);
|
|
|
146 LUAI_FUNC void luaC_runtilstate (lua_State *L, int statesmask);
|
|
|
147 LUAI_FUNC void luaC_fullgc (lua_State *L, int isemergency);
|
|
|
148 LUAI_FUNC GCObject *luaC_newobj (lua_State *L, int tt, size_t sz,
|
|
|
149 GCObject **list, int offset);
|
|
|
150 LUAI_FUNC void luaC_barrier_ (lua_State *L, GCObject *o, GCObject *v);
|
|
|
151 LUAI_FUNC void luaC_barrierback_ (lua_State *L, GCObject *o);
|
|
|
152 LUAI_FUNC void luaC_barrierproto_ (lua_State *L, Proto *p, Closure *c);
|
|
|
153 LUAI_FUNC void luaC_checkfinalizer (lua_State *L, GCObject *o, Table *mt);
|
|
|
154 LUAI_FUNC void luaC_checkupvalcolor (global_State *g, UpVal *uv);
|
|
|
155 LUAI_FUNC void luaC_changemode (lua_State *L, int mode);
|
|
|
156
|
|
|
157 #endif
|
