blob: caf749999a712694e04ec5df9b62d7a9bb9130de [file] [log] [blame]
Jeremy Hyltonc5007aa2000-06-30 05:02:53 +00001/*
Tim Peters88396172002-06-30 17:56:40 +00002
Jeremy Hyltonc5007aa2000-06-30 05:02:53 +00003 Reference Cycle Garbage Collection
4 ==================================
5
Neil Schemenauerb2c2c9e2000-10-04 16:34:09 +00006 Neil Schemenauer <nas@arctrix.com>
Jeremy Hyltonc5007aa2000-06-30 05:02:53 +00007
8 Based on a post on the python-dev list. Ideas from Guido van Rossum,
9 Eric Tiedemann, and various others.
10
Neil Schemenauer43411b52001-08-30 00:05:51 +000011 http://www.arctrix.com/nas/python/gc/
Jeremy Hyltonc5007aa2000-06-30 05:02:53 +000012 http://www.python.org/pipermail/python-dev/2000-March/003869.html
13 http://www.python.org/pipermail/python-dev/2000-March/004010.html
14 http://www.python.org/pipermail/python-dev/2000-March/004022.html
15
16 For a highlevel view of the collection process, read the collect
17 function.
18
Jeremy Hyltonc5007aa2000-06-30 05:02:53 +000019*/
20
Jeremy Hyltonc5007aa2000-06-30 05:02:53 +000021#include "Python.h"
22
Neil Schemenauer43411b52001-08-30 00:05:51 +000023/* Get an object's GC head */
24#define AS_GC(o) ((PyGC_Head *)(o)-1)
25
26/* Get the object given the GC head */
27#define FROM_GC(g) ((PyObject *)(((PyGC_Head *)g)+1))
28
Jeremy Hyltonc5007aa2000-06-30 05:02:53 +000029/*** Global GC state ***/
30
Neil Schemenauer2880ae52002-05-04 05:35:20 +000031struct gc_generation {
32 PyGC_Head head;
33 int threshold; /* collection threshold */
34 int count; /* count of allocations or collections of younger
35 generations */
36};
37
38#define NUM_GENERATIONS 3
39#define GEN_HEAD(n) (&generations[n].head)
40
Jeremy Hyltonc5007aa2000-06-30 05:02:53 +000041/* linked lists of container objects */
Neil Schemenauer2880ae52002-05-04 05:35:20 +000042static struct gc_generation generations[NUM_GENERATIONS] = {
43 /* PyGC_Head, threshold, count */
44 {{{GEN_HEAD(0), GEN_HEAD(0), 0}}, 700, 0},
45 {{{GEN_HEAD(1), GEN_HEAD(1), 0}}, 10, 0},
46 {{{GEN_HEAD(2), GEN_HEAD(2), 0}}, 10, 0},
47};
Jeremy Hyltonc5007aa2000-06-30 05:02:53 +000048
Neil Schemenauer2880ae52002-05-04 05:35:20 +000049PyGC_Head *_PyGC_generation0 = GEN_HEAD(0);
50
Vladimir Marangozovf9d20c32000-08-06 22:45:31 +000051static int enabled = 1; /* automatic collection enabled? */
Jeremy Hyltonc5007aa2000-06-30 05:02:53 +000052
Neil Schemenauer43411b52001-08-30 00:05:51 +000053/* true if we are currently running the collector */
Tim Petersbf384c22003-04-06 00:11:39 +000054static int collecting = 0;
Neil Schemenauer43411b52001-08-30 00:05:51 +000055
Tim Peters6fc13d92002-07-02 18:12:35 +000056/* list of uncollectable objects */
Tim Petersbf384c22003-04-06 00:11:39 +000057static PyObject *garbage = NULL;
Tim Peters6fc13d92002-07-02 18:12:35 +000058
59/* Python string to use if unhandled exception occurs */
Tim Petersbf384c22003-04-06 00:11:39 +000060static PyObject *gc_str = NULL;
Tim Peters6fc13d92002-07-02 18:12:35 +000061
Tim Peters93ad66d2003-04-05 17:15:44 +000062/* Python string used to look for __del__ attribute. */
63static PyObject *delstr = NULL;
Jeremy Hyltonce136e92003-04-04 19:59:06 +000064
Jeremy Hyltonc5007aa2000-06-30 05:02:53 +000065/* set for debugging information */
66#define DEBUG_STATS (1<<0) /* print collection statistics */
67#define DEBUG_COLLECTABLE (1<<1) /* print collectable objects */
68#define DEBUG_UNCOLLECTABLE (1<<2) /* print uncollectable objects */
69#define DEBUG_INSTANCES (1<<3) /* print instances */
70#define DEBUG_OBJECTS (1<<4) /* print other objects */
Neil Schemenauer544de1e2000-09-22 15:22:38 +000071#define DEBUG_SAVEALL (1<<5) /* save all garbage in gc.garbage */
Jeremy Hyltonc5007aa2000-06-30 05:02:53 +000072#define DEBUG_LEAK DEBUG_COLLECTABLE | \
73 DEBUG_UNCOLLECTABLE | \
74 DEBUG_INSTANCES | \
Neil Schemenauer544de1e2000-09-22 15:22:38 +000075 DEBUG_OBJECTS | \
76 DEBUG_SAVEALL
Jeremy Hyltonb709df32000-09-01 02:47:25 +000077static int debug;
Jeremy Hyltonc5007aa2000-06-30 05:02:53 +000078
Tim Peters6fc13d92002-07-02 18:12:35 +000079/*--------------------------------------------------------------------------
80gc_refs values.
Neil Schemenauer43411b52001-08-30 00:05:51 +000081
Tim Peters6fc13d92002-07-02 18:12:35 +000082Between collections, every gc'ed object has one of two gc_refs values:
83
84GC_UNTRACKED
85 The initial state; objects returned by PyObject_GC_Malloc are in this
86 state. The object doesn't live in any generation list, and its
87 tp_traverse slot must not be called.
88
89GC_REACHABLE
90 The object lives in some generation list, and its tp_traverse is safe to
91 call. An object transitions to GC_REACHABLE when PyObject_GC_Track
92 is called.
93
94During a collection, gc_refs can temporarily take on other states:
95
96>= 0
97 At the start of a collection, update_refs() copies the true refcount
98 to gc_refs, for each object in the generation being collected.
99 subtract_refs() then adjusts gc_refs so that it equals the number of
100 times an object is referenced directly from outside the generation
101 being collected.
Martin v. Löwis774348c2002-11-09 19:54:06 +0000102 gc_refs remains >= 0 throughout these steps.
Tim Peters6fc13d92002-07-02 18:12:35 +0000103
104GC_TENTATIVELY_UNREACHABLE
105 move_unreachable() then moves objects not reachable (whether directly or
106 indirectly) from outside the generation into an "unreachable" set.
107 Objects that are found to be reachable have gc_refs set to GC_REACHABLE
108 again. Objects that are found to be unreachable have gc_refs set to
109 GC_TENTATIVELY_UNREACHABLE. It's "tentatively" because the pass doing
110 this can't be sure until it ends, and GC_TENTATIVELY_UNREACHABLE may
111 transition back to GC_REACHABLE.
112
113 Only objects with GC_TENTATIVELY_UNREACHABLE still set are candidates
114 for collection. If it's decided not to collect such an object (e.g.,
115 it has a __del__ method), its gc_refs is restored to GC_REACHABLE again.
116----------------------------------------------------------------------------
117*/
Tim Petersea405632002-07-02 00:52:30 +0000118#define GC_UNTRACKED _PyGC_REFS_UNTRACKED
119#define GC_REACHABLE _PyGC_REFS_REACHABLE
120#define GC_TENTATIVELY_UNREACHABLE _PyGC_REFS_TENTATIVELY_UNREACHABLE
Tim Peters19b74c72002-07-01 03:52:19 +0000121
Tim Peters6fc13d92002-07-02 18:12:35 +0000122#define IS_TRACKED(o) ((AS_GC(o))->gc.gc_refs != GC_UNTRACKED)
Tim Peters19b74c72002-07-01 03:52:19 +0000123#define IS_REACHABLE(o) ((AS_GC(o))->gc.gc_refs == GC_REACHABLE)
124#define IS_TENTATIVELY_UNREACHABLE(o) ( \
125 (AS_GC(o))->gc.gc_refs == GC_TENTATIVELY_UNREACHABLE)
Neil Schemenauera2b11ec2002-05-21 15:53:24 +0000126
Jeremy Hyltonc5007aa2000-06-30 05:02:53 +0000127/*** list functions ***/
128
129static void
130gc_list_init(PyGC_Head *list)
131{
Tim Peters9e4ca102001-10-11 18:31:31 +0000132 list->gc.gc_prev = list;
133 list->gc.gc_next = list;
Jeremy Hyltonc5007aa2000-06-30 05:02:53 +0000134}
135
Neil Schemenauer2880ae52002-05-04 05:35:20 +0000136static int
137gc_list_is_empty(PyGC_Head *list)
138{
139 return (list->gc.gc_next == list);
140}
141
Jeremy Hyltonc5007aa2000-06-30 05:02:53 +0000142static void
143gc_list_append(PyGC_Head *node, PyGC_Head *list)
144{
Tim Peters9e4ca102001-10-11 18:31:31 +0000145 node->gc.gc_next = list;
146 node->gc.gc_prev = list->gc.gc_prev;
147 node->gc.gc_prev->gc.gc_next = node;
148 list->gc.gc_prev = node;
Jeremy Hyltonc5007aa2000-06-30 05:02:53 +0000149}
150
151static void
152gc_list_remove(PyGC_Head *node)
153{
Tim Peters9e4ca102001-10-11 18:31:31 +0000154 node->gc.gc_prev->gc.gc_next = node->gc.gc_next;
155 node->gc.gc_next->gc.gc_prev = node->gc.gc_prev;
156 node->gc.gc_next = NULL; /* object is not currently tracked */
Jeremy Hyltonc5007aa2000-06-30 05:02:53 +0000157}
158
Jeremy Hyltonc5007aa2000-06-30 05:02:53 +0000159/* append a list onto another list, from becomes an empty list */
160static void
161gc_list_merge(PyGC_Head *from, PyGC_Head *to)
162{
163 PyGC_Head *tail;
Neil Schemenauer2880ae52002-05-04 05:35:20 +0000164 if (!gc_list_is_empty(from)) {
Tim Peters9e4ca102001-10-11 18:31:31 +0000165 tail = to->gc.gc_prev;
166 tail->gc.gc_next = from->gc.gc_next;
167 tail->gc.gc_next->gc.gc_prev = tail;
168 to->gc.gc_prev = from->gc.gc_prev;
169 to->gc.gc_prev->gc.gc_next = to;
Jeremy Hyltonc5007aa2000-06-30 05:02:53 +0000170 }
171 gc_list_init(from);
172}
173
174static long
175gc_list_size(PyGC_Head *list)
176{
177 PyGC_Head *gc;
178 long n = 0;
Tim Peters9e4ca102001-10-11 18:31:31 +0000179 for (gc = list->gc.gc_next; gc != list; gc = gc->gc.gc_next) {
Jeremy Hyltonc5007aa2000-06-30 05:02:53 +0000180 n++;
181 }
182 return n;
183}
184
Tim Peters259272b2003-04-06 19:41:39 +0000185/* Append objects in a GC list to a Python list.
186 * Return 0 if all OK, < 0 if error (out of memory for list).
187 */
188static int
189append_objects(PyObject *py_list, PyGC_Head *gc_list)
190{
191 PyGC_Head *gc;
192 for (gc = gc_list->gc.gc_next; gc != gc_list; gc = gc->gc.gc_next) {
193 PyObject *op = FROM_GC(gc);
194 if (op != py_list) {
195 if (PyList_Append(py_list, op)) {
196 return -1; /* exception */
197 }
198 }
199 }
200 return 0;
201}
202
Jeremy Hyltonc5007aa2000-06-30 05:02:53 +0000203/*** end of list stuff ***/
204
205
Tim Peters19b74c72002-07-01 03:52:19 +0000206/* Set all gc_refs = ob_refcnt. After this, gc_refs is > 0 for all objects
207 * in containers, and is GC_REACHABLE for all tracked gc objects not in
208 * containers.
Tim Peters88396172002-06-30 17:56:40 +0000209 */
Jeremy Hyltonc5007aa2000-06-30 05:02:53 +0000210static void
211update_refs(PyGC_Head *containers)
212{
Tim Peters9e4ca102001-10-11 18:31:31 +0000213 PyGC_Head *gc = containers->gc.gc_next;
Tim Petersea405632002-07-02 00:52:30 +0000214 for (; gc != containers; gc = gc->gc.gc_next) {
215 assert(gc->gc.gc_refs == GC_REACHABLE);
Tim Peters9e4ca102001-10-11 18:31:31 +0000216 gc->gc.gc_refs = FROM_GC(gc)->ob_refcnt;
Tim Peters780c4972003-11-14 00:01:17 +0000217 /* Python's cyclic gc should never see an incoming refcount
218 * of 0: if something decref'ed to 0, it should have been
219 * deallocated immediately at that time.
220 * Possible cause (if the assert triggers): a tp_dealloc
221 * routine left a gc-aware object tracked during its teardown
222 * phase, and did something-- or allowed something to happen --
223 * that called back into Python. gc can trigger then, and may
224 * see the still-tracked dying object. Before this assert
225 * was added, such mistakes went on to allow gc to try to
226 * delete the object again. In a debug build, that caused
227 * a mysterious segfault, when _Py_ForgetReference tried
228 * to remove the object from the doubly-linked list of all
229 * objects a second time. In a release build, an actual
230 * double deallocation occurred, which leads to corruption
231 * of the allocator's internal bookkeeping pointers. That's
232 * so serious that maybe this should be a release-build
233 * check instead of an assert?
234 */
235 assert(gc->gc.gc_refs != 0);
Tim Petersea405632002-07-02 00:52:30 +0000236 }
Jeremy Hyltonc5007aa2000-06-30 05:02:53 +0000237}
238
Tim Peters19b74c72002-07-01 03:52:19 +0000239/* A traversal callback for subtract_refs. */
Jeremy Hyltonc5007aa2000-06-30 05:02:53 +0000240static int
241visit_decref(PyObject *op, void *data)
242{
Tim Peters93cd83e2002-06-30 21:31:03 +0000243 assert(op != NULL);
Tim Peters19b74c72002-07-01 03:52:19 +0000244 if (PyObject_IS_GC(op)) {
245 PyGC_Head *gc = AS_GC(op);
246 /* We're only interested in gc_refs for objects in the
247 * generation being collected, which can be recognized
248 * because only they have positive gc_refs.
249 */
Tim Petersaab713b2002-07-02 22:15:28 +0000250 assert(gc->gc.gc_refs != 0); /* else refcount was too small */
Tim Peters19b74c72002-07-01 03:52:19 +0000251 if (gc->gc.gc_refs > 0)
252 gc->gc.gc_refs--;
253 }
Jeremy Hyltonc5007aa2000-06-30 05:02:53 +0000254 return 0;
255}
256
Tim Peters19b74c72002-07-01 03:52:19 +0000257/* Subtract internal references from gc_refs. After this, gc_refs is >= 0
258 * for all objects in containers, and is GC_REACHABLE for all tracked gc
259 * objects not in containers. The ones with gc_refs > 0 are directly
260 * reachable from outside containers, and so can't be collected.
261 */
Jeremy Hyltonc5007aa2000-06-30 05:02:53 +0000262static void
263subtract_refs(PyGC_Head *containers)
264{
265 traverseproc traverse;
Tim Peters9e4ca102001-10-11 18:31:31 +0000266 PyGC_Head *gc = containers->gc.gc_next;
267 for (; gc != containers; gc=gc->gc.gc_next) {
Neil Schemenauer43411b52001-08-30 00:05:51 +0000268 traverse = FROM_GC(gc)->ob_type->tp_traverse;
269 (void) traverse(FROM_GC(gc),
Jeremy Hyltonc5007aa2000-06-30 05:02:53 +0000270 (visitproc)visit_decref,
271 NULL);
272 }
273}
274
Tim Peters19b74c72002-07-01 03:52:19 +0000275/* A traversal callback for move_unreachable. */
Jeremy Hyltonc5007aa2000-06-30 05:02:53 +0000276static int
Tim Peters19b74c72002-07-01 03:52:19 +0000277visit_reachable(PyObject *op, PyGC_Head *reachable)
Jeremy Hyltonc5007aa2000-06-30 05:02:53 +0000278{
Tim Petersea405632002-07-02 00:52:30 +0000279 if (PyObject_IS_GC(op)) {
Tim Peters19b74c72002-07-01 03:52:19 +0000280 PyGC_Head *gc = AS_GC(op);
281 const int gc_refs = gc->gc.gc_refs;
282
283 if (gc_refs == 0) {
284 /* This is in move_unreachable's 'young' list, but
285 * the traversal hasn't yet gotten to it. All
286 * we need to do is tell move_unreachable that it's
287 * reachable.
288 */
289 gc->gc.gc_refs = 1;
Jeremy Hyltonc5007aa2000-06-30 05:02:53 +0000290 }
Tim Peters19b74c72002-07-01 03:52:19 +0000291 else if (gc_refs == GC_TENTATIVELY_UNREACHABLE) {
292 /* This had gc_refs = 0 when move_unreachable got
293 * to it, but turns out it's reachable after all.
294 * Move it back to move_unreachable's 'young' list,
295 * and move_unreachable will eventually get to it
296 * again.
297 */
298 gc_list_remove(gc);
299 gc_list_append(gc, reachable);
300 gc->gc.gc_refs = 1;
301 }
302 /* Else there's nothing to do.
303 * If gc_refs > 0, it must be in move_unreachable's 'young'
304 * list, and move_unreachable will eventually get to it.
305 * If gc_refs == GC_REACHABLE, it's either in some other
306 * generation so we don't care about it, or move_unreachable
Tim Peters6fc13d92002-07-02 18:12:35 +0000307 * already dealt with it.
Tim Petersea405632002-07-02 00:52:30 +0000308 * If gc_refs == GC_UNTRACKED, it must be ignored.
Tim Peters19b74c72002-07-01 03:52:19 +0000309 */
Tim Petersea405632002-07-02 00:52:30 +0000310 else {
311 assert(gc_refs > 0
312 || gc_refs == GC_REACHABLE
313 || gc_refs == GC_UNTRACKED);
314 }
Jeremy Hyltonc5007aa2000-06-30 05:02:53 +0000315 }
316 return 0;
317}
318
Tim Peters19b74c72002-07-01 03:52:19 +0000319/* Move the unreachable objects from young to unreachable. After this,
320 * all objects in young have gc_refs = GC_REACHABLE, and all objects in
321 * unreachable have gc_refs = GC_TENTATIVELY_UNREACHABLE. All tracked
322 * gc objects not in young or unreachable still have gc_refs = GC_REACHABLE.
323 * All objects in young after this are directly or indirectly reachable
324 * from outside the original young; and all objects in unreachable are
325 * not.
Tim Peters88396172002-06-30 17:56:40 +0000326 */
Jeremy Hyltonc5007aa2000-06-30 05:02:53 +0000327static void
Tim Peters19b74c72002-07-01 03:52:19 +0000328move_unreachable(PyGC_Head *young, PyGC_Head *unreachable)
Jeremy Hyltonc5007aa2000-06-30 05:02:53 +0000329{
Tim Peters19b74c72002-07-01 03:52:19 +0000330 PyGC_Head *gc = young->gc.gc_next;
331
332 /* Invariants: all objects "to the left" of us in young have gc_refs
333 * = GC_REACHABLE, and are indeed reachable (directly or indirectly)
334 * from outside the young list as it was at entry. All other objects
335 * from the original young "to the left" of us are in unreachable now,
336 * and have gc_refs = GC_TENTATIVELY_UNREACHABLE. All objects to the
337 * left of us in 'young' now have been scanned, and no objects here
338 * or to the right have been scanned yet.
339 */
340
341 while (gc != young) {
342 PyGC_Head *next;
343
Tim Peters6fc13d92002-07-02 18:12:35 +0000344 if (gc->gc.gc_refs) {
345 /* gc is definitely reachable from outside the
346 * original 'young'. Mark it as such, and traverse
347 * its pointers to find any other objects that may
348 * be directly reachable from it. Note that the
349 * call to tp_traverse may append objects to young,
350 * so we have to wait until it returns to determine
351 * the next object to visit.
352 */
353 PyObject *op = FROM_GC(gc);
354 traverseproc traverse = op->ob_type->tp_traverse;
355 assert(gc->gc.gc_refs > 0);
356 gc->gc.gc_refs = GC_REACHABLE;
357 (void) traverse(op,
358 (visitproc)visit_reachable,
359 (void *)young);
360 next = gc->gc.gc_next;
361 }
362 else {
Tim Peters19b74c72002-07-01 03:52:19 +0000363 /* This *may* be unreachable. To make progress,
364 * assume it is. gc isn't directly reachable from
365 * any object we've already traversed, but may be
366 * reachable from an object we haven't gotten to yet.
367 * visit_reachable will eventually move gc back into
368 * young if that's so, and we'll see it again.
369 */
370 next = gc->gc.gc_next;
371 gc_list_remove(gc);
372 gc_list_append(gc, unreachable);
373 gc->gc.gc_refs = GC_TENTATIVELY_UNREACHABLE;
374 }
Tim Peters19b74c72002-07-01 03:52:19 +0000375 gc = next;
Jeremy Hyltonc5007aa2000-06-30 05:02:53 +0000376 }
377}
378
Tim Peters86b993b2003-04-05 17:35:54 +0000379/* Return true if object has a finalization method.
380 * CAUTION: An instance of an old-style class has to be checked for a
Tim Petersf6b80452003-04-07 19:21:15 +0000381 *__del__ method, and earlier versions of this used to call PyObject_HasAttr,
382 * which in turn could call the class's __getattr__ hook (if any). That
383 * could invoke arbitrary Python code, mutating the object graph in arbitrary
384 * ways, and that was the source of some excruciatingly subtle bugs.
Tim Peters86b993b2003-04-05 17:35:54 +0000385 */
Neil Schemenauera765c122001-11-01 17:35:23 +0000386static int
387has_finalizer(PyObject *op)
Jeremy Hyltonc5007aa2000-06-30 05:02:53 +0000388{
Tim Peters86b993b2003-04-05 17:35:54 +0000389 if (PyInstance_Check(op)) {
Tim Peters86b993b2003-04-05 17:35:54 +0000390 assert(delstr != NULL);
Tim Petersf6b80452003-04-07 19:21:15 +0000391 return _PyInstance_Lookup(op, delstr) != NULL;
Tim Peters86b993b2003-04-05 17:35:54 +0000392 }
393 else if (PyType_HasFeature(op->ob_type, Py_TPFLAGS_HEAPTYPE))
394 return op->ob_type->tp_del != NULL;
395 else
396 return 0;
Neil Schemenauera765c122001-11-01 17:35:23 +0000397}
398
Tim Peters403a2032003-11-20 21:21:46 +0000399/* Move the objects in unreachable with __del__ methods into finalizers,
400 * and weakrefs with callbacks into wr_callbacks.
401 * The objects remaining in unreachable do not have __del__ methods, and are
402 * not weakrefs with callbacks.
403 * The objects moved have gc_refs changed to GC_REACHABLE; the objects
404 * remaining in unreachable are left at GC_TENTATIVELY_UNREACHABLE.
Jeremy Hyltonce136e92003-04-04 19:59:06 +0000405 */
Neil Schemenauera765c122001-11-01 17:35:23 +0000406static void
Tim Peters403a2032003-11-20 21:21:46 +0000407move_troublemakers(PyGC_Head *unreachable,
408 PyGC_Head *finalizers,
409 PyGC_Head *wr_callbacks)
Neil Schemenauera765c122001-11-01 17:35:23 +0000410{
Tim Petersf6b80452003-04-07 19:21:15 +0000411 PyGC_Head *gc = unreachable->gc.gc_next;
412
413 while (gc != unreachable) {
Neil Schemenauer43411b52001-08-30 00:05:51 +0000414 PyObject *op = FROM_GC(gc);
Tim Petersf6b80452003-04-07 19:21:15 +0000415 PyGC_Head *next = gc->gc.gc_next;
Jeremy Hyltonce136e92003-04-04 19:59:06 +0000416
Tim Petersf6ae7a42003-04-05 18:40:50 +0000417 assert(IS_TENTATIVELY_UNREACHABLE(op));
418
Tim Petersf6b80452003-04-07 19:21:15 +0000419 if (has_finalizer(op)) {
Tim Petersf6ae7a42003-04-05 18:40:50 +0000420 gc_list_remove(gc);
Tim Petersf6b80452003-04-07 19:21:15 +0000421 gc_list_append(gc, finalizers);
422 gc->gc.gc_refs = GC_REACHABLE;
Jeremy Hyltonce136e92003-04-04 19:59:06 +0000423 }
Tim Peters403a2032003-11-20 21:21:46 +0000424 else if (PyWeakref_Check(op) &&
425 ((PyWeakReference *)op)->wr_callback) {
426 gc_list_remove(gc);
427 gc_list_append(gc, wr_callbacks);
428 gc->gc.gc_refs = GC_REACHABLE;
429 }
Tim Petersf6b80452003-04-07 19:21:15 +0000430 gc = next;
Jeremy Hyltonc5007aa2000-06-30 05:02:53 +0000431 }
432}
433
Tim Peters19b74c72002-07-01 03:52:19 +0000434/* A traversal callback for move_finalizer_reachable. */
435static int
436visit_move(PyObject *op, PyGC_Head *tolist)
437{
438 if (PyObject_IS_GC(op)) {
Tim Petersea405632002-07-02 00:52:30 +0000439 if (IS_TENTATIVELY_UNREACHABLE(op)) {
Tim Peters19b74c72002-07-01 03:52:19 +0000440 PyGC_Head *gc = AS_GC(op);
441 gc_list_remove(gc);
442 gc_list_append(gc, tolist);
443 gc->gc.gc_refs = GC_REACHABLE;
444 }
445 }
446 return 0;
447}
448
449/* Move objects that are reachable from finalizers, from the unreachable set
Tim Petersf6b80452003-04-07 19:21:15 +0000450 * into finalizers set.
Tim Peters19b74c72002-07-01 03:52:19 +0000451 */
Jeremy Hyltonc5007aa2000-06-30 05:02:53 +0000452static void
Tim Petersf6b80452003-04-07 19:21:15 +0000453move_finalizer_reachable(PyGC_Head *finalizers)
Jeremy Hyltonc5007aa2000-06-30 05:02:53 +0000454{
455 traverseproc traverse;
Tim Peters9e4ca102001-10-11 18:31:31 +0000456 PyGC_Head *gc = finalizers->gc.gc_next;
Tim Petersbf384c22003-04-06 00:11:39 +0000457 for (; gc != finalizers; gc = gc->gc.gc_next) {
458 /* Note that the finalizers list may grow during this. */
Neil Schemenauer43411b52001-08-30 00:05:51 +0000459 traverse = FROM_GC(gc)->ob_type->tp_traverse;
Tim Peters88396172002-06-30 17:56:40 +0000460 (void) traverse(FROM_GC(gc),
Tim Petersbf384c22003-04-06 00:11:39 +0000461 (visitproc)visit_move,
Tim Petersf6b80452003-04-07 19:21:15 +0000462 (void *)finalizers);
Jeremy Hyltonc5007aa2000-06-30 05:02:53 +0000463 }
464}
465
Tim Peters403a2032003-11-20 21:21:46 +0000466/* Clear all trash weakrefs with callbacks. This clears weakrefs first,
467 * which has the happy result of disabling the callbacks without executing
468 * them. A nasty technical complication: a weakref callback can itself be
469 * the target of a weakref, in which case decrefing the callback can cause
470 * another callback to trigger. But we can't allow arbitrary Python code to
471 * get executed at this point (the callback on the callback may try to muck
472 * with other cyclic trash we're trying to collect, even resurrecting it
473 * while we're in the middle of doing tp_clear() on the trash).
474 *
475 * The private _PyWeakref_ClearRef() function exists so that we can clear
476 * the reference in a weakref without triggering a callback on the callback.
477 *
478 * We have to save the callback objects and decref them later. But we can't
479 * allocate new memory to save them (if we can't get new memory, we're dead).
480 * So we grab a new reference on the clear'ed weakref, which prevents the
481 * rest of gc from reclaiming it. _PyWeakref_ClearRef() leaves the
482 * weakref's wr_callback member intact.
483 *
484 * In the end, then, wr_callbacks consists of cleared weakrefs that are
485 * immune from collection. Near the end of gc, after collecting all the
486 * cyclic trash, we call release_weakrefs(). That releases our references
487 * to the cleared weakrefs, which in turn may trigger callbacks on their
488 * callbacks.
489 */
490static void
491clear_weakrefs(PyGC_Head *wr_callbacks)
492{
493 PyGC_Head *gc = wr_callbacks->gc.gc_next;
494
495 for (; gc != wr_callbacks; gc = gc->gc.gc_next) {
496 PyObject *op = FROM_GC(gc);
497 PyWeakReference *wr;
498
499 assert(IS_REACHABLE(op));
500 assert(PyWeakref_Check(op));
501 wr = (PyWeakReference *)op;
502 assert(wr->wr_callback != NULL);
503 Py_INCREF(op);
504 _PyWeakref_ClearRef(wr);
505 }
506}
507
508/* Called near the end of gc. This gives up the references we own to
509 * cleared weakrefs, allowing them to get collected, and in turn decref'ing
510 * their callbacks.
511 *
512 * If a callback object is itself the target of a weakref callback,
513 * decref'ing the callback object may trigger that other callback. If
514 * that other callback was part of the cyclic trash in this generation,
515 * that won't happen, since we cleared *all* trash-weakref callbacks near
516 * the start of gc. If that other callback was not part of the cyclic trash
517 * in this generation, then it acted like an external root to this round
518 * of gc, so all the objects reachable from that callback are still alive.
519 *
520 * Giving up the references to the weakref objects will probably make
521 * them go away too. However, if a weakref is reachable from finalizers,
522 * it won't go away. We move it to the old generation then. Since a
523 * weakref object doesn't have a finalizer, that's the right thing to do (it
524 * doesn't belong in gc.garbage).
525 *
526 * We return the number of weakref objects freed (those not appended to old).
527 */
528static int
529release_weakrefs(PyGC_Head *wr_callbacks, PyGC_Head *old)
530{
531 int num_freed = 0;
532
533 while (! gc_list_is_empty(wr_callbacks)) {
534 PyGC_Head *gc = wr_callbacks->gc.gc_next;
535 PyObject *op = FROM_GC(gc);
Tim Peters403a2032003-11-20 21:21:46 +0000536
537 assert(IS_REACHABLE(op));
538 assert(PyWeakref_Check(op));
Guido van Rossum0bba7222003-11-24 04:02:13 +0000539 assert(((PyWeakReference *)op)->wr_callback != NULL);
Tim Peters403a2032003-11-20 21:21:46 +0000540 Py_DECREF(op);
541 if (wr_callbacks->gc.gc_next == gc) {
542 /* object is still alive -- move it */
543 gc_list_remove(gc);
544 gc_list_append(gc, old);
545 }
546 else
547 ++num_freed;
548 }
549 return num_freed;
550}
551
Jeremy Hyltonc5007aa2000-06-30 05:02:53 +0000552static void
Jeremy Hylton06257772000-08-31 15:10:24 +0000553debug_instance(char *msg, PyInstanceObject *inst)
Jeremy Hyltonc5007aa2000-06-30 05:02:53 +0000554{
Jeremy Hyltonc5007aa2000-06-30 05:02:53 +0000555 char *cname;
Neil Schemenauera765c122001-11-01 17:35:23 +0000556 /* simple version of instance_repr */
Jeremy Hyltonc5007aa2000-06-30 05:02:53 +0000557 PyObject *classname = inst->in_class->cl_name;
558 if (classname != NULL && PyString_Check(classname))
559 cname = PyString_AsString(classname);
560 else
561 cname = "?";
Jeremy Hylton06257772000-08-31 15:10:24 +0000562 PySys_WriteStderr("gc: %.100s <%.100s instance at %p>\n",
563 msg, cname, inst);
Jeremy Hyltonc5007aa2000-06-30 05:02:53 +0000564}
565
566static void
Jeremy Hylton06257772000-08-31 15:10:24 +0000567debug_cycle(char *msg, PyObject *op)
Jeremy Hyltonc5007aa2000-06-30 05:02:53 +0000568{
569 if ((debug & DEBUG_INSTANCES) && PyInstance_Check(op)) {
Jeremy Hylton06257772000-08-31 15:10:24 +0000570 debug_instance(msg, (PyInstanceObject *)op);
Neil Schemenauer544de1e2000-09-22 15:22:38 +0000571 }
572 else if (debug & DEBUG_OBJECTS) {
Jeremy Hylton06257772000-08-31 15:10:24 +0000573 PySys_WriteStderr("gc: %.100s <%.100s %p>\n",
574 msg, op->ob_type->tp_name, op);
Jeremy Hyltonc5007aa2000-06-30 05:02:53 +0000575 }
576}
577
Tim Petersbf384c22003-04-06 00:11:39 +0000578/* Handle uncollectable garbage (cycles with finalizers, and stuff reachable
579 * only from such cycles).
Tim Petersf6b80452003-04-07 19:21:15 +0000580 * If DEBUG_SAVEALL, all objects in finalizers are appended to the module
581 * garbage list (a Python list), else only the objects in finalizers with
582 * __del__ methods are appended to garbage. All objects in finalizers are
583 * merged into the old list regardless.
Tim Peters259272b2003-04-06 19:41:39 +0000584 * Returns 0 if all OK, <0 on error (out of memory to grow the garbage list).
585 * The finalizers list is made empty on a successful return.
Tim Petersbf384c22003-04-06 00:11:39 +0000586 */
Tim Peters259272b2003-04-06 19:41:39 +0000587static int
Tim Petersf6b80452003-04-07 19:21:15 +0000588handle_finalizers(PyGC_Head *finalizers, PyGC_Head *old)
Jeremy Hyltonc5007aa2000-06-30 05:02:53 +0000589{
Tim Petersf6b80452003-04-07 19:21:15 +0000590 PyGC_Head *gc = finalizers->gc.gc_next;
591
Jeremy Hyltonc5007aa2000-06-30 05:02:53 +0000592 if (garbage == NULL) {
593 garbage = PyList_New(0);
Tim Petersbf384c22003-04-06 00:11:39 +0000594 if (garbage == NULL)
595 Py_FatalError("gc couldn't create gc.garbage list");
Jeremy Hyltonc5007aa2000-06-30 05:02:53 +0000596 }
Tim Petersf6b80452003-04-07 19:21:15 +0000597 for (; gc != finalizers; gc = gc->gc.gc_next) {
598 PyObject *op = FROM_GC(gc);
599
600 if ((debug & DEBUG_SAVEALL) || has_finalizer(op)) {
601 if (PyList_Append(garbage, op) < 0)
602 return -1;
603 }
Jeremy Hyltonc5007aa2000-06-30 05:02:53 +0000604 }
Tim Petersf6b80452003-04-07 19:21:15 +0000605
Tim Peters259272b2003-04-06 19:41:39 +0000606 gc_list_merge(finalizers, old);
607 return 0;
Jeremy Hyltonc5007aa2000-06-30 05:02:53 +0000608}
609
Neil Schemenauer544de1e2000-09-22 15:22:38 +0000610/* Break reference cycles by clearing the containers involved. This is
Jeremy Hyltonc5007aa2000-06-30 05:02:53 +0000611 * tricky business as the lists can be changing and we don't know which
Tim Peters19b74c72002-07-01 03:52:19 +0000612 * objects may be freed. It is possible I screwed something up here.
613 */
Jeremy Hyltonc5007aa2000-06-30 05:02:53 +0000614static void
Jeremy Hyltonce136e92003-04-04 19:59:06 +0000615delete_garbage(PyGC_Head *collectable, PyGC_Head *old)
Jeremy Hyltonc5007aa2000-06-30 05:02:53 +0000616{
617 inquiry clear;
618
Jeremy Hyltonce136e92003-04-04 19:59:06 +0000619 while (!gc_list_is_empty(collectable)) {
620 PyGC_Head *gc = collectable->gc.gc_next;
Neil Schemenauer43411b52001-08-30 00:05:51 +0000621 PyObject *op = FROM_GC(gc);
Tim Peters88396172002-06-30 17:56:40 +0000622
Tim Peters19b74c72002-07-01 03:52:19 +0000623 assert(IS_TENTATIVELY_UNREACHABLE(op));
Neil Schemenauer544de1e2000-09-22 15:22:38 +0000624 if (debug & DEBUG_SAVEALL) {
625 PyList_Append(garbage, op);
Jeremy Hyltonc5007aa2000-06-30 05:02:53 +0000626 }
Neil Schemenauer544de1e2000-09-22 15:22:38 +0000627 else {
628 if ((clear = op->ob_type->tp_clear) != NULL) {
629 Py_INCREF(op);
Jeremy Hylton8a135182002-06-06 23:23:55 +0000630 clear(op);
Neil Schemenauer544de1e2000-09-22 15:22:38 +0000631 Py_DECREF(op);
632 }
633 }
Jeremy Hyltonce136e92003-04-04 19:59:06 +0000634 if (collectable->gc.gc_next == gc) {
Neil Schemenauer544de1e2000-09-22 15:22:38 +0000635 /* object is still alive, move it, it may die later */
Jeremy Hyltonc5007aa2000-06-30 05:02:53 +0000636 gc_list_remove(gc);
637 gc_list_append(gc, old);
Tim Peters19b74c72002-07-01 03:52:19 +0000638 gc->gc.gc_refs = GC_REACHABLE;
Jeremy Hyltonc5007aa2000-06-30 05:02:53 +0000639 }
640 }
641}
642
643/* This is the main function. Read this to understand how the
644 * collection process works. */
645static long
Neil Schemenauer2880ae52002-05-04 05:35:20 +0000646collect(int generation)
Jeremy Hyltonc5007aa2000-06-30 05:02:53 +0000647{
Neil Schemenauer2880ae52002-05-04 05:35:20 +0000648 int i;
Tim Peters19b74c72002-07-01 03:52:19 +0000649 long m = 0; /* # objects collected */
650 long n = 0; /* # unreachable objects that couldn't be collected */
Neil Schemenauer2880ae52002-05-04 05:35:20 +0000651 PyGC_Head *young; /* the generation we are examining */
652 PyGC_Head *old; /* next older generation */
Tim Peters403a2032003-11-20 21:21:46 +0000653 PyGC_Head unreachable; /* non-problematic unreachable trash */
654 PyGC_Head finalizers; /* objects with, & reachable from, __del__ */
655 PyGC_Head wr_callbacks; /* weakrefs with callbacks */
Jeremy Hyltonc5007aa2000-06-30 05:02:53 +0000656 PyGC_Head *gc;
Jeremy Hyltonc5007aa2000-06-30 05:02:53 +0000657
Tim Peters93ad66d2003-04-05 17:15:44 +0000658 if (delstr == NULL) {
659 delstr = PyString_InternFromString("__del__");
660 if (delstr == NULL)
661 Py_FatalError("gc couldn't allocate \"__del__\"");
662 }
663
Jeremy Hyltonc5007aa2000-06-30 05:02:53 +0000664 if (debug & DEBUG_STATS) {
Neil Schemenauer2880ae52002-05-04 05:35:20 +0000665 PySys_WriteStderr("gc: collecting generation %d...\n",
666 generation);
667 PySys_WriteStderr("gc: objects in each generation:");
668 for (i = 0; i < NUM_GENERATIONS; i++) {
669 PySys_WriteStderr(" %ld", gc_list_size(GEN_HEAD(i)));
670 }
671 PySys_WriteStderr("\n");
672 }
673
674 /* update collection and allocation counters */
675 if (generation+1 < NUM_GENERATIONS)
676 generations[generation+1].count += 1;
677 for (i = 0; i <= generation; i++)
Neil Schemenauerc9051642002-06-28 19:16:04 +0000678 generations[i].count = 0;
Neil Schemenauer2880ae52002-05-04 05:35:20 +0000679
680 /* merge younger generations with one we are currently collecting */
681 for (i = 0; i < generation; i++) {
682 gc_list_merge(GEN_HEAD(i), GEN_HEAD(generation));
683 }
684
685 /* handy references */
686 young = GEN_HEAD(generation);
Tim Peters19b74c72002-07-01 03:52:19 +0000687 if (generation < NUM_GENERATIONS-1)
Neil Schemenauer2880ae52002-05-04 05:35:20 +0000688 old = GEN_HEAD(generation+1);
Tim Peters19b74c72002-07-01 03:52:19 +0000689 else
690 old = young;
Jeremy Hyltonc5007aa2000-06-30 05:02:53 +0000691
692 /* Using ob_refcnt and gc_refs, calculate which objects in the
693 * container set are reachable from outside the set (ie. have a
694 * refcount greater than 0 when all the references within the
Tim Peters19b74c72002-07-01 03:52:19 +0000695 * set are taken into account
696 */
Jeremy Hyltonc5007aa2000-06-30 05:02:53 +0000697 update_refs(young);
698 subtract_refs(young);
699
Tim Peters19b74c72002-07-01 03:52:19 +0000700 /* Leave everything reachable from outside young in young, and move
701 * everything else (in young) to unreachable.
702 * NOTE: This used to move the reachable objects into a reachable
703 * set instead. But most things usually turn out to be reachable,
704 * so it's more efficient to move the unreachable things.
705 */
Jeremy Hyltonc5007aa2000-06-30 05:02:53 +0000706 gc_list_init(&unreachable);
Tim Peters19b74c72002-07-01 03:52:19 +0000707 move_unreachable(young, &unreachable);
Jeremy Hyltonc5007aa2000-06-30 05:02:53 +0000708
Tim Peters19b74c72002-07-01 03:52:19 +0000709 /* Move reachable objects to next generation. */
710 if (young != old)
711 gc_list_merge(young, old);
Jeremy Hyltonc5007aa2000-06-30 05:02:53 +0000712
Tim Peters19b74c72002-07-01 03:52:19 +0000713 /* All objects in unreachable are trash, but objects reachable from
714 * finalizers can't safely be deleted. Python programmers should take
715 * care not to create such things. For Python, finalizers means
Tim Peters403a2032003-11-20 21:21:46 +0000716 * instance objects with __del__ methods. Weakrefs with callbacks
717 * can call arbitrary Python code, so those are special-cased too.
Tim Peters93ad66d2003-04-05 17:15:44 +0000718 *
Tim Peters403a2032003-11-20 21:21:46 +0000719 * Move unreachable objects with finalizers, and weakrefs with
720 * callbacks, into different lists.
Tim Petersf6b80452003-04-07 19:21:15 +0000721 */
Jeremy Hyltonc5007aa2000-06-30 05:02:53 +0000722 gc_list_init(&finalizers);
Tim Peters403a2032003-11-20 21:21:46 +0000723 gc_list_init(&wr_callbacks);
724 move_troublemakers(&unreachable, &finalizers, &wr_callbacks);
725 /* Clear the trash weakrefs with callbacks. This prevents their
726 * callbacks from getting invoked (when a weakref goes away, so does
727 * its callback).
728 * We do this even if the weakrefs are reachable from finalizers.
729 * If we didn't, breaking cycles in unreachable later could trigger
730 * deallocation of objects in finalizers, which could in turn
731 * cause callbacks to trigger. This may not be ideal behavior.
732 */
733 clear_weakrefs(&wr_callbacks);
Tim Petersbf384c22003-04-06 00:11:39 +0000734 /* finalizers contains the unreachable objects with a finalizer;
Tim Peters403a2032003-11-20 21:21:46 +0000735 * unreachable objects reachable *from* those are also uncollectable,
736 * and we move those into the finalizers list too.
Tim Petersbf384c22003-04-06 00:11:39 +0000737 */
Tim Petersf6b80452003-04-07 19:21:15 +0000738 move_finalizer_reachable(&finalizers);
Jeremy Hyltonc5007aa2000-06-30 05:02:53 +0000739
740 /* Collect statistics on collectable objects found and print
Tim Peters403a2032003-11-20 21:21:46 +0000741 * debugging information.
742 */
Tim Petersf6b80452003-04-07 19:21:15 +0000743 for (gc = unreachable.gc.gc_next; gc != &unreachable;
Tim Peters9e4ca102001-10-11 18:31:31 +0000744 gc = gc->gc.gc_next) {
Jeremy Hyltonc5007aa2000-06-30 05:02:53 +0000745 m++;
Jeremy Hylton06257772000-08-31 15:10:24 +0000746 if (debug & DEBUG_COLLECTABLE) {
Neil Schemenauer43411b52001-08-30 00:05:51 +0000747 debug_cycle("collectable", FROM_GC(gc));
Jeremy Hyltonc5007aa2000-06-30 05:02:53 +0000748 }
749 }
Tim Petersfb2ab4d2003-04-07 22:41:24 +0000750 /* Call tp_clear on objects in the unreachable set. This will cause
751 * the reference cycles to be broken. It may also cause some objects
752 * in finalizers to be freed.
753 */
Tim Petersf6b80452003-04-07 19:21:15 +0000754 delete_garbage(&unreachable, old);
Jeremy Hyltonc5007aa2000-06-30 05:02:53 +0000755
Tim Peters403a2032003-11-20 21:21:46 +0000756 /* Now that we're done analyzing stuff and breaking cycles, let
757 * delayed weakref callbacks run.
758 */
759 m += release_weakrefs(&wr_callbacks, old);
760
Jeremy Hyltonc5007aa2000-06-30 05:02:53 +0000761 /* Collect statistics on uncollectable objects found and print
762 * debugging information. */
Tim Peters50c61d52003-04-06 01:50:50 +0000763 for (gc = finalizers.gc.gc_next;
Tim Petersbf384c22003-04-06 00:11:39 +0000764 gc != &finalizers;
765 gc = gc->gc.gc_next) {
Jeremy Hyltonc5007aa2000-06-30 05:02:53 +0000766 n++;
Tim Petersbf384c22003-04-06 00:11:39 +0000767 if (debug & DEBUG_UNCOLLECTABLE)
Neil Schemenauer43411b52001-08-30 00:05:51 +0000768 debug_cycle("uncollectable", FROM_GC(gc));
Tim Petersbf384c22003-04-06 00:11:39 +0000769 }
Jeremy Hylton06257772000-08-31 15:10:24 +0000770 if (debug & DEBUG_STATS) {
Jeremy Hyltonc5007aa2000-06-30 05:02:53 +0000771 if (m == 0 && n == 0) {
Jeremy Hylton06257772000-08-31 15:10:24 +0000772 PySys_WriteStderr("gc: done.\n");
Neil Schemenauer544de1e2000-09-22 15:22:38 +0000773 }
774 else {
Jeremy Hylton06257772000-08-31 15:10:24 +0000775 PySys_WriteStderr(
776 "gc: done, %ld unreachable, %ld uncollectable.\n",
777 n+m, n);
Jeremy Hyltonc5007aa2000-06-30 05:02:53 +0000778 }
779 }
780
781 /* Append instances in the uncollectable set to a Python
782 * reachable list of garbage. The programmer has to deal with
Tim Petersbf384c22003-04-06 00:11:39 +0000783 * this if they insist on creating this type of structure.
784 */
Tim Petersf6b80452003-04-07 19:21:15 +0000785 (void)handle_finalizers(&finalizers, old);
Jeremy Hyltonc5007aa2000-06-30 05:02:53 +0000786
Jeremy Hyltonb709df32000-09-01 02:47:25 +0000787 if (PyErr_Occurred()) {
Tim Petersf6b80452003-04-07 19:21:15 +0000788 if (gc_str == NULL)
Tim Petersfb2ab4d2003-04-07 22:41:24 +0000789 gc_str = PyString_FromString("garbage collection");
Jeremy Hyltonb709df32000-09-01 02:47:25 +0000790 PyErr_WriteUnraisable(gc_str);
791 Py_FatalError("unexpected exception during garbage collection");
792 }
Jeremy Hyltonc5007aa2000-06-30 05:02:53 +0000793 return n+m;
794}
795
796static long
797collect_generations(void)
798{
Neil Schemenauer2880ae52002-05-04 05:35:20 +0000799 int i;
Vladimir Marangozovb16714b2000-07-10 05:37:39 +0000800 long n = 0;
Jeremy Hyltonc5007aa2000-06-30 05:02:53 +0000801
Neil Schemenauer2880ae52002-05-04 05:35:20 +0000802 /* Find the oldest generation (higest numbered) where the count
803 * exceeds the threshold. Objects in the that generation and
804 * generations younger than it will be collected. */
805 for (i = NUM_GENERATIONS-1; i >= 0; i--) {
806 if (generations[i].count > generations[i].threshold) {
807 n = collect(i);
808 break;
Jeremy Hyltonc5007aa2000-06-30 05:02:53 +0000809 }
810 }
811 return n;
812}
813
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +0000814PyDoc_STRVAR(gc_enable__doc__,
Vladimir Marangozovf9d20c32000-08-06 22:45:31 +0000815"enable() -> None\n"
816"\n"
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +0000817"Enable automatic garbage collection.\n");
Jeremy Hyltonc5007aa2000-06-30 05:02:53 +0000818
Vladimir Marangozovf9d20c32000-08-06 22:45:31 +0000819static PyObject *
Tim Peters50c61d52003-04-06 01:50:50 +0000820gc_enable(PyObject *self, PyObject *noargs)
Vladimir Marangozovf9d20c32000-08-06 22:45:31 +0000821{
Vladimir Marangozovf9d20c32000-08-06 22:45:31 +0000822 enabled = 1;
Vladimir Marangozovf9d20c32000-08-06 22:45:31 +0000823 Py_INCREF(Py_None);
824 return Py_None;
825}
826
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +0000827PyDoc_STRVAR(gc_disable__doc__,
Vladimir Marangozovf9d20c32000-08-06 22:45:31 +0000828"disable() -> None\n"
829"\n"
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +0000830"Disable automatic garbage collection.\n");
Vladimir Marangozovf9d20c32000-08-06 22:45:31 +0000831
832static PyObject *
Tim Peters50c61d52003-04-06 01:50:50 +0000833gc_disable(PyObject *self, PyObject *noargs)
Vladimir Marangozovf9d20c32000-08-06 22:45:31 +0000834{
Vladimir Marangozovf9d20c32000-08-06 22:45:31 +0000835 enabled = 0;
Vladimir Marangozovf9d20c32000-08-06 22:45:31 +0000836 Py_INCREF(Py_None);
837 return Py_None;
838}
839
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +0000840PyDoc_STRVAR(gc_isenabled__doc__,
Vladimir Marangozovf9d20c32000-08-06 22:45:31 +0000841"isenabled() -> status\n"
842"\n"
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +0000843"Returns true if automatic garbage collection is enabled.\n");
Vladimir Marangozovf9d20c32000-08-06 22:45:31 +0000844
845static PyObject *
Tim Peters50c61d52003-04-06 01:50:50 +0000846gc_isenabled(PyObject *self, PyObject *noargs)
Vladimir Marangozovf9d20c32000-08-06 22:45:31 +0000847{
Raymond Hettinger674d56b2004-01-04 04:00:13 +0000848 return PyBool_FromLong((long)enabled);
Vladimir Marangozovf9d20c32000-08-06 22:45:31 +0000849}
850
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +0000851PyDoc_STRVAR(gc_collect__doc__,
Jeremy Hyltonc5007aa2000-06-30 05:02:53 +0000852"collect() -> n\n"
853"\n"
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +0000854"Run a full collection. The number of unreachable objects is returned.\n");
Jeremy Hyltonc5007aa2000-06-30 05:02:53 +0000855
856static PyObject *
Tim Peters50c61d52003-04-06 01:50:50 +0000857gc_collect(PyObject *self, PyObject *noargs)
Jeremy Hyltonc5007aa2000-06-30 05:02:53 +0000858{
859 long n;
860
Tim Peters50c61d52003-04-06 01:50:50 +0000861 if (collecting)
Neil Schemenauere8c40cb2001-10-31 23:09:35 +0000862 n = 0; /* already collecting, don't do anything */
Neil Schemenauere8c40cb2001-10-31 23:09:35 +0000863 else {
864 collecting = 1;
Neil Schemenauer2880ae52002-05-04 05:35:20 +0000865 n = collect(NUM_GENERATIONS - 1);
Neil Schemenauere8c40cb2001-10-31 23:09:35 +0000866 collecting = 0;
867 }
Jeremy Hyltonc5007aa2000-06-30 05:02:53 +0000868
Neil Schemenauer7760cff2000-09-22 22:35:36 +0000869 return Py_BuildValue("l", n);
Jeremy Hyltonc5007aa2000-06-30 05:02:53 +0000870}
871
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +0000872PyDoc_STRVAR(gc_set_debug__doc__,
Jeremy Hyltonc5007aa2000-06-30 05:02:53 +0000873"set_debug(flags) -> None\n"
874"\n"
875"Set the garbage collection debugging flags. Debugging information is\n"
876"written to sys.stderr.\n"
877"\n"
878"flags is an integer and can have the following bits turned on:\n"
879"\n"
880" DEBUG_STATS - Print statistics during collection.\n"
881" DEBUG_COLLECTABLE - Print collectable objects found.\n"
882" DEBUG_UNCOLLECTABLE - Print unreachable but uncollectable objects found.\n"
883" DEBUG_INSTANCES - Print instance objects.\n"
884" DEBUG_OBJECTS - Print objects other than instances.\n"
Neil Schemenauer544de1e2000-09-22 15:22:38 +0000885" DEBUG_SAVEALL - Save objects to gc.garbage rather than freeing them.\n"
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +0000886" DEBUG_LEAK - Debug leaking programs (everything but STATS).\n");
Jeremy Hyltonc5007aa2000-06-30 05:02:53 +0000887
888static PyObject *
Vladimir Marangozovf9d20c32000-08-06 22:45:31 +0000889gc_set_debug(PyObject *self, PyObject *args)
Jeremy Hyltonc5007aa2000-06-30 05:02:53 +0000890{
Neil Schemenauer7760cff2000-09-22 22:35:36 +0000891 if (!PyArg_ParseTuple(args, "i:set_debug", &debug))
Jeremy Hyltonc5007aa2000-06-30 05:02:53 +0000892 return NULL;
893
894 Py_INCREF(Py_None);
895 return Py_None;
896}
897
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +0000898PyDoc_STRVAR(gc_get_debug__doc__,
Jeremy Hyltonc5007aa2000-06-30 05:02:53 +0000899"get_debug() -> flags\n"
900"\n"
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +0000901"Get the garbage collection debugging flags.\n");
Jeremy Hyltonc5007aa2000-06-30 05:02:53 +0000902
903static PyObject *
Tim Peters50c61d52003-04-06 01:50:50 +0000904gc_get_debug(PyObject *self, PyObject *noargs)
Jeremy Hyltonc5007aa2000-06-30 05:02:53 +0000905{
Jeremy Hyltonc5007aa2000-06-30 05:02:53 +0000906 return Py_BuildValue("i", debug);
907}
908
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +0000909PyDoc_STRVAR(gc_set_thresh__doc__,
Neal Norwitz2a47c0f2002-01-29 00:53:41 +0000910"set_threshold(threshold0, [threshold1, threshold2]) -> None\n"
Jeremy Hyltonc5007aa2000-06-30 05:02:53 +0000911"\n"
912"Sets the collection thresholds. Setting threshold0 to zero disables\n"
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +0000913"collection.\n");
Jeremy Hyltonc5007aa2000-06-30 05:02:53 +0000914
915static PyObject *
Vladimir Marangozovf9d20c32000-08-06 22:45:31 +0000916gc_set_thresh(PyObject *self, PyObject *args)
Jeremy Hyltonc5007aa2000-06-30 05:02:53 +0000917{
Neil Schemenauer2880ae52002-05-04 05:35:20 +0000918 int i;
919 if (!PyArg_ParseTuple(args, "i|ii:set_threshold",
920 &generations[0].threshold,
921 &generations[1].threshold,
922 &generations[2].threshold))
Jeremy Hyltonc5007aa2000-06-30 05:02:53 +0000923 return NULL;
Neil Schemenauer2880ae52002-05-04 05:35:20 +0000924 for (i = 2; i < NUM_GENERATIONS; i++) {
925 /* generations higher than 2 get the same threshold */
926 generations[i].threshold = generations[2].threshold;
927 }
Jeremy Hyltonc5007aa2000-06-30 05:02:53 +0000928
929 Py_INCREF(Py_None);
930 return Py_None;
931}
932
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +0000933PyDoc_STRVAR(gc_get_thresh__doc__,
Jeremy Hyltonc5007aa2000-06-30 05:02:53 +0000934"get_threshold() -> (threshold0, threshold1, threshold2)\n"
935"\n"
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +0000936"Return the current collection thresholds\n");
Jeremy Hyltonc5007aa2000-06-30 05:02:53 +0000937
938static PyObject *
Tim Peters50c61d52003-04-06 01:50:50 +0000939gc_get_thresh(PyObject *self, PyObject *noargs)
Jeremy Hyltonc5007aa2000-06-30 05:02:53 +0000940{
Neil Schemenauer2880ae52002-05-04 05:35:20 +0000941 return Py_BuildValue("(iii)",
942 generations[0].threshold,
943 generations[1].threshold,
944 generations[2].threshold);
Jeremy Hyltonc5007aa2000-06-30 05:02:53 +0000945}
946
Neil Schemenauer48c70342001-08-09 15:38:31 +0000947static int
Martin v. Löwis560da622001-11-24 09:24:51 +0000948referrersvisit(PyObject* obj, PyObject *objs)
Neil Schemenauer48c70342001-08-09 15:38:31 +0000949{
Martin v. Löwisc8fe77b2001-11-29 18:08:31 +0000950 int i;
951 for (i = 0; i < PyTuple_GET_SIZE(objs); i++)
952 if (PyTuple_GET_ITEM(objs, i) == obj)
953 return 1;
Neil Schemenauer48c70342001-08-09 15:38:31 +0000954 return 0;
955}
956
Neil Schemenauer17e7be62001-08-10 14:46:47 +0000957static int
Martin v. Löwis560da622001-11-24 09:24:51 +0000958gc_referrers_for(PyObject *objs, PyGC_Head *list, PyObject *resultlist)
Neil Schemenauer48c70342001-08-09 15:38:31 +0000959{
960 PyGC_Head *gc;
961 PyObject *obj;
962 traverseproc traverse;
Tim Peters9e4ca102001-10-11 18:31:31 +0000963 for (gc = list->gc.gc_next; gc != list; gc = gc->gc.gc_next) {
Neil Schemenauer43411b52001-08-30 00:05:51 +0000964 obj = FROM_GC(gc);
Neil Schemenauer48c70342001-08-09 15:38:31 +0000965 traverse = obj->ob_type->tp_traverse;
966 if (obj == objs || obj == resultlist)
967 continue;
Martin v. Löwis560da622001-11-24 09:24:51 +0000968 if (traverse(obj, (visitproc)referrersvisit, objs)) {
Neil Schemenauer17e7be62001-08-10 14:46:47 +0000969 if (PyList_Append(resultlist, obj) < 0)
970 return 0; /* error */
Neil Schemenauer48c70342001-08-09 15:38:31 +0000971 }
972 }
Neil Schemenauer17e7be62001-08-10 14:46:47 +0000973 return 1; /* no error */
Neil Schemenauer48c70342001-08-09 15:38:31 +0000974}
975
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +0000976PyDoc_STRVAR(gc_get_referrers__doc__,
Martin v. Löwis560da622001-11-24 09:24:51 +0000977"get_referrers(*objs) -> list\n\
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +0000978Return the list of objects that directly refer to any of objs.");
Neil Schemenauer48c70342001-08-09 15:38:31 +0000979
Neil Schemenauer17e7be62001-08-10 14:46:47 +0000980static PyObject *
Martin v. Löwis560da622001-11-24 09:24:51 +0000981gc_get_referrers(PyObject *self, PyObject *args)
Neil Schemenauer48c70342001-08-09 15:38:31 +0000982{
Neil Schemenauer2880ae52002-05-04 05:35:20 +0000983 int i;
Neil Schemenauer48c70342001-08-09 15:38:31 +0000984 PyObject *result = PyList_New(0);
Neil Schemenauer2880ae52002-05-04 05:35:20 +0000985 for (i = 0; i < NUM_GENERATIONS; i++) {
986 if (!(gc_referrers_for(args, GEN_HEAD(i), result))) {
987 Py_DECREF(result);
988 return NULL;
989 }
Neil Schemenauer17e7be62001-08-10 14:46:47 +0000990 }
Neil Schemenauer48c70342001-08-09 15:38:31 +0000991 return result;
992}
Jeremy Hyltonc5007aa2000-06-30 05:02:53 +0000993
Tim Peters0f81ab62003-04-08 16:39:48 +0000994/* Append obj to list; return true if error (out of memory), false if OK. */
Jeremy Hylton5bd378b2003-04-03 16:28:38 +0000995static int
Tim Peters730f5532003-04-08 17:17:17 +0000996referentsvisit(PyObject *obj, PyObject *list)
Jeremy Hylton5bd378b2003-04-03 16:28:38 +0000997{
Tim Peters0f81ab62003-04-08 16:39:48 +0000998 return PyList_Append(list, obj) < 0;
Jeremy Hylton5bd378b2003-04-03 16:28:38 +0000999}
1000
Tim Peters730f5532003-04-08 17:17:17 +00001001PyDoc_STRVAR(gc_get_referents__doc__,
1002"get_referents(*objs) -> list\n\
Jeremy Hylton059b0942003-04-03 16:29:13 +00001003Return the list of objects that are directly referred to by objs.");
Jeremy Hylton5bd378b2003-04-03 16:28:38 +00001004
1005static PyObject *
Tim Peters730f5532003-04-08 17:17:17 +00001006gc_get_referents(PyObject *self, PyObject *args)
Jeremy Hylton5bd378b2003-04-03 16:28:38 +00001007{
1008 int i;
1009 PyObject *result = PyList_New(0);
Tim Peters0f81ab62003-04-08 16:39:48 +00001010
1011 if (result == NULL)
1012 return NULL;
1013
Jeremy Hylton5bd378b2003-04-03 16:28:38 +00001014 for (i = 0; i < PyTuple_GET_SIZE(args); i++) {
Tim Peters0f81ab62003-04-08 16:39:48 +00001015 traverseproc traverse;
Tim Peters93ad66d2003-04-05 17:15:44 +00001016 PyObject *obj = PyTuple_GET_ITEM(args, i);
Tim Peters0f81ab62003-04-08 16:39:48 +00001017
1018 if (! PyObject_IS_GC(obj))
Jeremy Hylton5bd378b2003-04-03 16:28:38 +00001019 continue;
Tim Peters0f81ab62003-04-08 16:39:48 +00001020 traverse = obj->ob_type->tp_traverse;
1021 if (! traverse)
1022 continue;
Tim Peters730f5532003-04-08 17:17:17 +00001023 if (traverse(obj, (visitproc)referentsvisit, result)) {
Tim Peters0f81ab62003-04-08 16:39:48 +00001024 Py_DECREF(result);
Jeremy Hylton5bd378b2003-04-03 16:28:38 +00001025 return NULL;
Tim Peters0f81ab62003-04-08 16:39:48 +00001026 }
Jeremy Hylton5bd378b2003-04-03 16:28:38 +00001027 }
1028 return result;
1029}
1030
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00001031PyDoc_STRVAR(gc_get_objects__doc__,
Neil Schemenauerc7c8d8e2001-08-09 15:58:59 +00001032"get_objects() -> [...]\n"
1033"\n"
1034"Return a list of objects tracked by the collector (excluding the list\n"
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00001035"returned).\n");
Neil Schemenauerc7c8d8e2001-08-09 15:58:59 +00001036
Neil Schemenauerc7c8d8e2001-08-09 15:58:59 +00001037static PyObject *
Tim Peters50c61d52003-04-06 01:50:50 +00001038gc_get_objects(PyObject *self, PyObject *noargs)
Neil Schemenauerc7c8d8e2001-08-09 15:58:59 +00001039{
Neil Schemenauer2880ae52002-05-04 05:35:20 +00001040 int i;
Neil Schemenauerc7c8d8e2001-08-09 15:58:59 +00001041 PyObject* result;
1042
Neil Schemenauerc7c8d8e2001-08-09 15:58:59 +00001043 result = PyList_New(0);
Tim Peters50c61d52003-04-06 01:50:50 +00001044 if (result == NULL)
Martin v. Löwisf8a6f242001-12-02 18:31:02 +00001045 return NULL;
Neil Schemenauer2880ae52002-05-04 05:35:20 +00001046 for (i = 0; i < NUM_GENERATIONS; i++) {
1047 if (append_objects(result, GEN_HEAD(i))) {
1048 Py_DECREF(result);
1049 return NULL;
1050 }
Martin v. Löwis155aad12001-12-02 12:21:34 +00001051 }
Neil Schemenauerc7c8d8e2001-08-09 15:58:59 +00001052 return result;
1053}
1054
1055
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00001056PyDoc_STRVAR(gc__doc__,
Jeremy Hyltonc5007aa2000-06-30 05:02:53 +00001057"This module provides access to the garbage collector for reference cycles.\n"
1058"\n"
Vladimir Marangozovf9d20c32000-08-06 22:45:31 +00001059"enable() -- Enable automatic garbage collection.\n"
1060"disable() -- Disable automatic garbage collection.\n"
1061"isenabled() -- Returns true if automatic collection is enabled.\n"
Jeremy Hyltonc5007aa2000-06-30 05:02:53 +00001062"collect() -- Do a full collection right now.\n"
1063"set_debug() -- Set debugging flags.\n"
1064"get_debug() -- Get debugging flags.\n"
1065"set_threshold() -- Set the collection thresholds.\n"
1066"get_threshold() -- Return the current the collection thresholds.\n"
Neil Schemenauerc7c8d8e2001-08-09 15:58:59 +00001067"get_objects() -- Return a list of all objects tracked by the collector.\n"
Jeremy Hylton5bd378b2003-04-03 16:28:38 +00001068"get_referrers() -- Return the list of objects that refer to an object.\n"
Tim Peters730f5532003-04-08 17:17:17 +00001069"get_referents() -- Return the list of objects that an object refers to.\n");
Jeremy Hyltonc5007aa2000-06-30 05:02:53 +00001070
1071static PyMethodDef GcMethods[] = {
Tim Peters50c61d52003-04-06 01:50:50 +00001072 {"enable", gc_enable, METH_NOARGS, gc_enable__doc__},
1073 {"disable", gc_disable, METH_NOARGS, gc_disable__doc__},
1074 {"isenabled", gc_isenabled, METH_NOARGS, gc_isenabled__doc__},
Vladimir Marangozovf9d20c32000-08-06 22:45:31 +00001075 {"set_debug", gc_set_debug, METH_VARARGS, gc_set_debug__doc__},
Tim Peters50c61d52003-04-06 01:50:50 +00001076 {"get_debug", gc_get_debug, METH_NOARGS, gc_get_debug__doc__},
Vladimir Marangozovf9d20c32000-08-06 22:45:31 +00001077 {"set_threshold", gc_set_thresh, METH_VARARGS, gc_set_thresh__doc__},
Tim Peters50c61d52003-04-06 01:50:50 +00001078 {"get_threshold", gc_get_thresh, METH_NOARGS, gc_get_thresh__doc__},
1079 {"collect", gc_collect, METH_NOARGS, gc_collect__doc__},
1080 {"get_objects", gc_get_objects,METH_NOARGS, gc_get_objects__doc__},
Martin v. Löwis560da622001-11-24 09:24:51 +00001081 {"get_referrers", gc_get_referrers, METH_VARARGS,
1082 gc_get_referrers__doc__},
Tim Peters730f5532003-04-08 17:17:17 +00001083 {"get_referents", gc_get_referents, METH_VARARGS,
1084 gc_get_referents__doc__},
Jeremy Hyltonc5007aa2000-06-30 05:02:53 +00001085 {NULL, NULL} /* Sentinel */
1086};
1087
Jason Tishler6bc06ec2003-09-04 11:59:50 +00001088PyMODINIT_FUNC
Jeremy Hyltonc5007aa2000-06-30 05:02:53 +00001089initgc(void)
1090{
1091 PyObject *m;
Jeremy Hyltonc5007aa2000-06-30 05:02:53 +00001092
1093 m = Py_InitModule4("gc",
1094 GcMethods,
1095 gc__doc__,
1096 NULL,
1097 PYTHON_API_VERSION);
Tim Peters11558872003-04-06 23:30:52 +00001098
Jeremy Hyltonc5007aa2000-06-30 05:02:53 +00001099 if (garbage == NULL) {
1100 garbage = PyList_New(0);
Tim Peters11558872003-04-06 23:30:52 +00001101 if (garbage == NULL)
1102 return;
Jeremy Hyltonc5007aa2000-06-30 05:02:53 +00001103 }
Tim Peters11558872003-04-06 23:30:52 +00001104 if (PyModule_AddObject(m, "garbage", garbage) < 0)
1105 return;
1106#define ADD_INT(NAME) if (PyModule_AddIntConstant(m, #NAME, NAME) < 0) return
1107 ADD_INT(DEBUG_STATS);
1108 ADD_INT(DEBUG_COLLECTABLE);
1109 ADD_INT(DEBUG_UNCOLLECTABLE);
1110 ADD_INT(DEBUG_INSTANCES);
1111 ADD_INT(DEBUG_OBJECTS);
1112 ADD_INT(DEBUG_SAVEALL);
1113 ADD_INT(DEBUG_LEAK);
1114#undef ADD_INT
Jeremy Hyltonc5007aa2000-06-30 05:02:53 +00001115}
1116
Guido van Rossume13ddc92003-04-17 17:29:22 +00001117/* API to invoke gc.collect() from C */
1118long
1119PyGC_Collect(void)
1120{
1121 long n;
1122
1123 if (collecting)
1124 n = 0; /* already collecting, don't do anything */
1125 else {
1126 collecting = 1;
1127 n = collect(NUM_GENERATIONS - 1);
1128 collecting = 0;
1129 }
1130
1131 return n;
1132}
1133
Neil Schemenauer43411b52001-08-30 00:05:51 +00001134/* for debugging */
Guido van Rossume13ddc92003-04-17 17:29:22 +00001135void
1136_PyGC_Dump(PyGC_Head *g)
Neil Schemenauer43411b52001-08-30 00:05:51 +00001137{
1138 _PyObject_Dump(FROM_GC(g));
1139}
1140
Neil Schemenauer43411b52001-08-30 00:05:51 +00001141/* extension modules might be compiled with GC support so these
1142 functions must always be available */
1143
Neil Schemenauerfec4eb12002-04-12 02:41:03 +00001144#undef PyObject_GC_Track
1145#undef PyObject_GC_UnTrack
1146#undef PyObject_GC_Del
1147#undef _PyObject_GC_Malloc
1148
Neil Schemenauer43411b52001-08-30 00:05:51 +00001149void
Neil Schemenauerfec4eb12002-04-12 02:41:03 +00001150PyObject_GC_Track(void *op)
Neil Schemenauer43411b52001-08-30 00:05:51 +00001151{
1152 _PyObject_GC_TRACK(op);
1153}
1154
Neil Schemenauerfec4eb12002-04-12 02:41:03 +00001155/* for binary compatibility with 2.2 */
Neil Schemenauer43411b52001-08-30 00:05:51 +00001156void
Neil Schemenauerfec4eb12002-04-12 02:41:03 +00001157_PyObject_GC_Track(PyObject *op)
1158{
1159 PyObject_GC_Track(op);
1160}
1161
1162void
1163PyObject_GC_UnTrack(void *op)
Neil Schemenauer43411b52001-08-30 00:05:51 +00001164{
Tim Peters803526b2002-07-07 05:13:56 +00001165 /* Obscure: the Py_TRASHCAN mechanism requires that we be able to
1166 * call PyObject_GC_UnTrack twice on an object.
1167 */
Neil Schemenauera2b11ec2002-05-21 15:53:24 +00001168 if (IS_TRACKED(op))
Guido van Rossumff413af2002-03-28 20:34:59 +00001169 _PyObject_GC_UNTRACK(op);
Neil Schemenauer43411b52001-08-30 00:05:51 +00001170}
1171
Neil Schemenauerfec4eb12002-04-12 02:41:03 +00001172/* for binary compatibility with 2.2 */
1173void
1174_PyObject_GC_UnTrack(PyObject *op)
1175{
1176 PyObject_GC_UnTrack(op);
1177}
1178
Neil Schemenauer43411b52001-08-30 00:05:51 +00001179PyObject *
Neil Schemenauerfec4eb12002-04-12 02:41:03 +00001180_PyObject_GC_Malloc(size_t basicsize)
Neil Schemenauer43411b52001-08-30 00:05:51 +00001181{
1182 PyObject *op;
Neil Schemenauerfec4eb12002-04-12 02:41:03 +00001183 PyGC_Head *g = PyObject_MALLOC(sizeof(PyGC_Head) + basicsize);
Neil Schemenauer43411b52001-08-30 00:05:51 +00001184 if (g == NULL)
Jeremy Hylton8a135182002-06-06 23:23:55 +00001185 return PyErr_NoMemory();
Tim Petersea405632002-07-02 00:52:30 +00001186 g->gc.gc_refs = GC_UNTRACKED;
Neil Schemenauer2880ae52002-05-04 05:35:20 +00001187 generations[0].count++; /* number of allocated GC objects */
1188 if (generations[0].count > generations[0].threshold &&
Neil Schemenauer43411b52001-08-30 00:05:51 +00001189 enabled &&
Neil Schemenauer2880ae52002-05-04 05:35:20 +00001190 generations[0].threshold &&
Neil Schemenauer43411b52001-08-30 00:05:51 +00001191 !collecting &&
1192 !PyErr_Occurred()) {
1193 collecting = 1;
Neil Schemenauer2880ae52002-05-04 05:35:20 +00001194 collect_generations();
Neil Schemenauer43411b52001-08-30 00:05:51 +00001195 collecting = 0;
1196 }
1197 op = FROM_GC(g);
Neil Schemenauer43411b52001-08-30 00:05:51 +00001198 return op;
1199}
1200
1201PyObject *
1202_PyObject_GC_New(PyTypeObject *tp)
1203{
Neil Schemenauerfec4eb12002-04-12 02:41:03 +00001204 PyObject *op = _PyObject_GC_Malloc(_PyObject_SIZE(tp));
Tim Petersfa8efab2002-04-28 01:57:25 +00001205 if (op != NULL)
1206 op = PyObject_INIT(op, tp);
1207 return op;
Neil Schemenauer43411b52001-08-30 00:05:51 +00001208}
1209
1210PyVarObject *
Tim Peters6d483d32001-10-06 21:27:34 +00001211_PyObject_GC_NewVar(PyTypeObject *tp, int nitems)
Neil Schemenauer43411b52001-08-30 00:05:51 +00001212{
Neil Schemenauerfec4eb12002-04-12 02:41:03 +00001213 const size_t size = _PyObject_VAR_SIZE(tp, nitems);
1214 PyVarObject *op = (PyVarObject *) _PyObject_GC_Malloc(size);
Tim Petersfa8efab2002-04-28 01:57:25 +00001215 if (op != NULL)
1216 op = PyObject_INIT_VAR(op, tp, nitems);
1217 return op;
Neil Schemenauer43411b52001-08-30 00:05:51 +00001218}
1219
1220PyVarObject *
Tim Peters6d483d32001-10-06 21:27:34 +00001221_PyObject_GC_Resize(PyVarObject *op, int nitems)
Neil Schemenauer43411b52001-08-30 00:05:51 +00001222{
Tim Petersf2a67da2001-10-07 03:54:51 +00001223 const size_t basicsize = _PyObject_VAR_SIZE(op->ob_type, nitems);
Neil Schemenauer43411b52001-08-30 00:05:51 +00001224 PyGC_Head *g = AS_GC(op);
Neil Schemenauerfec4eb12002-04-12 02:41:03 +00001225 g = PyObject_REALLOC(g, sizeof(PyGC_Head) + basicsize);
Neil Schemenauer43411b52001-08-30 00:05:51 +00001226 if (g == NULL)
1227 return (PyVarObject *)PyErr_NoMemory();
1228 op = (PyVarObject *) FROM_GC(g);
Tim Peters6d483d32001-10-06 21:27:34 +00001229 op->ob_size = nitems;
Neil Schemenauer43411b52001-08-30 00:05:51 +00001230 return op;
1231}
1232
1233void
Neil Schemenauerfec4eb12002-04-12 02:41:03 +00001234PyObject_GC_Del(void *op)
Neil Schemenauer43411b52001-08-30 00:05:51 +00001235{
Neil Schemenauer43411b52001-08-30 00:05:51 +00001236 PyGC_Head *g = AS_GC(op);
Neil Schemenauera2b11ec2002-05-21 15:53:24 +00001237 if (IS_TRACKED(op))
Neil Schemenauer43411b52001-08-30 00:05:51 +00001238 gc_list_remove(g);
Neil Schemenauer2880ae52002-05-04 05:35:20 +00001239 if (generations[0].count > 0) {
1240 generations[0].count--;
Neil Schemenauer43411b52001-08-30 00:05:51 +00001241 }
Neil Schemenauerfec4eb12002-04-12 02:41:03 +00001242 PyObject_FREE(g);
Neil Schemenauer43411b52001-08-30 00:05:51 +00001243}
1244
Neil Schemenauerfec4eb12002-04-12 02:41:03 +00001245/* for binary compatibility with 2.2 */
1246#undef _PyObject_GC_Del
1247void
1248_PyObject_GC_Del(PyObject *op)
1249{
1250 PyObject_GC_Del(op);
1251}