Mercurial > cpython-lru_cache-weakref

annotate Modules/gcmodule.c @ 32527:0da660e05e69 legacy-trunk

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
"#if WITH_THREAD" is incorrect; must be #ifdef instead; WITH_THREAD isn't always set to an integer value when it's defined.
author Tim Peters <tim.peters@gmail.com>
date Wed, 07 Jul 2004 20:42:07 +0000
parents 4915fbec608f
children facb5a2f4b53
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
rev   line source
13183
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
1 /*
24072
86b3760d285d SF bug #574132: Major GC related performance regression
Tim Peters <tim.peters@gmail.com>
parents: 24036
diff changeset
2
13183
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
3 Reference Cycle Garbage Collection
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
4 ==================================
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
5
15013
25bc16952a24 - update Neil's email address
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 15012
diff changeset
6 Neil Schemenauer <nas@arctrix.com>
13183
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
7
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
8 Based on a post on the python-dev list. Ideas from Guido van Rossum,
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
9 Eric Tiedemann, and various others.
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
10
19585
c43d7a8f00a4 Make more things internal to this file. Remove
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 19128
diff changeset
11 http://www.arctrix.com/nas/python/gc/
13183
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
12 http://www.python.org/pipermail/python-dev/2000-March/003869.html
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
13 http://www.python.org/pipermail/python-dev/2000-March/004010.html
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
14 http://www.python.org/pipermail/python-dev/2000-March/004022.html
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
15
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
16 For a highlevel view of the collection process, read the collect
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
17 function.
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
18
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
19 */
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
20
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
21 #include "Python.h"
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
22
19585
c43d7a8f00a4 Make more things internal to this file. Remove
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 19128
diff changeset
23 /* Get an object's GC head */
c43d7a8f00a4 Make more things internal to this file. Remove
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 19128
diff changeset
24 #define AS_GC(o) ((PyGC_Head *)(o)-1)
c43d7a8f00a4 Make more things internal to this file. Remove
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 19128
diff changeset
25
c43d7a8f00a4 Make more things internal to this file. Remove
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 19128
diff changeset
26 /* Get the object given the GC head */
c43d7a8f00a4 Make more things internal to this file. Remove
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 19128
diff changeset
27 #define FROM_GC(g) ((PyObject *)(((PyGC_Head *)g)+1))
c43d7a8f00a4 Make more things internal to this file. Remove
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 19128
diff changeset
28
13183
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
29 /*** Global GC state ***/
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
30
23377
2f7d869dad4d Move all data for a single generation into a structure. The set of
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 23296
diff changeset
31 struct gc_generation {
2f7d869dad4d Move all data for a single generation into a structure. The set of
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 23296
diff changeset
32 PyGC_Head head;
2f7d869dad4d Move all data for a single generation into a structure. The set of
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 23296
diff changeset
33 int threshold; /* collection threshold */
2f7d869dad4d Move all data for a single generation into a structure. The set of
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 23296
diff changeset
34 int count; /* count of allocations or collections of younger
2f7d869dad4d Move all data for a single generation into a structure. The set of
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 23296
diff changeset
35 generations */
2f7d869dad4d Move all data for a single generation into a structure. The set of
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 23296
diff changeset
36 };
2f7d869dad4d Move all data for a single generation into a structure. The set of
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 23296
diff changeset
37
2f7d869dad4d Move all data for a single generation into a structure. The set of
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 23296
diff changeset
38 #define NUM_GENERATIONS 3
2f7d869dad4d Move all data for a single generation into a structure. The set of
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 23296
diff changeset
39 #define GEN_HEAD(n) (&generations[n].head)
13183
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
40
23377
2f7d869dad4d Move all data for a single generation into a structure. The set of
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 23296
diff changeset
41 /* linked lists of container objects */
2f7d869dad4d Move all data for a single generation into a structure. The set of
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 23296
diff changeset
42 static struct gc_generation generations[NUM_GENERATIONS] = {
2f7d869dad4d Move all data for a single generation into a structure. The set of
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 23296
diff changeset
43 /* PyGC_Head, threshold, count */
2f7d869dad4d Move all data for a single generation into a structure. The set of
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 23296
diff changeset
44 {{{GEN_HEAD(0), GEN_HEAD(0), 0}}, 700, 0},
2f7d869dad4d Move all data for a single generation into a structure. The set of
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 23296
diff changeset
45 {{{GEN_HEAD(1), GEN_HEAD(1), 0}}, 10, 0},
2f7d869dad4d Move all data for a single generation into a structure. The set of
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 23296
diff changeset
46 {{{GEN_HEAD(2), GEN_HEAD(2), 0}}, 10, 0},
2f7d869dad4d Move all data for a single generation into a structure. The set of
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 23296
diff changeset
47 };
2f7d869dad4d Move all data for a single generation into a structure. The set of
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 23296
diff changeset
48
2f7d869dad4d Move all data for a single generation into a structure. The set of
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 23296
diff changeset
49 PyGC_Head *_PyGC_generation0 = GEN_HEAD(0);
2f7d869dad4d Move all data for a single generation into a structure. The set of
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 23296
diff changeset
50
13878
abfa4e4b2f3e Neil Schemenauer: GC enable(), disable(), isenabled() interface.
Vladimir Marangozov <vladimir.marangozov@t-online.de>
parents: 13570
diff changeset
51 static int enabled = 1; /* automatic collection enabled? */
13183
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
52
19585
c43d7a8f00a4 Make more things internal to this file. Remove
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 19128
diff changeset
53 /* true if we are currently running the collector */
28511
acf3596fcc28 Reworked move_finalizer_reachable() to create two distinct lists:
Tim Peters <tim.peters@gmail.com>
parents: 28510
diff changeset
54 static int collecting = 0;
19585
c43d7a8f00a4 Make more things internal to this file. Remove
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 19128
diff changeset
55
24085
22d2f037af9d Finished transitioning to using gc_refs to track gc objects' states.
Tim Peters <tim.peters@gmail.com>
parents: 24077
diff changeset
56 /* list of uncollectable objects */
28511
acf3596fcc28 Reworked move_finalizer_reachable() to create two distinct lists:
Tim Peters <tim.peters@gmail.com>
parents: 28510
diff changeset
57 static PyObject *garbage = NULL;
24085
22d2f037af9d Finished transitioning to using gc_refs to track gc objects' states.
Tim Peters <tim.peters@gmail.com>
parents: 24077
diff changeset
58
22d2f037af9d Finished transitioning to using gc_refs to track gc objects' states.
Tim Peters <tim.peters@gmail.com>
parents: 24077
diff changeset
59 /* Python string to use if unhandled exception occurs */
28511
acf3596fcc28 Reworked move_finalizer_reachable() to create two distinct lists:
Tim Peters <tim.peters@gmail.com>
parents: 28510
diff changeset
60 static PyObject *gc_str = NULL;
24085
22d2f037af9d Finished transitioning to using gc_refs to track gc objects' states.
Tim Peters <tim.peters@gmail.com>
parents: 24077
diff changeset
61
28507
a0503bdb0c24 Fixed new seemingly random segfaults, by moving the initialization of
Tim Peters <tim.peters@gmail.com>
parents: 28504
diff changeset
62 /* Python string used to look for __del__ attribute. */
a0503bdb0c24 Fixed new seemingly random segfaults, by moving the initialization of
Tim Peters <tim.peters@gmail.com>
parents: 28504
diff changeset
63 static PyObject *delstr = NULL;
28504
cb5db5561cdc Fix Tim's boom example.
Jeremy Hylton <jeremy@alum.mit.edu>
parents: 28498
diff changeset
64
13183
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
65 /* set for debugging information */
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
66 #define DEBUG_STATS (1<<0) /* print collection statistics */
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
67 #define DEBUG_COLLECTABLE (1<<1) /* print collectable objects */
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
68 #define DEBUG_UNCOLLECTABLE (1<<2) /* print uncollectable objects */
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
69 #define DEBUG_INSTANCES (1<<3) /* print instances */
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
70 #define DEBUG_OBJECTS (1<<4) /* print other objects */
14756
6e9331e68a3b - Add DEBUG_SAVEALL option. When enabled all garbage objects found by the
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 14424
diff changeset
71 #define DEBUG_SAVEALL (1<<5) /* save all garbage in gc.garbage */
13183
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
72 #define DEBUG_LEAK DEBUG_COLLECTABLE | \
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
73 DEBUG_UNCOLLECTABLE | \
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
74 DEBUG_INSTANCES | \
14756
6e9331e68a3b - Add DEBUG_SAVEALL option. When enabled all garbage objects found by the
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 14424
diff changeset
75 DEBUG_OBJECTS | \
6e9331e68a3b - Add DEBUG_SAVEALL option. When enabled all garbage objects found by the
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 14424
diff changeset
76 DEBUG_SAVEALL
14330
6dee1985c681 refactor __del__ exception handler into PyErr_WriteUnraisable
Jeremy Hylton <jeremy@alum.mit.edu>
parents: 14294
diff changeset
77 static int debug;
13183
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
78
24085
22d2f037af9d Finished transitioning to using gc_refs to track gc objects' states.
Tim Peters <tim.peters@gmail.com>
parents: 24077
diff changeset
79 /*--------------------------------------------------------------------------
22d2f037af9d Finished transitioning to using gc_refs to track gc objects' states.
Tim Peters <tim.peters@gmail.com>
parents: 24077
diff changeset
80 gc_refs values.
22d2f037af9d Finished transitioning to using gc_refs to track gc objects' states.
Tim Peters <tim.peters@gmail.com>
parents: 24077
diff changeset
81
22d2f037af9d Finished transitioning to using gc_refs to track gc objects' states.
Tim Peters <tim.peters@gmail.com>
parents: 24077
diff changeset
82 Between collections, every gc'ed object has one of two gc_refs values:
22d2f037af9d Finished transitioning to using gc_refs to track gc objects' states.
Tim Peters <tim.peters@gmail.com>
parents: 24077
diff changeset
83
22d2f037af9d Finished transitioning to using gc_refs to track gc objects' states.
Tim Peters <tim.peters@gmail.com>
parents: 24077
diff changeset
84 GC_UNTRACKED
22d2f037af9d Finished transitioning to using gc_refs to track gc objects' states.
Tim Peters <tim.peters@gmail.com>
parents: 24077
diff changeset
85 The initial state; objects returned by PyObject_GC_Malloc are in this
22d2f037af9d Finished transitioning to using gc_refs to track gc objects' states.
Tim Peters <tim.peters@gmail.com>
parents: 24077
diff changeset
86 state. The object doesn't live in any generation list, and its
22d2f037af9d Finished transitioning to using gc_refs to track gc objects' states.
Tim Peters <tim.peters@gmail.com>
parents: 24077
diff changeset
87 tp_traverse slot must not be called.
22d2f037af9d Finished transitioning to using gc_refs to track gc objects' states.
Tim Peters <tim.peters@gmail.com>
parents: 24077
diff changeset
88
22d2f037af9d Finished transitioning to using gc_refs to track gc objects' states.
Tim Peters <tim.peters@gmail.com>
parents: 24077
diff changeset
89 GC_REACHABLE
22d2f037af9d Finished transitioning to using gc_refs to track gc objects' states.
Tim Peters <tim.peters@gmail.com>
parents: 24077
diff changeset
90 The object lives in some generation list, and its tp_traverse is safe to
22d2f037af9d Finished transitioning to using gc_refs to track gc objects' states.
Tim Peters <tim.peters@gmail.com>
parents: 24077
diff changeset
91 call. An object transitions to GC_REACHABLE when PyObject_GC_Track
22d2f037af9d Finished transitioning to using gc_refs to track gc objects' states.
Tim Peters <tim.peters@gmail.com>
parents: 24077
diff changeset
92 is called.
22d2f037af9d Finished transitioning to using gc_refs to track gc objects' states.
Tim Peters <tim.peters@gmail.com>
parents: 24077
diff changeset
93
22d2f037af9d Finished transitioning to using gc_refs to track gc objects' states.
Tim Peters <tim.peters@gmail.com>
parents: 24077
diff changeset
94 During a collection, gc_refs can temporarily take on other states:
19585
c43d7a8f00a4 Make more things internal to this file. Remove
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 19128
diff changeset
95
24085
22d2f037af9d Finished transitioning to using gc_refs to track gc objects' states.
Tim Peters <tim.peters@gmail.com>
parents: 24077
diff changeset
96 >= 0
22d2f037af9d Finished transitioning to using gc_refs to track gc objects' states.
Tim Peters <tim.peters@gmail.com>
parents: 24077
diff changeset
97 At the start of a collection, update_refs() copies the true refcount
22d2f037af9d Finished transitioning to using gc_refs to track gc objects' states.
Tim Peters <tim.peters@gmail.com>
parents: 24077
diff changeset
98 to gc_refs, for each object in the generation being collected.
22d2f037af9d Finished transitioning to using gc_refs to track gc objects' states.
Tim Peters <tim.peters@gmail.com>
parents: 24077
diff changeset
99 subtract_refs() then adjusts gc_refs so that it equals the number of
22d2f037af9d Finished transitioning to using gc_refs to track gc objects' states.
Tim Peters <tim.peters@gmail.com>
parents: 24077
diff changeset
100 times an object is referenced directly from outside the generation
22d2f037af9d Finished transitioning to using gc_refs to track gc objects' states.
Tim Peters <tim.peters@gmail.com>
parents: 24077
diff changeset
101 being collected.
26138
4ab6b7c3f311 Fix typo.
Martin v. Löwis <martin@v.loewis.de>
parents: 24714
diff changeset
102 gc_refs remains >= 0 throughout these steps.
24085
22d2f037af9d Finished transitioning to using gc_refs to track gc objects' states.
Tim Peters <tim.peters@gmail.com>
parents: 24077
diff changeset
103
22d2f037af9d Finished transitioning to using gc_refs to track gc objects' states.
Tim Peters <tim.peters@gmail.com>
parents: 24077
diff changeset
104 GC_TENTATIVELY_UNREACHABLE
22d2f037af9d Finished transitioning to using gc_refs to track gc objects' states.
Tim Peters <tim.peters@gmail.com>
parents: 24077
diff changeset
105 move_unreachable() then moves objects not reachable (whether directly or
22d2f037af9d Finished transitioning to using gc_refs to track gc objects' states.
Tim Peters <tim.peters@gmail.com>
parents: 24077
diff changeset
106 indirectly) from outside the generation into an "unreachable" set.
22d2f037af9d Finished transitioning to using gc_refs to track gc objects' states.
Tim Peters <tim.peters@gmail.com>
parents: 24077
diff changeset
107 Objects that are found to be reachable have gc_refs set to GC_REACHABLE
22d2f037af9d Finished transitioning to using gc_refs to track gc objects' states.
Tim Peters <tim.peters@gmail.com>
parents: 24077
diff changeset
108 again. Objects that are found to be unreachable have gc_refs set to
22d2f037af9d Finished transitioning to using gc_refs to track gc objects' states.
Tim Peters <tim.peters@gmail.com>
parents: 24077
diff changeset
109 GC_TENTATIVELY_UNREACHABLE. It's "tentatively" because the pass doing
22d2f037af9d Finished transitioning to using gc_refs to track gc objects' states.
Tim Peters <tim.peters@gmail.com>
parents: 24077
diff changeset
110 this can't be sure until it ends, and GC_TENTATIVELY_UNREACHABLE may
22d2f037af9d Finished transitioning to using gc_refs to track gc objects' states.
Tim Peters <tim.peters@gmail.com>
parents: 24077
diff changeset
111 transition back to GC_REACHABLE.
22d2f037af9d Finished transitioning to using gc_refs to track gc objects' states.
Tim Peters <tim.peters@gmail.com>
parents: 24077
diff changeset
112
22d2f037af9d Finished transitioning to using gc_refs to track gc objects' states.
Tim Peters <tim.peters@gmail.com>
parents: 24077
diff changeset
113 Only objects with GC_TENTATIVELY_UNREACHABLE still set are candidates
22d2f037af9d Finished transitioning to using gc_refs to track gc objects' states.
Tim Peters <tim.peters@gmail.com>
parents: 24077
diff changeset
114 for collection. If it's decided not to collect such an object (e.g.,
22d2f037af9d Finished transitioning to using gc_refs to track gc objects' states.
Tim Peters <tim.peters@gmail.com>
parents: 24077
diff changeset
115 it has a __del__ method), its gc_refs is restored to GC_REACHABLE again.
22d2f037af9d Finished transitioning to using gc_refs to track gc objects' states.
Tim Peters <tim.peters@gmail.com>
parents: 24077
diff changeset
116 ----------------------------------------------------------------------------
22d2f037af9d Finished transitioning to using gc_refs to track gc objects' states.
Tim Peters <tim.peters@gmail.com>
parents: 24077
diff changeset
117 */
24077
a5162fd65c3d Reserved another gc_refs value for untracked objects. Every live gc
Tim Peters <tim.peters@gmail.com>
parents: 24075
diff changeset
118 #define GC_UNTRACKED _PyGC_REFS_UNTRACKED
a5162fd65c3d Reserved another gc_refs value for untracked objects. Every live gc
Tim Peters <tim.peters@gmail.com>
parents: 24075
diff changeset
119 #define GC_REACHABLE _PyGC_REFS_REACHABLE
a5162fd65c3d Reserved another gc_refs value for untracked objects. Every live gc
Tim Peters <tim.peters@gmail.com>
parents: 24075
diff changeset
120 #define GC_TENTATIVELY_UNREACHABLE _PyGC_REFS_TENTATIVELY_UNREACHABLE
24075
32db075def3f OK, I couldn't stand it <0.5 wink>: removed all uncertainty about what's
Tim Peters <tim.peters@gmail.com>
parents: 24074
diff changeset
121
24085
22d2f037af9d Finished transitioning to using gc_refs to track gc objects' states.
Tim Peters <tim.peters@gmail.com>
parents: 24077
diff changeset
122 #define IS_TRACKED(o) ((AS_GC(o))->gc.gc_refs != GC_UNTRACKED)
24075
32db075def3f OK, I couldn't stand it <0.5 wink>: removed all uncertainty about what's
Tim Peters <tim.peters@gmail.com>
parents: 24074
diff changeset
123 #define IS_REACHABLE(o) ((AS_GC(o))->gc.gc_refs == GC_REACHABLE)
32db075def3f OK, I couldn't stand it <0.5 wink>: removed all uncertainty about what's
Tim Peters <tim.peters@gmail.com>
parents: 24074
diff changeset
124 #define IS_TENTATIVELY_UNREACHABLE(o) ( \
32db075def3f OK, I couldn't stand it <0.5 wink>: removed all uncertainty about what's
Tim Peters <tim.peters@gmail.com>
parents: 24074
diff changeset
125 (AS_GC(o))->gc.gc_refs == GC_TENTATIVELY_UNREACHABLE)
23495
68e3f3dd4d48 Add IS_TRACKED and IS_MOVED macros. This makes the logic a little more clear.
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 23377
diff changeset
126
13183
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
127 /*** list functions ***/
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
128
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
129 static void
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
130 gc_list_init(PyGC_Head *list)
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
131 {
20381
b4f829941f3d SF bug [#467145] Python 2.2a4 build problem on HPUX 11.0.
Tim Peters <tim.peters@gmail.com>
parents: 20296
diff changeset
132 list->gc.gc_prev = list;
b4f829941f3d SF bug [#467145] Python 2.2a4 build problem on HPUX 11.0.
Tim Peters <tim.peters@gmail.com>
parents: 20296
diff changeset
133 list->gc.gc_next = list;
13183
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
134 }
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
135
23377
2f7d869dad4d Move all data for a single generation into a structure. The set of
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 23296
diff changeset
136 static int
2f7d869dad4d Move all data for a single generation into a structure. The set of
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 23296
diff changeset
137 gc_list_is_empty(PyGC_Head *list)
2f7d869dad4d Move all data for a single generation into a structure. The set of
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 23296
diff changeset
138 {
2f7d869dad4d Move all data for a single generation into a structure. The set of
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 23296
diff changeset
139 return (list->gc.gc_next == list);
2f7d869dad4d Move all data for a single generation into a structure. The set of
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 23296
diff changeset
140 }
2f7d869dad4d Move all data for a single generation into a structure. The set of
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 23296
diff changeset
141
13183
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
142 static void
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
143 gc_list_append(PyGC_Head *node, PyGC_Head *list)
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
144 {
20381
b4f829941f3d SF bug [#467145] Python 2.2a4 build problem on HPUX 11.0.
Tim Peters <tim.peters@gmail.com>
parents: 20296
diff changeset
145 node->gc.gc_next = list;
b4f829941f3d SF bug [#467145] Python 2.2a4 build problem on HPUX 11.0.
Tim Peters <tim.peters@gmail.com>
parents: 20296
diff changeset
146 node->gc.gc_prev = list->gc.gc_prev;
b4f829941f3d SF bug [#467145] Python 2.2a4 build problem on HPUX 11.0.
Tim Peters <tim.peters@gmail.com>
parents: 20296
diff changeset
147 node->gc.gc_prev->gc.gc_next = node;
b4f829941f3d SF bug [#467145] Python 2.2a4 build problem on HPUX 11.0.
Tim Peters <tim.peters@gmail.com>
parents: 20296
diff changeset
148 list->gc.gc_prev = node;
13183
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
149 }
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
150
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
151 static void
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
152 gc_list_remove(PyGC_Head *node)
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
153 {
20381
b4f829941f3d SF bug [#467145] Python 2.2a4 build problem on HPUX 11.0.
Tim Peters <tim.peters@gmail.com>
parents: 20296
diff changeset
154 node->gc.gc_prev->gc.gc_next = node->gc.gc_next;
b4f829941f3d SF bug [#467145] Python 2.2a4 build problem on HPUX 11.0.
Tim Peters <tim.peters@gmail.com>
parents: 20296
diff changeset
155 node->gc.gc_next->gc.gc_prev = node->gc.gc_prev;
b4f829941f3d SF bug [#467145] Python 2.2a4 build problem on HPUX 11.0.
Tim Peters <tim.peters@gmail.com>
parents: 20296
diff changeset
156 node->gc.gc_next = NULL; /* object is not currently tracked */
13183
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
157 }
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
158
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
159 /* append a list onto another list, from becomes an empty list */
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
160 static void
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
161 gc_list_merge(PyGC_Head *from, PyGC_Head *to)
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
162 {
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
163 PyGC_Head *tail;
23377
2f7d869dad4d Move all data for a single generation into a structure. The set of
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 23296
diff changeset
164 if (!gc_list_is_empty(from)) {
20381
b4f829941f3d SF bug [#467145] Python 2.2a4 build problem on HPUX 11.0.
Tim Peters <tim.peters@gmail.com>
parents: 20296
diff changeset
165 tail = to->gc.gc_prev;
b4f829941f3d SF bug [#467145] Python 2.2a4 build problem on HPUX 11.0.
Tim Peters <tim.peters@gmail.com>
parents: 20296
diff changeset
166 tail->gc.gc_next = from->gc.gc_next;
b4f829941f3d SF bug [#467145] Python 2.2a4 build problem on HPUX 11.0.
Tim Peters <tim.peters@gmail.com>
parents: 20296
diff changeset
167 tail->gc.gc_next->gc.gc_prev = tail;
b4f829941f3d SF bug [#467145] Python 2.2a4 build problem on HPUX 11.0.
Tim Peters <tim.peters@gmail.com>
parents: 20296
diff changeset
168 to->gc.gc_prev = from->gc.gc_prev;
b4f829941f3d SF bug [#467145] Python 2.2a4 build problem on HPUX 11.0.
Tim Peters <tim.peters@gmail.com>
parents: 20296
diff changeset
169 to->gc.gc_prev->gc.gc_next = to;
13183
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
170 }
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
171 gc_list_init(from);
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
172 }
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
173
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
174 static long
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
175 gc_list_size(PyGC_Head *list)
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
176 {
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
177 PyGC_Head *gc;
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
178 long n = 0;
20381
b4f829941f3d SF bug [#467145] Python 2.2a4 build problem on HPUX 11.0.
Tim Peters <tim.peters@gmail.com>
parents: 20296
diff changeset
179 for (gc = list->gc.gc_next; gc != list; gc = gc->gc.gc_next) {
13183
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
180 n++;
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
181 }
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
182 return n;
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
183 }
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
184
28515
4c596dd60c22 handle_finalizers(): Rewrote to call append_objects() and gc_list_merge()
Tim Peters <tim.peters@gmail.com>
parents: 28512
diff changeset
185 /* Append objects in a GC list to a Python list.
4c596dd60c22 handle_finalizers(): Rewrote to call append_objects() and gc_list_merge()
Tim Peters <tim.peters@gmail.com>
parents: 28512
diff changeset
186 * Return 0 if all OK, < 0 if error (out of memory for list).
4c596dd60c22 handle_finalizers(): Rewrote to call append_objects() and gc_list_merge()
Tim Peters <tim.peters@gmail.com>
parents: 28512
diff changeset
187 */
4c596dd60c22 handle_finalizers(): Rewrote to call append_objects() and gc_list_merge()
Tim Peters <tim.peters@gmail.com>
parents: 28512
diff changeset
188 static int
4c596dd60c22 handle_finalizers(): Rewrote to call append_objects() and gc_list_merge()
Tim Peters <tim.peters@gmail.com>
parents: 28512
diff changeset
189 append_objects(PyObject *py_list, PyGC_Head *gc_list)
4c596dd60c22 handle_finalizers(): Rewrote to call append_objects() and gc_list_merge()
Tim Peters <tim.peters@gmail.com>
parents: 28512
diff changeset
190 {
4c596dd60c22 handle_finalizers(): Rewrote to call append_objects() and gc_list_merge()
Tim Peters <tim.peters@gmail.com>
parents: 28512
diff changeset
191 PyGC_Head *gc;
4c596dd60c22 handle_finalizers(): Rewrote to call append_objects() and gc_list_merge()
Tim Peters <tim.peters@gmail.com>
parents: 28512
diff changeset
192 for (gc = gc_list->gc.gc_next; gc != gc_list; gc = gc->gc.gc_next) {
4c596dd60c22 handle_finalizers(): Rewrote to call append_objects() and gc_list_merge()
Tim Peters <tim.peters@gmail.com>
parents: 28512
diff changeset
193 PyObject *op = FROM_GC(gc);
4c596dd60c22 handle_finalizers(): Rewrote to call append_objects() and gc_list_merge()
Tim Peters <tim.peters@gmail.com>
parents: 28512
diff changeset
194 if (op != py_list) {
4c596dd60c22 handle_finalizers(): Rewrote to call append_objects() and gc_list_merge()
Tim Peters <tim.peters@gmail.com>
parents: 28512
diff changeset
195 if (PyList_Append(py_list, op)) {
4c596dd60c22 handle_finalizers(): Rewrote to call append_objects() and gc_list_merge()
Tim Peters <tim.peters@gmail.com>
parents: 28512
diff changeset
196 return -1; /* exception */
4c596dd60c22 handle_finalizers(): Rewrote to call append_objects() and gc_list_merge()
Tim Peters <tim.peters@gmail.com>
parents: 28512
diff changeset
197 }
4c596dd60c22 handle_finalizers(): Rewrote to call append_objects() and gc_list_merge()
Tim Peters <tim.peters@gmail.com>
parents: 28512
diff changeset
198 }
4c596dd60c22 handle_finalizers(): Rewrote to call append_objects() and gc_list_merge()
Tim Peters <tim.peters@gmail.com>
parents: 28512
diff changeset
199 }
4c596dd60c22 handle_finalizers(): Rewrote to call append_objects() and gc_list_merge()
Tim Peters <tim.peters@gmail.com>
parents: 28512
diff changeset
200 return 0;
4c596dd60c22 handle_finalizers(): Rewrote to call append_objects() and gc_list_merge()
Tim Peters <tim.peters@gmail.com>
parents: 28512
diff changeset
201 }
4c596dd60c22 handle_finalizers(): Rewrote to call append_objects() and gc_list_merge()
Tim Peters <tim.peters@gmail.com>
parents: 28512
diff changeset
202
13183
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
203 /*** end of list stuff ***/
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
204
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
205
24075
32db075def3f OK, I couldn't stand it <0.5 wink>: removed all uncertainty about what's
Tim Peters <tim.peters@gmail.com>
parents: 24074
diff changeset
206 /* Set all gc_refs = ob_refcnt. After this, gc_refs is > 0 for all objects
32db075def3f OK, I couldn't stand it <0.5 wink>: removed all uncertainty about what's
Tim Peters <tim.peters@gmail.com>
parents: 24074
diff changeset
207 * in containers, and is GC_REACHABLE for all tracked gc objects not in
32db075def3f OK, I couldn't stand it <0.5 wink>: removed all uncertainty about what's
Tim Peters <tim.peters@gmail.com>
parents: 24074
diff changeset
208 * containers.
24072
86b3760d285d SF bug #574132: Major GC related performance regression
Tim Peters <tim.peters@gmail.com>
parents: 24036
diff changeset
209 */
13183
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
210 static void
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
211 update_refs(PyGC_Head *containers)
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
212 {
20381
b4f829941f3d SF bug [#467145] Python 2.2a4 build problem on HPUX 11.0.
Tim Peters <tim.peters@gmail.com>
parents: 20296
diff changeset
213 PyGC_Head *gc = containers->gc.gc_next;
24077
a5162fd65c3d Reserved another gc_refs value for untracked objects. Every live gc
Tim Peters <tim.peters@gmail.com>
parents: 24075
diff changeset
214 for (; gc != containers; gc = gc->gc.gc_next) {
a5162fd65c3d Reserved another gc_refs value for untracked objects. Every live gc
Tim Peters <tim.peters@gmail.com>
parents: 24075
diff changeset
215 assert(gc->gc.gc_refs == GC_REACHABLE);
20381
b4f829941f3d SF bug [#467145] Python 2.2a4 build problem on HPUX 11.0.
Tim Peters <tim.peters@gmail.com>
parents: 20296
diff changeset
216 gc->gc.gc_refs = FROM_GC(gc)->ob_refcnt;
30918
8aa9237f6dd6 update_refs(): assert that incoming refcounts aren't 0. The comment
Tim Peters <tim.peters@gmail.com>
parents: 30311
diff changeset
217 /* Python's cyclic gc should never see an incoming refcount
8aa9237f6dd6 update_refs(): assert that incoming refcounts aren't 0. The comment
Tim Peters <tim.peters@gmail.com>
parents: 30311
diff changeset
218 * of 0: if something decref'ed to 0, it should have been
8aa9237f6dd6 update_refs(): assert that incoming refcounts aren't 0. The comment
Tim Peters <tim.peters@gmail.com>
parents: 30311
diff changeset
219 * deallocated immediately at that time.
8aa9237f6dd6 update_refs(): assert that incoming refcounts aren't 0. The comment
Tim Peters <tim.peters@gmail.com>
parents: 30311
diff changeset
220 * Possible cause (if the assert triggers): a tp_dealloc
8aa9237f6dd6 update_refs(): assert that incoming refcounts aren't 0. The comment
Tim Peters <tim.peters@gmail.com>
parents: 30311
diff changeset
221 * routine left a gc-aware object tracked during its teardown
8aa9237f6dd6 update_refs(): assert that incoming refcounts aren't 0. The comment
Tim Peters <tim.peters@gmail.com>
parents: 30311
diff changeset
222 * phase, and did something-- or allowed something to happen --
8aa9237f6dd6 update_refs(): assert that incoming refcounts aren't 0. The comment
Tim Peters <tim.peters@gmail.com>
parents: 30311
diff changeset
223 * that called back into Python. gc can trigger then, and may
8aa9237f6dd6 update_refs(): assert that incoming refcounts aren't 0. The comment
Tim Peters <tim.peters@gmail.com>
parents: 30311
diff changeset
224 * see the still-tracked dying object. Before this assert
8aa9237f6dd6 update_refs(): assert that incoming refcounts aren't 0. The comment
Tim Peters <tim.peters@gmail.com>
parents: 30311
diff changeset
225 * was added, such mistakes went on to allow gc to try to
8aa9237f6dd6 update_refs(): assert that incoming refcounts aren't 0. The comment
Tim Peters <tim.peters@gmail.com>
parents: 30311
diff changeset
226 * delete the object again. In a debug build, that caused
8aa9237f6dd6 update_refs(): assert that incoming refcounts aren't 0. The comment
Tim Peters <tim.peters@gmail.com>
parents: 30311
diff changeset
227 * a mysterious segfault, when _Py_ForgetReference tried
8aa9237f6dd6 update_refs(): assert that incoming refcounts aren't 0. The comment
Tim Peters <tim.peters@gmail.com>
parents: 30311
diff changeset
228 * to remove the object from the doubly-linked list of all
8aa9237f6dd6 update_refs(): assert that incoming refcounts aren't 0. The comment
Tim Peters <tim.peters@gmail.com>
parents: 30311
diff changeset
229 * objects a second time. In a release build, an actual
8aa9237f6dd6 update_refs(): assert that incoming refcounts aren't 0. The comment
Tim Peters <tim.peters@gmail.com>
parents: 30311
diff changeset
230 * double deallocation occurred, which leads to corruption
8aa9237f6dd6 update_refs(): assert that incoming refcounts aren't 0. The comment
Tim Peters <tim.peters@gmail.com>
parents: 30311
diff changeset
231 * of the allocator's internal bookkeeping pointers. That's
8aa9237f6dd6 update_refs(): assert that incoming refcounts aren't 0. The comment
Tim Peters <tim.peters@gmail.com>
parents: 30311
diff changeset
232 * so serious that maybe this should be a release-build
8aa9237f6dd6 update_refs(): assert that incoming refcounts aren't 0. The comment
Tim Peters <tim.peters@gmail.com>
parents: 30311
diff changeset
233 * check instead of an assert?
8aa9237f6dd6 update_refs(): assert that incoming refcounts aren't 0. The comment
Tim Peters <tim.peters@gmail.com>
parents: 30311
diff changeset
234 */
8aa9237f6dd6 update_refs(): assert that incoming refcounts aren't 0. The comment
Tim Peters <tim.peters@gmail.com>
parents: 30311
diff changeset
235 assert(gc->gc.gc_refs != 0);
24077
a5162fd65c3d Reserved another gc_refs value for untracked objects. Every live gc
Tim Peters <tim.peters@gmail.com>
parents: 24075
diff changeset
236 }
13183
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
237 }
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
238
24075
32db075def3f OK, I couldn't stand it <0.5 wink>: removed all uncertainty about what's
Tim Peters <tim.peters@gmail.com>
parents: 24074
diff changeset
239 /* A traversal callback for subtract_refs. */
13183
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
240 static int
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
241 visit_decref(PyObject *op, void *data)
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
242 {
24074
a1805a54666f visit_decref(): Two optimizations.
Tim Peters <tim.peters@gmail.com>
parents: 24072
diff changeset
243 assert(op != NULL);
24075
32db075def3f OK, I couldn't stand it <0.5 wink>: removed all uncertainty about what's
Tim Peters <tim.peters@gmail.com>
parents: 24074
diff changeset
244 if (PyObject_IS_GC(op)) {
32db075def3f OK, I couldn't stand it <0.5 wink>: removed all uncertainty about what's
Tim Peters <tim.peters@gmail.com>
parents: 24074
diff changeset
245 PyGC_Head *gc = AS_GC(op);
32db075def3f OK, I couldn't stand it <0.5 wink>: removed all uncertainty about what's
Tim Peters <tim.peters@gmail.com>
parents: 24074
diff changeset
246 /* We're only interested in gc_refs for objects in the
32db075def3f OK, I couldn't stand it <0.5 wink>: removed all uncertainty about what's
Tim Peters <tim.peters@gmail.com>
parents: 24074
diff changeset
247 * generation being collected, which can be recognized
32db075def3f OK, I couldn't stand it <0.5 wink>: removed all uncertainty about what's
Tim Peters <tim.peters@gmail.com>
parents: 24074
diff changeset
248 * because only they have positive gc_refs.
32db075def3f OK, I couldn't stand it <0.5 wink>: removed all uncertainty about what's
Tim Peters <tim.peters@gmail.com>
parents: 24074
diff changeset
249 */
24097
f7abbd15b4f4 visit_decref(): Added another assert.
Tim Peters <tim.peters@gmail.com>
parents: 24085
diff changeset
250 assert(gc->gc.gc_refs != 0); /* else refcount was too small */
24075
32db075def3f OK, I couldn't stand it <0.5 wink>: removed all uncertainty about what's
Tim Peters <tim.peters@gmail.com>
parents: 24074
diff changeset
251 if (gc->gc.gc_refs > 0)
32db075def3f OK, I couldn't stand it <0.5 wink>: removed all uncertainty about what's
Tim Peters <tim.peters@gmail.com>
parents: 24074
diff changeset
252 gc->gc.gc_refs--;
32db075def3f OK, I couldn't stand it <0.5 wink>: removed all uncertainty about what's
Tim Peters <tim.peters@gmail.com>
parents: 24074
diff changeset
253 }
13183
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
254 return 0;
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
255 }
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
256
24075
32db075def3f OK, I couldn't stand it <0.5 wink>: removed all uncertainty about what's
Tim Peters <tim.peters@gmail.com>
parents: 24074
diff changeset
257 /* Subtract internal references from gc_refs. After this, gc_refs is >= 0
32db075def3f OK, I couldn't stand it <0.5 wink>: removed all uncertainty about what's
Tim Peters <tim.peters@gmail.com>
parents: 24074
diff changeset
258 * for all objects in containers, and is GC_REACHABLE for all tracked gc
32db075def3f OK, I couldn't stand it <0.5 wink>: removed all uncertainty about what's
Tim Peters <tim.peters@gmail.com>
parents: 24074
diff changeset
259 * objects not in containers. The ones with gc_refs > 0 are directly
32db075def3f OK, I couldn't stand it <0.5 wink>: removed all uncertainty about what's
Tim Peters <tim.peters@gmail.com>
parents: 24074
diff changeset
260 * reachable from outside containers, and so can't be collected.
32db075def3f OK, I couldn't stand it <0.5 wink>: removed all uncertainty about what's
Tim Peters <tim.peters@gmail.com>
parents: 24074
diff changeset
261 */
13183
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
262 static void
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
263 subtract_refs(PyGC_Head *containers)
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
264 {
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
265 traverseproc traverse;
20381
b4f829941f3d SF bug [#467145] Python 2.2a4 build problem on HPUX 11.0.
Tim Peters <tim.peters@gmail.com>
parents: 20296
diff changeset
266 PyGC_Head *gc = containers->gc.gc_next;
b4f829941f3d SF bug [#467145] Python 2.2a4 build problem on HPUX 11.0.
Tim Peters <tim.peters@gmail.com>
parents: 20296
diff changeset
267 for (; gc != containers; gc=gc->gc.gc_next) {
19585
c43d7a8f00a4 Make more things internal to this file. Remove
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 19128
diff changeset
268 traverse = FROM_GC(gc)->ob_type->tp_traverse;
c43d7a8f00a4 Make more things internal to this file. Remove
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 19128
diff changeset
269 (void) traverse(FROM_GC(gc),
13183
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
270 (visitproc)visit_decref,
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
271 NULL);
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
272 }
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
273 }
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
274
24075
32db075def3f OK, I couldn't stand it <0.5 wink>: removed all uncertainty about what's
Tim Peters <tim.peters@gmail.com>
parents: 24074
diff changeset
275 /* A traversal callback for move_unreachable. */
32db075def3f OK, I couldn't stand it <0.5 wink>: removed all uncertainty about what's
Tim Peters <tim.peters@gmail.com>
parents: 24074
diff changeset
276 static int
32db075def3f OK, I couldn't stand it <0.5 wink>: removed all uncertainty about what's
Tim Peters <tim.peters@gmail.com>
parents: 24074
diff changeset
277 visit_reachable(PyObject *op, PyGC_Head *reachable)
13183
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
278 {
24077
a5162fd65c3d Reserved another gc_refs value for untracked objects. Every live gc
Tim Peters <tim.peters@gmail.com>
parents: 24075
diff changeset
279 if (PyObject_IS_GC(op)) {
24075
32db075def3f OK, I couldn't stand it <0.5 wink>: removed all uncertainty about what's
Tim Peters <tim.peters@gmail.com>
parents: 24074
diff changeset
280 PyGC_Head *gc = AS_GC(op);
32db075def3f OK, I couldn't stand it <0.5 wink>: removed all uncertainty about what's
Tim Peters <tim.peters@gmail.com>
parents: 24074
diff changeset
281 const int gc_refs = gc->gc.gc_refs;
32db075def3f OK, I couldn't stand it <0.5 wink>: removed all uncertainty about what's
Tim Peters <tim.peters@gmail.com>
parents: 24074
diff changeset
282
32db075def3f OK, I couldn't stand it <0.5 wink>: removed all uncertainty about what's
Tim Peters <tim.peters@gmail.com>
parents: 24074
diff changeset
283 if (gc_refs == 0) {
32db075def3f OK, I couldn't stand it <0.5 wink>: removed all uncertainty about what's
Tim Peters <tim.peters@gmail.com>
parents: 24074
diff changeset
284 /* This is in move_unreachable's 'young' list, but
32db075def3f OK, I couldn't stand it <0.5 wink>: removed all uncertainty about what's
Tim Peters <tim.peters@gmail.com>
parents: 24074
diff changeset
285 * the traversal hasn't yet gotten to it. All
32db075def3f OK, I couldn't stand it <0.5 wink>: removed all uncertainty about what's
Tim Peters <tim.peters@gmail.com>
parents: 24074
diff changeset
286 * we need to do is tell move_unreachable that it's
32db075def3f OK, I couldn't stand it <0.5 wink>: removed all uncertainty about what's
Tim Peters <tim.peters@gmail.com>
parents: 24074
diff changeset
287 * reachable.
32db075def3f OK, I couldn't stand it <0.5 wink>: removed all uncertainty about what's
Tim Peters <tim.peters@gmail.com>
parents: 24074
diff changeset
288 */
32db075def3f OK, I couldn't stand it <0.5 wink>: removed all uncertainty about what's
Tim Peters <tim.peters@gmail.com>
parents: 24074
diff changeset
289 gc->gc.gc_refs = 1;
13183
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
290 }
24075
32db075def3f OK, I couldn't stand it <0.5 wink>: removed all uncertainty about what's
Tim Peters <tim.peters@gmail.com>
parents: 24074
diff changeset
291 else if (gc_refs == GC_TENTATIVELY_UNREACHABLE) {
32db075def3f OK, I couldn't stand it <0.5 wink>: removed all uncertainty about what's
Tim Peters <tim.peters@gmail.com>
parents: 24074
diff changeset
292 /* This had gc_refs = 0 when move_unreachable got
32db075def3f OK, I couldn't stand it <0.5 wink>: removed all uncertainty about what's
Tim Peters <tim.peters@gmail.com>
parents: 24074
diff changeset
293 * to it, but turns out it's reachable after all.
32db075def3f OK, I couldn't stand it <0.5 wink>: removed all uncertainty about what's
Tim Peters <tim.peters@gmail.com>
parents: 24074
diff changeset
294 * Move it back to move_unreachable's 'young' list,
32db075def3f OK, I couldn't stand it <0.5 wink>: removed all uncertainty about what's
Tim Peters <tim.peters@gmail.com>
parents: 24074
diff changeset
295 * and move_unreachable will eventually get to it
32db075def3f OK, I couldn't stand it <0.5 wink>: removed all uncertainty about what's
Tim Peters <tim.peters@gmail.com>
parents: 24074
diff changeset
296 * again.
32db075def3f OK, I couldn't stand it <0.5 wink>: removed all uncertainty about what's
Tim Peters <tim.peters@gmail.com>
parents: 24074
diff changeset
297 */
13183
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
298 gc_list_remove(gc);
24075
32db075def3f OK, I couldn't stand it <0.5 wink>: removed all uncertainty about what's
Tim Peters <tim.peters@gmail.com>
parents: 24074
diff changeset
299 gc_list_append(gc, reachable);
32db075def3f OK, I couldn't stand it <0.5 wink>: removed all uncertainty about what's
Tim Peters <tim.peters@gmail.com>
parents: 24074
diff changeset
300 gc->gc.gc_refs = 1;
13183
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
301 }
24075
32db075def3f OK, I couldn't stand it <0.5 wink>: removed all uncertainty about what's
Tim Peters <tim.peters@gmail.com>
parents: 24074
diff changeset
302 /* Else there's nothing to do.
32db075def3f OK, I couldn't stand it <0.5 wink>: removed all uncertainty about what's
Tim Peters <tim.peters@gmail.com>
parents: 24074
diff changeset
303 * If gc_refs > 0, it must be in move_unreachable's 'young'
32db075def3f OK, I couldn't stand it <0.5 wink>: removed all uncertainty about what's
Tim Peters <tim.peters@gmail.com>
parents: 24074
diff changeset
304 * list, and move_unreachable will eventually get to it.
32db075def3f OK, I couldn't stand it <0.5 wink>: removed all uncertainty about what's
Tim Peters <tim.peters@gmail.com>
parents: 24074
diff changeset
305 * If gc_refs == GC_REACHABLE, it's either in some other
32db075def3f OK, I couldn't stand it <0.5 wink>: removed all uncertainty about what's
Tim Peters <tim.peters@gmail.com>
parents: 24074
diff changeset
306 * generation so we don't care about it, or move_unreachable
24085
22d2f037af9d Finished transitioning to using gc_refs to track gc objects' states.
Tim Peters <tim.peters@gmail.com>
parents: 24077
diff changeset
307 * already dealt with it.
24077
a5162fd65c3d Reserved another gc_refs value for untracked objects. Every live gc
Tim Peters <tim.peters@gmail.com>
parents: 24075
diff changeset
308 * If gc_refs == GC_UNTRACKED, it must be ignored.
24075
32db075def3f OK, I couldn't stand it <0.5 wink>: removed all uncertainty about what's
Tim Peters <tim.peters@gmail.com>
parents: 24074
diff changeset
309 */
24077
a5162fd65c3d Reserved another gc_refs value for untracked objects. Every live gc
Tim Peters <tim.peters@gmail.com>
parents: 24075
diff changeset
310 else {
a5162fd65c3d Reserved another gc_refs value for untracked objects. Every live gc
Tim Peters <tim.peters@gmail.com>
parents: 24075
diff changeset
311 assert(gc_refs > 0
a5162fd65c3d Reserved another gc_refs value for untracked objects. Every live gc
Tim Peters <tim.peters@gmail.com>
parents: 24075
diff changeset
312 || gc_refs == GC_REACHABLE
a5162fd65c3d Reserved another gc_refs value for untracked objects. Every live gc
Tim Peters <tim.peters@gmail.com>
parents: 24075
diff changeset
313 || gc_refs == GC_UNTRACKED);
a5162fd65c3d Reserved another gc_refs value for untracked objects. Every live gc
Tim Peters <tim.peters@gmail.com>
parents: 24075
diff changeset
314 }
13183
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
315 }
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
316 return 0;
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
317 }
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
318
24075
32db075def3f OK, I couldn't stand it <0.5 wink>: removed all uncertainty about what's
Tim Peters <tim.peters@gmail.com>
parents: 24074
diff changeset
319 /* Move the unreachable objects from young to unreachable. After this,
32db075def3f OK, I couldn't stand it <0.5 wink>: removed all uncertainty about what's
Tim Peters <tim.peters@gmail.com>
parents: 24074
diff changeset
320 * all objects in young have gc_refs = GC_REACHABLE, and all objects in
32db075def3f OK, I couldn't stand it <0.5 wink>: removed all uncertainty about what's
Tim Peters <tim.peters@gmail.com>
parents: 24074
diff changeset
321 * unreachable have gc_refs = GC_TENTATIVELY_UNREACHABLE. All tracked
32db075def3f OK, I couldn't stand it <0.5 wink>: removed all uncertainty about what's
Tim Peters <tim.peters@gmail.com>
parents: 24074
diff changeset
322 * gc objects not in young or unreachable still have gc_refs = GC_REACHABLE.
32db075def3f OK, I couldn't stand it <0.5 wink>: removed all uncertainty about what's
Tim Peters <tim.peters@gmail.com>
parents: 24074
diff changeset
323 * All objects in young after this are directly or indirectly reachable
32db075def3f OK, I couldn't stand it <0.5 wink>: removed all uncertainty about what's
Tim Peters <tim.peters@gmail.com>
parents: 24074
diff changeset
324 * from outside the original young; and all objects in unreachable are
32db075def3f OK, I couldn't stand it <0.5 wink>: removed all uncertainty about what's
Tim Peters <tim.peters@gmail.com>
parents: 24074
diff changeset
325 * not.
24072
86b3760d285d SF bug #574132: Major GC related performance regression
Tim Peters <tim.peters@gmail.com>
parents: 24036
diff changeset
326 */
13183
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
327 static void
24075
32db075def3f OK, I couldn't stand it <0.5 wink>: removed all uncertainty about what's
Tim Peters <tim.peters@gmail.com>
parents: 24074
diff changeset
328 move_unreachable(PyGC_Head *young, PyGC_Head *unreachable)
13183
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
329 {
24075
32db075def3f OK, I couldn't stand it <0.5 wink>: removed all uncertainty about what's
Tim Peters <tim.peters@gmail.com>
parents: 24074
diff changeset
330 PyGC_Head *gc = young->gc.gc_next;
32db075def3f OK, I couldn't stand it <0.5 wink>: removed all uncertainty about what's
Tim Peters <tim.peters@gmail.com>
parents: 24074
diff changeset
331
32db075def3f OK, I couldn't stand it <0.5 wink>: removed all uncertainty about what's
Tim Peters <tim.peters@gmail.com>
parents: 24074
diff changeset
332 /* Invariants: all objects "to the left" of us in young have gc_refs
32db075def3f OK, I couldn't stand it <0.5 wink>: removed all uncertainty about what's
Tim Peters <tim.peters@gmail.com>
parents: 24074
diff changeset
333 * = GC_REACHABLE, and are indeed reachable (directly or indirectly)
32db075def3f OK, I couldn't stand it <0.5 wink>: removed all uncertainty about what's
Tim Peters <tim.peters@gmail.com>
parents: 24074
diff changeset
334 * from outside the young list as it was at entry. All other objects
32db075def3f OK, I couldn't stand it <0.5 wink>: removed all uncertainty about what's
Tim Peters <tim.peters@gmail.com>
parents: 24074
diff changeset
335 * from the original young "to the left" of us are in unreachable now,
32db075def3f OK, I couldn't stand it <0.5 wink>: removed all uncertainty about what's
Tim Peters <tim.peters@gmail.com>
parents: 24074
diff changeset
336 * and have gc_refs = GC_TENTATIVELY_UNREACHABLE. All objects to the
32db075def3f OK, I couldn't stand it <0.5 wink>: removed all uncertainty about what's
Tim Peters <tim.peters@gmail.com>
parents: 24074
diff changeset
337 * left of us in 'young' now have been scanned, and no objects here
32db075def3f OK, I couldn't stand it <0.5 wink>: removed all uncertainty about what's
Tim Peters <tim.peters@gmail.com>
parents: 24074
diff changeset
338 * or to the right have been scanned yet.
32db075def3f OK, I couldn't stand it <0.5 wink>: removed all uncertainty about what's
Tim Peters <tim.peters@gmail.com>
parents: 24074
diff changeset
339 */
32db075def3f OK, I couldn't stand it <0.5 wink>: removed all uncertainty about what's
Tim Peters <tim.peters@gmail.com>
parents: 24074
diff changeset
340
32db075def3f OK, I couldn't stand it <0.5 wink>: removed all uncertainty about what's
Tim Peters <tim.peters@gmail.com>
parents: 24074
diff changeset
341 while (gc != young) {
32db075def3f OK, I couldn't stand it <0.5 wink>: removed all uncertainty about what's
Tim Peters <tim.peters@gmail.com>
parents: 24074
diff changeset
342 PyGC_Head *next;
32db075def3f OK, I couldn't stand it <0.5 wink>: removed all uncertainty about what's
Tim Peters <tim.peters@gmail.com>
parents: 24074
diff changeset
343
24085
22d2f037af9d Finished transitioning to using gc_refs to track gc objects' states.
Tim Peters <tim.peters@gmail.com>
parents: 24077
diff changeset
344 if (gc->gc.gc_refs) {
22d2f037af9d Finished transitioning to using gc_refs to track gc objects' states.
Tim Peters <tim.peters@gmail.com>
parents: 24077
diff changeset
345 /* gc is definitely reachable from outside the
22d2f037af9d Finished transitioning to using gc_refs to track gc objects' states.
Tim Peters <tim.peters@gmail.com>
parents: 24077
diff changeset
346 * original 'young'. Mark it as such, and traverse
22d2f037af9d Finished transitioning to using gc_refs to track gc objects' states.
Tim Peters <tim.peters@gmail.com>
parents: 24077
diff changeset
347 * its pointers to find any other objects that may
22d2f037af9d Finished transitioning to using gc_refs to track gc objects' states.
Tim Peters <tim.peters@gmail.com>
parents: 24077
diff changeset
348 * be directly reachable from it. Note that the
22d2f037af9d Finished transitioning to using gc_refs to track gc objects' states.
Tim Peters <tim.peters@gmail.com>
parents: 24077
diff changeset
349 * call to tp_traverse may append objects to young,
22d2f037af9d Finished transitioning to using gc_refs to track gc objects' states.
Tim Peters <tim.peters@gmail.com>
parents: 24077
diff changeset
350 * so we have to wait until it returns to determine
22d2f037af9d Finished transitioning to using gc_refs to track gc objects' states.
Tim Peters <tim.peters@gmail.com>
parents: 24077
diff changeset
351 * the next object to visit.
22d2f037af9d Finished transitioning to using gc_refs to track gc objects' states.
Tim Peters <tim.peters@gmail.com>
parents: 24077
diff changeset
352 */
22d2f037af9d Finished transitioning to using gc_refs to track gc objects' states.
Tim Peters <tim.peters@gmail.com>
parents: 24077
diff changeset
353 PyObject *op = FROM_GC(gc);
22d2f037af9d Finished transitioning to using gc_refs to track gc objects' states.
Tim Peters <tim.peters@gmail.com>
parents: 24077
diff changeset
354 traverseproc traverse = op->ob_type->tp_traverse;
22d2f037af9d Finished transitioning to using gc_refs to track gc objects' states.
Tim Peters <tim.peters@gmail.com>
parents: 24077
diff changeset
355 assert(gc->gc.gc_refs > 0);
22d2f037af9d Finished transitioning to using gc_refs to track gc objects' states.
Tim Peters <tim.peters@gmail.com>
parents: 24077
diff changeset
356 gc->gc.gc_refs = GC_REACHABLE;
22d2f037af9d Finished transitioning to using gc_refs to track gc objects' states.
Tim Peters <tim.peters@gmail.com>
parents: 24077
diff changeset
357 (void) traverse(op,
22d2f037af9d Finished transitioning to using gc_refs to track gc objects' states.
Tim Peters <tim.peters@gmail.com>
parents: 24077
diff changeset
358 (visitproc)visit_reachable,
22d2f037af9d Finished transitioning to using gc_refs to track gc objects' states.
Tim Peters <tim.peters@gmail.com>
parents: 24077
diff changeset
359 (void *)young);
22d2f037af9d Finished transitioning to using gc_refs to track gc objects' states.
Tim Peters <tim.peters@gmail.com>
parents: 24077
diff changeset
360 next = gc->gc.gc_next;
22d2f037af9d Finished transitioning to using gc_refs to track gc objects' states.
Tim Peters <tim.peters@gmail.com>
parents: 24077
diff changeset
361 }
22d2f037af9d Finished transitioning to using gc_refs to track gc objects' states.
Tim Peters <tim.peters@gmail.com>
parents: 24077
diff changeset
362 else {
24075
32db075def3f OK, I couldn't stand it <0.5 wink>: removed all uncertainty about what's
Tim Peters <tim.peters@gmail.com>
parents: 24074
diff changeset
363 /* This *may* be unreachable. To make progress,
32db075def3f OK, I couldn't stand it <0.5 wink>: removed all uncertainty about what's
Tim Peters <tim.peters@gmail.com>
parents: 24074
diff changeset
364 * assume it is. gc isn't directly reachable from
32db075def3f OK, I couldn't stand it <0.5 wink>: removed all uncertainty about what's
Tim Peters <tim.peters@gmail.com>
parents: 24074
diff changeset
365 * any object we've already traversed, but may be
32db075def3f OK, I couldn't stand it <0.5 wink>: removed all uncertainty about what's
Tim Peters <tim.peters@gmail.com>
parents: 24074
diff changeset
366 * reachable from an object we haven't gotten to yet.
32db075def3f OK, I couldn't stand it <0.5 wink>: removed all uncertainty about what's
Tim Peters <tim.peters@gmail.com>
parents: 24074
diff changeset
367 * visit_reachable will eventually move gc back into
32db075def3f OK, I couldn't stand it <0.5 wink>: removed all uncertainty about what's
Tim Peters <tim.peters@gmail.com>
parents: 24074
diff changeset
368 * young if that's so, and we'll see it again.
32db075def3f OK, I couldn't stand it <0.5 wink>: removed all uncertainty about what's
Tim Peters <tim.peters@gmail.com>
parents: 24074
diff changeset
369 */
32db075def3f OK, I couldn't stand it <0.5 wink>: removed all uncertainty about what's
Tim Peters <tim.peters@gmail.com>
parents: 24074
diff changeset
370 next = gc->gc.gc_next;
32db075def3f OK, I couldn't stand it <0.5 wink>: removed all uncertainty about what's
Tim Peters <tim.peters@gmail.com>
parents: 24074
diff changeset
371 gc_list_remove(gc);
32db075def3f OK, I couldn't stand it <0.5 wink>: removed all uncertainty about what's
Tim Peters <tim.peters@gmail.com>
parents: 24074
diff changeset
372 gc_list_append(gc, unreachable);
32db075def3f OK, I couldn't stand it <0.5 wink>: removed all uncertainty about what's
Tim Peters <tim.peters@gmail.com>
parents: 24074
diff changeset
373 gc->gc.gc_refs = GC_TENTATIVELY_UNREACHABLE;
32db075def3f OK, I couldn't stand it <0.5 wink>: removed all uncertainty about what's
Tim Peters <tim.peters@gmail.com>
parents: 24074
diff changeset
374 }
32db075def3f OK, I couldn't stand it <0.5 wink>: removed all uncertainty about what's
Tim Peters <tim.peters@gmail.com>
parents: 24074
diff changeset
375 gc = next;
13183
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
376 }
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
377 }
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
378
28508
8233a0294c41 New comments. Rewrote has_finalizer() as a sequence of ifs instead of
Tim Peters <tim.peters@gmail.com>
parents: 28507
diff changeset
379 /* Return true if object has a finalization method.
8233a0294c41 New comments. Rewrote has_finalizer() as a sequence of ifs instead of
Tim Peters <tim.peters@gmail.com>
parents: 28507
diff changeset
380 * CAUTION: An instance of an old-style class has to be checked for a
28520
6653a56002ef Reworked has_finalizer() to use the new _PyObject_Lookup() instead
Tim Peters <tim.peters@gmail.com>
parents: 28516
diff changeset
381 *__del__ method, and earlier versions of this used to call PyObject_HasAttr,
6653a56002ef Reworked has_finalizer() to use the new _PyObject_Lookup() instead
Tim Peters <tim.peters@gmail.com>
parents: 28516
diff changeset
382 * which in turn could call the class's __getattr__ hook (if any). That
6653a56002ef Reworked has_finalizer() to use the new _PyObject_Lookup() instead
Tim Peters <tim.peters@gmail.com>
parents: 28516
diff changeset
383 * could invoke arbitrary Python code, mutating the object graph in arbitrary
6653a56002ef Reworked has_finalizer() to use the new _PyObject_Lookup() instead
Tim Peters <tim.peters@gmail.com>
parents: 28516
diff changeset
384 * ways, and that was the source of some excruciatingly subtle bugs.
28508
8233a0294c41 New comments. Rewrote has_finalizer() as a sequence of ifs instead of
Tim Peters <tim.peters@gmail.com>
parents: 28507
diff changeset
385 */
20818
9aded6235d89 Add has_finalizer predictate function. Use it when deciding which
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 20810
diff changeset
386 static int
9aded6235d89 Add has_finalizer predictate function. Use it when deciding which
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 20810
diff changeset
387 has_finalizer(PyObject *op)
9aded6235d89 Add has_finalizer predictate function. Use it when deciding which
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 20810
diff changeset
388 {
28508
8233a0294c41 New comments. Rewrote has_finalizer() as a sequence of ifs instead of
Tim Peters <tim.peters@gmail.com>
parents: 28507
diff changeset
389 if (PyInstance_Check(op)) {
8233a0294c41 New comments. Rewrote has_finalizer() as a sequence of ifs instead of
Tim Peters <tim.peters@gmail.com>
parents: 28507
diff changeset
390 assert(delstr != NULL);
28520
6653a56002ef Reworked has_finalizer() to use the new _PyObject_Lookup() instead
Tim Peters <tim.peters@gmail.com>
parents: 28516
diff changeset
391 return _PyInstance_Lookup(op, delstr) != NULL;
28508
8233a0294c41 New comments. Rewrote has_finalizer() as a sequence of ifs instead of
Tim Peters <tim.peters@gmail.com>
parents: 28507
diff changeset
392 }
8233a0294c41 New comments. Rewrote has_finalizer() as a sequence of ifs instead of
Tim Peters <tim.peters@gmail.com>
parents: 28507
diff changeset
393 else if (PyType_HasFeature(op->ob_type, Py_TPFLAGS_HEAPTYPE))
8233a0294c41 New comments. Rewrote has_finalizer() as a sequence of ifs instead of
Tim Peters <tim.peters@gmail.com>
parents: 28507
diff changeset
394 return op->ob_type->tp_del != NULL;
8233a0294c41 New comments. Rewrote has_finalizer() as a sequence of ifs instead of
Tim Peters <tim.peters@gmail.com>
parents: 28507
diff changeset
395 else
8233a0294c41 New comments. Rewrote has_finalizer() as a sequence of ifs instead of
Tim Peters <tim.peters@gmail.com>
parents: 28507
diff changeset
396 return 0;
20818
9aded6235d89 Add has_finalizer predictate function. Use it when deciding which
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 20810
diff changeset
397 }
9aded6235d89 Add has_finalizer predictate function. Use it when deciding which
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 20810
diff changeset
398
30988
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults.
Tim Peters <tim.peters@gmail.com>
parents: 30918
diff changeset
399 /* Move the objects in unreachable with __del__ methods into finalizers,
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults.
Tim Peters <tim.peters@gmail.com>
parents: 30918
diff changeset
400 * and weakrefs with callbacks into wr_callbacks.
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults.
Tim Peters <tim.peters@gmail.com>
parents: 30918
diff changeset
401 * The objects remaining in unreachable do not have __del__ methods, and are
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults.
Tim Peters <tim.peters@gmail.com>
parents: 30918
diff changeset
402 * not weakrefs with callbacks.
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults.
Tim Peters <tim.peters@gmail.com>
parents: 30918
diff changeset
403 * The objects moved have gc_refs changed to GC_REACHABLE; the objects
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults.
Tim Peters <tim.peters@gmail.com>
parents: 30918
diff changeset
404 * remaining in unreachable are left at GC_TENTATIVELY_UNREACHABLE.
28504
cb5db5561cdc Fix Tim's boom example.
Jeremy Hylton <jeremy@alum.mit.edu>
parents: 28498
diff changeset
405 */
13183
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
406 static void
30988
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults.
Tim Peters <tim.peters@gmail.com>
parents: 30918
diff changeset
407 move_troublemakers(PyGC_Head *unreachable,
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults.
Tim Peters <tim.peters@gmail.com>
parents: 30918
diff changeset
408 PyGC_Head *finalizers,
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults.
Tim Peters <tim.peters@gmail.com>
parents: 30918
diff changeset
409 PyGC_Head *wr_callbacks)
13183
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
410 {
28520
6653a56002ef Reworked has_finalizer() to use the new _PyObject_Lookup() instead
Tim Peters <tim.peters@gmail.com>
parents: 28516
diff changeset
411 PyGC_Head *gc = unreachable->gc.gc_next;
6653a56002ef Reworked has_finalizer() to use the new _PyObject_Lookup() instead
Tim Peters <tim.peters@gmail.com>
parents: 28516
diff changeset
412
6653a56002ef Reworked has_finalizer() to use the new _PyObject_Lookup() instead
Tim Peters <tim.peters@gmail.com>
parents: 28516
diff changeset
413 while (gc != unreachable) {
19585
c43d7a8f00a4 Make more things internal to this file. Remove
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 19128
diff changeset
414 PyObject *op = FROM_GC(gc);
28520
6653a56002ef Reworked has_finalizer() to use the new _PyObject_Lookup() instead
Tim Peters <tim.peters@gmail.com>
parents: 28516
diff changeset
415 PyGC_Head *next = gc->gc.gc_next;
28504
cb5db5561cdc Fix Tim's boom example.
Jeremy Hylton <jeremy@alum.mit.edu>
parents: 28498
diff changeset
416
28510
0de0ded19968 move_finalizers(): Rewrote. It's not necessary for this routine
Tim Peters <tim.peters@gmail.com>
parents: 28508
diff changeset
417 assert(IS_TENTATIVELY_UNREACHABLE(op));
0de0ded19968 move_finalizers(): Rewrote. It's not necessary for this routine
Tim Peters <tim.peters@gmail.com>
parents: 28508
diff changeset
418
28520
6653a56002ef Reworked has_finalizer() to use the new _PyObject_Lookup() instead
Tim Peters <tim.peters@gmail.com>
parents: 28516
diff changeset
419 if (has_finalizer(op)) {
28510
0de0ded19968 move_finalizers(): Rewrote. It's not necessary for this routine
Tim Peters <tim.peters@gmail.com>
parents: 28508
diff changeset
420 gc_list_remove(gc);
28520
6653a56002ef Reworked has_finalizer() to use the new _PyObject_Lookup() instead
Tim Peters <tim.peters@gmail.com>
parents: 28516
diff changeset
421 gc_list_append(gc, finalizers);
6653a56002ef Reworked has_finalizer() to use the new _PyObject_Lookup() instead
Tim Peters <tim.peters@gmail.com>
parents: 28516
diff changeset
422 gc->gc.gc_refs = GC_REACHABLE;
28504
cb5db5561cdc Fix Tim's boom example.
Jeremy Hylton <jeremy@alum.mit.edu>
parents: 28498
diff changeset
423 }
30988
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults.
Tim Peters <tim.peters@gmail.com>
parents: 30918
diff changeset
424 else if (PyWeakref_Check(op) &&
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults.
Tim Peters <tim.peters@gmail.com>
parents: 30918
diff changeset
425 ((PyWeakReference *)op)->wr_callback) {
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults.
Tim Peters <tim.peters@gmail.com>
parents: 30918
diff changeset
426 gc_list_remove(gc);
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults.
Tim Peters <tim.peters@gmail.com>
parents: 30918
diff changeset
427 gc_list_append(gc, wr_callbacks);
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults.
Tim Peters <tim.peters@gmail.com>
parents: 30918
diff changeset
428 gc->gc.gc_refs = GC_REACHABLE;
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults.
Tim Peters <tim.peters@gmail.com>
parents: 30918
diff changeset
429 }
28520
6653a56002ef Reworked has_finalizer() to use the new _PyObject_Lookup() instead
Tim Peters <tim.peters@gmail.com>
parents: 28516
diff changeset
430 gc = next;
13183
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
431 }
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
432 }
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
433
24075
32db075def3f OK, I couldn't stand it <0.5 wink>: removed all uncertainty about what's
Tim Peters <tim.peters@gmail.com>
parents: 24074
diff changeset
434 /* A traversal callback for move_finalizer_reachable. */
32db075def3f OK, I couldn't stand it <0.5 wink>: removed all uncertainty about what's
Tim Peters <tim.peters@gmail.com>
parents: 24074
diff changeset
435 static int
32db075def3f OK, I couldn't stand it <0.5 wink>: removed all uncertainty about what's
Tim Peters <tim.peters@gmail.com>
parents: 24074
diff changeset
436 visit_move(PyObject *op, PyGC_Head *tolist)
32db075def3f OK, I couldn't stand it <0.5 wink>: removed all uncertainty about what's
Tim Peters <tim.peters@gmail.com>
parents: 24074
diff changeset
437 {
32db075def3f OK, I couldn't stand it <0.5 wink>: removed all uncertainty about what's
Tim Peters <tim.peters@gmail.com>
parents: 24074
diff changeset
438 if (PyObject_IS_GC(op)) {
24077
a5162fd65c3d Reserved another gc_refs value for untracked objects. Every live gc
Tim Peters <tim.peters@gmail.com>
parents: 24075
diff changeset
439 if (IS_TENTATIVELY_UNREACHABLE(op)) {
24075
32db075def3f OK, I couldn't stand it <0.5 wink>: removed all uncertainty about what's
Tim Peters <tim.peters@gmail.com>
parents: 24074
diff changeset
440 PyGC_Head *gc = AS_GC(op);
32db075def3f OK, I couldn't stand it <0.5 wink>: removed all uncertainty about what's
Tim Peters <tim.peters@gmail.com>
parents: 24074
diff changeset
441 gc_list_remove(gc);
32db075def3f OK, I couldn't stand it <0.5 wink>: removed all uncertainty about what's
Tim Peters <tim.peters@gmail.com>
parents: 24074
diff changeset
442 gc_list_append(gc, tolist);
32db075def3f OK, I couldn't stand it <0.5 wink>: removed all uncertainty about what's
Tim Peters <tim.peters@gmail.com>
parents: 24074
diff changeset
443 gc->gc.gc_refs = GC_REACHABLE;
32db075def3f OK, I couldn't stand it <0.5 wink>: removed all uncertainty about what's
Tim Peters <tim.peters@gmail.com>
parents: 24074
diff changeset
444 }
32db075def3f OK, I couldn't stand it <0.5 wink>: removed all uncertainty about what's
Tim Peters <tim.peters@gmail.com>
parents: 24074
diff changeset
445 }
32db075def3f OK, I couldn't stand it <0.5 wink>: removed all uncertainty about what's
Tim Peters <tim.peters@gmail.com>
parents: 24074
diff changeset
446 return 0;
32db075def3f OK, I couldn't stand it <0.5 wink>: removed all uncertainty about what's
Tim Peters <tim.peters@gmail.com>
parents: 24074
diff changeset
447 }
32db075def3f OK, I couldn't stand it <0.5 wink>: removed all uncertainty about what's
Tim Peters <tim.peters@gmail.com>
parents: 24074
diff changeset
448
32db075def3f OK, I couldn't stand it <0.5 wink>: removed all uncertainty about what's
Tim Peters <tim.peters@gmail.com>
parents: 24074
diff changeset
449 /* Move objects that are reachable from finalizers, from the unreachable set
28520
6653a56002ef Reworked has_finalizer() to use the new _PyObject_Lookup() instead
Tim Peters <tim.peters@gmail.com>
parents: 28516
diff changeset
450 * into finalizers set.
24075
32db075def3f OK, I couldn't stand it <0.5 wink>: removed all uncertainty about what's
Tim Peters <tim.peters@gmail.com>
parents: 24074
diff changeset
451 */
13183
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
452 static void
28520
6653a56002ef Reworked has_finalizer() to use the new _PyObject_Lookup() instead
Tim Peters <tim.peters@gmail.com>
parents: 28516
diff changeset
453 move_finalizer_reachable(PyGC_Head *finalizers)
13183
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
454 {
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
455 traverseproc traverse;
20381
b4f829941f3d SF bug [#467145] Python 2.2a4 build problem on HPUX 11.0.
Tim Peters <tim.peters@gmail.com>
parents: 20296
diff changeset
456 PyGC_Head *gc = finalizers->gc.gc_next;
28511
acf3596fcc28 Reworked move_finalizer_reachable() to create two distinct lists:
Tim Peters <tim.peters@gmail.com>
parents: 28510
diff changeset
457 for (; gc != finalizers; gc = gc->gc.gc_next) {
acf3596fcc28 Reworked move_finalizer_reachable() to create two distinct lists:
Tim Peters <tim.peters@gmail.com>
parents: 28510
diff changeset
458 /* Note that the finalizers list may grow during this. */
19585
c43d7a8f00a4 Make more things internal to this file. Remove
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 19128
diff changeset
459 traverse = FROM_GC(gc)->ob_type->tp_traverse;
24072
86b3760d285d SF bug #574132: Major GC related performance regression
Tim Peters <tim.peters@gmail.com>
parents: 24036
diff changeset
460 (void) traverse(FROM_GC(gc),
28511
acf3596fcc28 Reworked move_finalizer_reachable() to create two distinct lists:
Tim Peters <tim.peters@gmail.com>
parents: 28510
diff changeset
461 (visitproc)visit_move,
28520
6653a56002ef Reworked has_finalizer() to use the new _PyObject_Lookup() instead
Tim Peters <tim.peters@gmail.com>
parents: 28516
diff changeset
462 (void *)finalizers);
13183
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
463 }
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
464 }
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
465
30988
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults.
Tim Peters <tim.peters@gmail.com>
parents: 30918
diff changeset
466 /* Clear all trash weakrefs with callbacks. This clears weakrefs first,
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults.
Tim Peters <tim.peters@gmail.com>
parents: 30918
diff changeset
467 * which has the happy result of disabling the callbacks without executing
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults.
Tim Peters <tim.peters@gmail.com>
parents: 30918
diff changeset
468 * them. A nasty technical complication: a weakref callback can itself be
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults.
Tim Peters <tim.peters@gmail.com>
parents: 30918
diff changeset
469 * the target of a weakref, in which case decrefing the callback can cause
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults.
Tim Peters <tim.peters@gmail.com>
parents: 30918
diff changeset
470 * another callback to trigger. But we can't allow arbitrary Python code to
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults.
Tim Peters <tim.peters@gmail.com>
parents: 30918
diff changeset
471 * get executed at this point (the callback on the callback may try to muck
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults.
Tim Peters <tim.peters@gmail.com>
parents: 30918
diff changeset
472 * with other cyclic trash we're trying to collect, even resurrecting it
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults.
Tim Peters <tim.peters@gmail.com>
parents: 30918
diff changeset
473 * while we're in the middle of doing tp_clear() on the trash).
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults.
Tim Peters <tim.peters@gmail.com>
parents: 30918
diff changeset
474 *
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults.
Tim Peters <tim.peters@gmail.com>
parents: 30918
diff changeset
475 * The private _PyWeakref_ClearRef() function exists so that we can clear
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults.
Tim Peters <tim.peters@gmail.com>
parents: 30918
diff changeset
476 * the reference in a weakref without triggering a callback on the callback.
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults.
Tim Peters <tim.peters@gmail.com>
parents: 30918
diff changeset
477 *
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults.
Tim Peters <tim.peters@gmail.com>
parents: 30918
diff changeset
478 * We have to save the callback objects and decref them later. But we can't
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults.
Tim Peters <tim.peters@gmail.com>
parents: 30918
diff changeset
479 * allocate new memory to save them (if we can't get new memory, we're dead).
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults.
Tim Peters <tim.peters@gmail.com>
parents: 30918
diff changeset
480 * So we grab a new reference on the clear'ed weakref, which prevents the
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults.
Tim Peters <tim.peters@gmail.com>
parents: 30918
diff changeset
481 * rest of gc from reclaiming it. _PyWeakref_ClearRef() leaves the
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults.
Tim Peters <tim.peters@gmail.com>
parents: 30918
diff changeset
482 * weakref's wr_callback member intact.
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults.
Tim Peters <tim.peters@gmail.com>
parents: 30918
diff changeset
483 *
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults.
Tim Peters <tim.peters@gmail.com>
parents: 30918
diff changeset
484 * In the end, then, wr_callbacks consists of cleared weakrefs that are
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults.
Tim Peters <tim.peters@gmail.com>
parents: 30918
diff changeset
485 * immune from collection. Near the end of gc, after collecting all the
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults.
Tim Peters <tim.peters@gmail.com>
parents: 30918
diff changeset
486 * cyclic trash, we call release_weakrefs(). That releases our references
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults.
Tim Peters <tim.peters@gmail.com>
parents: 30918
diff changeset
487 * to the cleared weakrefs, which in turn may trigger callbacks on their
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults.
Tim Peters <tim.peters@gmail.com>
parents: 30918
diff changeset
488 * callbacks.
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults.
Tim Peters <tim.peters@gmail.com>
parents: 30918
diff changeset
489 */
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults.
Tim Peters <tim.peters@gmail.com>
parents: 30918
diff changeset
490 static void
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults.
Tim Peters <tim.peters@gmail.com>
parents: 30918
diff changeset
491 clear_weakrefs(PyGC_Head *wr_callbacks)
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults.
Tim Peters <tim.peters@gmail.com>
parents: 30918
diff changeset
492 {
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults.
Tim Peters <tim.peters@gmail.com>
parents: 30918
diff changeset
493 PyGC_Head *gc = wr_callbacks->gc.gc_next;
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults.
Tim Peters <tim.peters@gmail.com>
parents: 30918
diff changeset
494
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults.
Tim Peters <tim.peters@gmail.com>
parents: 30918
diff changeset
495 for (; gc != wr_callbacks; gc = gc->gc.gc_next) {
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults.
Tim Peters <tim.peters@gmail.com>
parents: 30918
diff changeset
496 PyObject *op = FROM_GC(gc);
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults.
Tim Peters <tim.peters@gmail.com>
parents: 30918
diff changeset
497 PyWeakReference *wr;
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults.
Tim Peters <tim.peters@gmail.com>
parents: 30918
diff changeset
498
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults.
Tim Peters <tim.peters@gmail.com>
parents: 30918
diff changeset
499 assert(IS_REACHABLE(op));
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults.
Tim Peters <tim.peters@gmail.com>
parents: 30918
diff changeset
500 assert(PyWeakref_Check(op));
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults.
Tim Peters <tim.peters@gmail.com>
parents: 30918
diff changeset
501 wr = (PyWeakReference *)op;
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults.
Tim Peters <tim.peters@gmail.com>
parents: 30918
diff changeset
502 assert(wr->wr_callback != NULL);
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults.
Tim Peters <tim.peters@gmail.com>
parents: 30918
diff changeset
503 Py_INCREF(op);
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults.
Tim Peters <tim.peters@gmail.com>
parents: 30918
diff changeset
504 _PyWeakref_ClearRef(wr);
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults.
Tim Peters <tim.peters@gmail.com>
parents: 30918
diff changeset
505 }
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults.
Tim Peters <tim.peters@gmail.com>
parents: 30918
diff changeset
506 }
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults.
Tim Peters <tim.peters@gmail.com>
parents: 30918
diff changeset
507
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults.
Tim Peters <tim.peters@gmail.com>
parents: 30918
diff changeset
508 /* Called near the end of gc. This gives up the references we own to
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults.
Tim Peters <tim.peters@gmail.com>
parents: 30918
diff changeset
509 * cleared weakrefs, allowing them to get collected, and in turn decref'ing
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults.
Tim Peters <tim.peters@gmail.com>
parents: 30918
diff changeset
510 * their callbacks.
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults.
Tim Peters <tim.peters@gmail.com>
parents: 30918
diff changeset
511 *
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults.
Tim Peters <tim.peters@gmail.com>
parents: 30918
diff changeset
512 * If a callback object is itself the target of a weakref callback,
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults.
Tim Peters <tim.peters@gmail.com>
parents: 30918
diff changeset
513 * decref'ing the callback object may trigger that other callback. If
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults.
Tim Peters <tim.peters@gmail.com>
parents: 30918
diff changeset
514 * that other callback was part of the cyclic trash in this generation,
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults.
Tim Peters <tim.peters@gmail.com>
parents: 30918
diff changeset
515 * that won't happen, since we cleared *all* trash-weakref callbacks near
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults.
Tim Peters <tim.peters@gmail.com>
parents: 30918
diff changeset
516 * the start of gc. If that other callback was not part of the cyclic trash
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults.
Tim Peters <tim.peters@gmail.com>
parents: 30918
diff changeset
517 * in this generation, then it acted like an external root to this round
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults.
Tim Peters <tim.peters@gmail.com>
parents: 30918
diff changeset
518 * of gc, so all the objects reachable from that callback are still alive.
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults.
Tim Peters <tim.peters@gmail.com>
parents: 30918
diff changeset
519 *
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults.
Tim Peters <tim.peters@gmail.com>
parents: 30918
diff changeset
520 * Giving up the references to the weakref objects will probably make
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults.
Tim Peters <tim.peters@gmail.com>
parents: 30918
diff changeset
521 * them go away too. However, if a weakref is reachable from finalizers,
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults.
Tim Peters <tim.peters@gmail.com>
parents: 30918
diff changeset
522 * it won't go away. We move it to the old generation then. Since a
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults.
Tim Peters <tim.peters@gmail.com>
parents: 30918
diff changeset
523 * weakref object doesn't have a finalizer, that's the right thing to do (it
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults.
Tim Peters <tim.peters@gmail.com>
parents: 30918
diff changeset
524 * doesn't belong in gc.garbage).
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults.
Tim Peters <tim.peters@gmail.com>
parents: 30918
diff changeset
525 *
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults.
Tim Peters <tim.peters@gmail.com>
parents: 30918
diff changeset
526 * We return the number of weakref objects freed (those not appended to old).
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults.
Tim Peters <tim.peters@gmail.com>
parents: 30918
diff changeset
527 */
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults.
Tim Peters <tim.peters@gmail.com>
parents: 30918
diff changeset
528 static int
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults.
Tim Peters <tim.peters@gmail.com>
parents: 30918
diff changeset
529 release_weakrefs(PyGC_Head *wr_callbacks, PyGC_Head *old)
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults.
Tim Peters <tim.peters@gmail.com>
parents: 30918
diff changeset
530 {
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults.
Tim Peters <tim.peters@gmail.com>
parents: 30918
diff changeset
531 int num_freed = 0;
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults.
Tim Peters <tim.peters@gmail.com>
parents: 30918
diff changeset
532
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults.
Tim Peters <tim.peters@gmail.com>
parents: 30918
diff changeset
533 while (! gc_list_is_empty(wr_callbacks)) {
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults.
Tim Peters <tim.peters@gmail.com>
parents: 30918
diff changeset
534 PyGC_Head *gc = wr_callbacks->gc.gc_next;
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults.
Tim Peters <tim.peters@gmail.com>
parents: 30918
diff changeset
535 PyObject *op = FROM_GC(gc);
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults.
Tim Peters <tim.peters@gmail.com>
parents: 30918
diff changeset
536
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults.
Tim Peters <tim.peters@gmail.com>
parents: 30918
diff changeset
537 assert(IS_REACHABLE(op));
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults.
Tim Peters <tim.peters@gmail.com>
parents: 30918
diff changeset
538 assert(PyWeakref_Check(op));
31010
2ddb1cba18d6 Silence GCC warning when asserts are turned off.
Guido van Rossum <guido@python.org>
parents: 30988
diff changeset
539 assert(((PyWeakReference *)op)->wr_callback != NULL);
30988
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults.
Tim Peters <tim.peters@gmail.com>
parents: 30918
diff changeset
540 Py_DECREF(op);
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults.
Tim Peters <tim.peters@gmail.com>
parents: 30918
diff changeset
541 if (wr_callbacks->gc.gc_next == gc) {
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults.
Tim Peters <tim.peters@gmail.com>
parents: 30918
diff changeset
542 /* object is still alive -- move it */
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults.
Tim Peters <tim.peters@gmail.com>
parents: 30918
diff changeset
543 gc_list_remove(gc);
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults.
Tim Peters <tim.peters@gmail.com>
parents: 30918
diff changeset
544 gc_list_append(gc, old);
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults.
Tim Peters <tim.peters@gmail.com>
parents: 30918
diff changeset
545 }
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults.
Tim Peters <tim.peters@gmail.com>
parents: 30918
diff changeset
546 else
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults.
Tim Peters <tim.peters@gmail.com>
parents: 30918
diff changeset
547 ++num_freed;
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults.
Tim Peters <tim.peters@gmail.com>
parents: 30918
diff changeset
548 }
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults.
Tim Peters <tim.peters@gmail.com>
parents: 30918
diff changeset
549 return num_freed;
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults.
Tim Peters <tim.peters@gmail.com>
parents: 30918
diff changeset
550 }
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults.
Tim Peters <tim.peters@gmail.com>
parents: 30918
diff changeset
551
13183
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
552 static void
14294
053627e7ac14 apply patch #101362 by Vladimir Marangozov
Jeremy Hylton <jeremy@alum.mit.edu>
parents: 13878
diff changeset
553 debug_instance(char *msg, PyInstanceObject *inst)
13183
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
554 {
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
555 char *cname;
20818
9aded6235d89 Add has_finalizer predictate function. Use it when deciding which
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 20810
diff changeset
556 /* simple version of instance_repr */
13183
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
557 PyObject *classname = inst->in_class->cl_name;
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
558 if (classname != NULL && PyString_Check(classname))
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
559 cname = PyString_AsString(classname);
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
560 else
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
561 cname = "?";
14294
053627e7ac14 apply patch #101362 by Vladimir Marangozov
Jeremy Hylton <jeremy@alum.mit.edu>
parents: 13878
diff changeset
562 PySys_WriteStderr("gc: %.100s <%.100s instance at %p>\n",
053627e7ac14 apply patch #101362 by Vladimir Marangozov
Jeremy Hylton <jeremy@alum.mit.edu>
parents: 13878
diff changeset
563 msg, cname, inst);
13183
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
564 }
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
565
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
566 static void
14294
053627e7ac14 apply patch #101362 by Vladimir Marangozov
Jeremy Hylton <jeremy@alum.mit.edu>
parents: 13878
diff changeset
567 debug_cycle(char *msg, PyObject *op)
13183
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
568 {
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
569 if ((debug & DEBUG_INSTANCES) && PyInstance_Check(op)) {
14294
053627e7ac14 apply patch #101362 by Vladimir Marangozov
Jeremy Hylton <jeremy@alum.mit.edu>
parents: 13878
diff changeset
570 debug_instance(msg, (PyInstanceObject *)op);
14756
6e9331e68a3b - Add DEBUG_SAVEALL option. When enabled all garbage objects found by the
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 14424
diff changeset
571 }
6e9331e68a3b - Add DEBUG_SAVEALL option. When enabled all garbage objects found by the
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 14424
diff changeset
572 else if (debug & DEBUG_OBJECTS) {
14294
053627e7ac14 apply patch #101362 by Vladimir Marangozov
Jeremy Hylton <jeremy@alum.mit.edu>
parents: 13878
diff changeset
573 PySys_WriteStderr("gc: %.100s <%.100s %p>\n",
053627e7ac14 apply patch #101362 by Vladimir Marangozov
Jeremy Hylton <jeremy@alum.mit.edu>
parents: 13878
diff changeset
574 msg, op->ob_type->tp_name, op);
13183
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
575 }
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
576 }
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
577
28511
acf3596fcc28 Reworked move_finalizer_reachable() to create two distinct lists:
Tim Peters <tim.peters@gmail.com>
parents: 28510
diff changeset
578 /* Handle uncollectable garbage (cycles with finalizers, and stuff reachable
acf3596fcc28 Reworked move_finalizer_reachable() to create two distinct lists:
Tim Peters <tim.peters@gmail.com>
parents: 28510
diff changeset
579 * only from such cycles).
28520
6653a56002ef Reworked has_finalizer() to use the new _PyObject_Lookup() instead
Tim Peters <tim.peters@gmail.com>
parents: 28516
diff changeset
580 * If DEBUG_SAVEALL, all objects in finalizers are appended to the module
6653a56002ef Reworked has_finalizer() to use the new _PyObject_Lookup() instead
Tim Peters <tim.peters@gmail.com>
parents: 28516
diff changeset
581 * garbage list (a Python list), else only the objects in finalizers with
6653a56002ef Reworked has_finalizer() to use the new _PyObject_Lookup() instead
Tim Peters <tim.peters@gmail.com>
parents: 28516
diff changeset
582 * __del__ methods are appended to garbage. All objects in finalizers are
6653a56002ef Reworked has_finalizer() to use the new _PyObject_Lookup() instead
Tim Peters <tim.peters@gmail.com>
parents: 28516
diff changeset
583 * merged into the old list regardless.
28515
4c596dd60c22 handle_finalizers(): Rewrote to call append_objects() and gc_list_merge()
Tim Peters <tim.peters@gmail.com>
parents: 28512
diff changeset
584 * Returns 0 if all OK, <0 on error (out of memory to grow the garbage list).
4c596dd60c22 handle_finalizers(): Rewrote to call append_objects() and gc_list_merge()
Tim Peters <tim.peters@gmail.com>
parents: 28512
diff changeset
585 * The finalizers list is made empty on a successful return.
28511
acf3596fcc28 Reworked move_finalizer_reachable() to create two distinct lists:
Tim Peters <tim.peters@gmail.com>
parents: 28510
diff changeset
586 */
28515
4c596dd60c22 handle_finalizers(): Rewrote to call append_objects() and gc_list_merge()
Tim Peters <tim.peters@gmail.com>
parents: 28512
diff changeset
587 static int
28520
6653a56002ef Reworked has_finalizer() to use the new _PyObject_Lookup() instead
Tim Peters <tim.peters@gmail.com>
parents: 28516
diff changeset
588 handle_finalizers(PyGC_Head *finalizers, PyGC_Head *old)
13183
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
589 {
28520
6653a56002ef Reworked has_finalizer() to use the new _PyObject_Lookup() instead
Tim Peters <tim.peters@gmail.com>
parents: 28516
diff changeset
590 PyGC_Head *gc = finalizers->gc.gc_next;
6653a56002ef Reworked has_finalizer() to use the new _PyObject_Lookup() instead
Tim Peters <tim.peters@gmail.com>
parents: 28516
diff changeset
591
13183
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
592 if (garbage == NULL) {
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
593 garbage = PyList_New(0);
28511
acf3596fcc28 Reworked move_finalizer_reachable() to create two distinct lists:
Tim Peters <tim.peters@gmail.com>
parents: 28510
diff changeset
594 if (garbage == NULL)
acf3596fcc28 Reworked move_finalizer_reachable() to create two distinct lists:
Tim Peters <tim.peters@gmail.com>
parents: 28510
diff changeset
595 Py_FatalError("gc couldn't create gc.garbage list");
13183
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
596 }
28520
6653a56002ef Reworked has_finalizer() to use the new _PyObject_Lookup() instead
Tim Peters <tim.peters@gmail.com>
parents: 28516
diff changeset
597 for (; gc != finalizers; gc = gc->gc.gc_next) {
6653a56002ef Reworked has_finalizer() to use the new _PyObject_Lookup() instead
Tim Peters <tim.peters@gmail.com>
parents: 28516
diff changeset
598 PyObject *op = FROM_GC(gc);
6653a56002ef Reworked has_finalizer() to use the new _PyObject_Lookup() instead
Tim Peters <tim.peters@gmail.com>
parents: 28516
diff changeset
599
6653a56002ef Reworked has_finalizer() to use the new _PyObject_Lookup() instead
Tim Peters <tim.peters@gmail.com>
parents: 28516
diff changeset
600 if ((debug & DEBUG_SAVEALL) || has_finalizer(op)) {
6653a56002ef Reworked has_finalizer() to use the new _PyObject_Lookup() instead
Tim Peters <tim.peters@gmail.com>
parents: 28516
diff changeset
601 if (PyList_Append(garbage, op) < 0)
6653a56002ef Reworked has_finalizer() to use the new _PyObject_Lookup() instead
Tim Peters <tim.peters@gmail.com>
parents: 28516
diff changeset
602 return -1;
6653a56002ef Reworked has_finalizer() to use the new _PyObject_Lookup() instead
Tim Peters <tim.peters@gmail.com>
parents: 28516
diff changeset
603 }
13183
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
604 }
28520
6653a56002ef Reworked has_finalizer() to use the new _PyObject_Lookup() instead
Tim Peters <tim.peters@gmail.com>
parents: 28516
diff changeset
605
28515
4c596dd60c22 handle_finalizers(): Rewrote to call append_objects() and gc_list_merge()
Tim Peters <tim.peters@gmail.com>
parents: 28512
diff changeset
606 gc_list_merge(finalizers, old);
4c596dd60c22 handle_finalizers(): Rewrote to call append_objects() and gc_list_merge()
Tim Peters <tim.peters@gmail.com>
parents: 28512
diff changeset
607 return 0;
13183
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
608 }
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
609
14756
6e9331e68a3b - Add DEBUG_SAVEALL option. When enabled all garbage objects found by the
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 14424
diff changeset
610 /* Break reference cycles by clearing the containers involved. This is
13183
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
611 * tricky business as the lists can be changing and we don't know which
24075
32db075def3f OK, I couldn't stand it <0.5 wink>: removed all uncertainty about what's
Tim Peters <tim.peters@gmail.com>
parents: 24074
diff changeset
612 * objects may be freed. It is possible I screwed something up here.
32db075def3f OK, I couldn't stand it <0.5 wink>: removed all uncertainty about what's
Tim Peters <tim.peters@gmail.com>
parents: 24074
diff changeset
613 */
13183
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
614 static void
28504
cb5db5561cdc Fix Tim's boom example.
Jeremy Hylton <jeremy@alum.mit.edu>
parents: 28498
diff changeset
615 delete_garbage(PyGC_Head *collectable, PyGC_Head *old)
13183
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
616 {
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
617 inquiry clear;
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
618
28504
cb5db5561cdc Fix Tim's boom example.
Jeremy Hylton <jeremy@alum.mit.edu>
parents: 28498
diff changeset
619 while (!gc_list_is_empty(collectable)) {
cb5db5561cdc Fix Tim's boom example.
Jeremy Hylton <jeremy@alum.mit.edu>
parents: 28498
diff changeset
620 PyGC_Head *gc = collectable->gc.gc_next;
19585
c43d7a8f00a4 Make more things internal to this file. Remove
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 19128
diff changeset
621 PyObject *op = FROM_GC(gc);
24072
86b3760d285d SF bug #574132: Major GC related performance regression
Tim Peters <tim.peters@gmail.com>
parents: 24036
diff changeset
622
24075
32db075def3f OK, I couldn't stand it <0.5 wink>: removed all uncertainty about what's
Tim Peters <tim.peters@gmail.com>
parents: 24074
diff changeset
623 assert(IS_TENTATIVELY_UNREACHABLE(op));
14756
6e9331e68a3b - Add DEBUG_SAVEALL option. When enabled all garbage objects found by the
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 14424
diff changeset
624 if (debug & DEBUG_SAVEALL) {
6e9331e68a3b - Add DEBUG_SAVEALL option. When enabled all garbage objects found by the
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 14424
diff changeset
625 PyList_Append(garbage, op);
13183
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
626 }
14756
6e9331e68a3b - Add DEBUG_SAVEALL option. When enabled all garbage objects found by the
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 14424
diff changeset
627 else {
6e9331e68a3b - Add DEBUG_SAVEALL option. When enabled all garbage objects found by the
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 14424
diff changeset
628 if ((clear = op->ob_type->tp_clear) != NULL) {
6e9331e68a3b - Add DEBUG_SAVEALL option. When enabled all garbage objects found by the
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 14424
diff changeset
629 Py_INCREF(op);
23721
48e937e1b3fe Remove casts to PyObject * when declaration is for PyObject *
Jeremy Hylton <jeremy@alum.mit.edu>
parents: 23495
diff changeset
630 clear(op);
14756
6e9331e68a3b - Add DEBUG_SAVEALL option. When enabled all garbage objects found by the
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 14424
diff changeset
631 Py_DECREF(op);
6e9331e68a3b - Add DEBUG_SAVEALL option. When enabled all garbage objects found by the
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 14424
diff changeset
632 }
6e9331e68a3b - Add DEBUG_SAVEALL option. When enabled all garbage objects found by the
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 14424
diff changeset
633 }
28504
cb5db5561cdc Fix Tim's boom example.
Jeremy Hylton <jeremy@alum.mit.edu>
parents: 28498
diff changeset
634 if (collectable->gc.gc_next == gc) {
14756
6e9331e68a3b - Add DEBUG_SAVEALL option. When enabled all garbage objects found by the
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 14424
diff changeset
635 /* object is still alive, move it, it may die later */
13183
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
636 gc_list_remove(gc);
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
637 gc_list_append(gc, old);
24075
32db075def3f OK, I couldn't stand it <0.5 wink>: removed all uncertainty about what's
Tim Peters <tim.peters@gmail.com>
parents: 24074
diff changeset
638 gc->gc.gc_refs = GC_REACHABLE;
13183
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
639 }
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
640 }
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
641 }
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
642
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
643 /* This is the main function. Read this to understand how the
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
644 * collection process works. */
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
645 static long
23377
2f7d869dad4d Move all data for a single generation into a structure. The set of
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 23296
diff changeset
646 collect(int generation)
13183
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
647 {
23377
2f7d869dad4d Move all data for a single generation into a structure. The set of
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 23296
diff changeset
648 int i;
24075
32db075def3f OK, I couldn't stand it <0.5 wink>: removed all uncertainty about what's
Tim Peters <tim.peters@gmail.com>
parents: 24074
diff changeset
649 long m = 0; /* # objects collected */
32db075def3f OK, I couldn't stand it <0.5 wink>: removed all uncertainty about what's
Tim Peters <tim.peters@gmail.com>
parents: 24074
diff changeset
650 long n = 0; /* # unreachable objects that couldn't be collected */
23377
2f7d869dad4d Move all data for a single generation into a structure. The set of
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 23296
diff changeset
651 PyGC_Head *young; /* the generation we are examining */
2f7d869dad4d Move all data for a single generation into a structure. The set of
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 23296
diff changeset
652 PyGC_Head *old; /* next older generation */
30988
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults.
Tim Peters <tim.peters@gmail.com>
parents: 30918
diff changeset
653 PyGC_Head unreachable; /* non-problematic unreachable trash */
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults.
Tim Peters <tim.peters@gmail.com>
parents: 30918
diff changeset
654 PyGC_Head finalizers; /* objects with, & reachable from, __del__ */
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults.
Tim Peters <tim.peters@gmail.com>
parents: 30918
diff changeset
655 PyGC_Head wr_callbacks; /* weakrefs with callbacks */
13183
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
656 PyGC_Head *gc;
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
657
28507
a0503bdb0c24 Fixed new seemingly random segfaults, by moving the initialization of
Tim Peters <tim.peters@gmail.com>
parents: 28504
diff changeset
658 if (delstr == NULL) {
a0503bdb0c24 Fixed new seemingly random segfaults, by moving the initialization of
Tim Peters <tim.peters@gmail.com>
parents: 28504
diff changeset
659 delstr = PyString_InternFromString("__del__");
a0503bdb0c24 Fixed new seemingly random segfaults, by moving the initialization of
Tim Peters <tim.peters@gmail.com>
parents: 28504
diff changeset
660 if (delstr == NULL)
a0503bdb0c24 Fixed new seemingly random segfaults, by moving the initialization of
Tim Peters <tim.peters@gmail.com>
parents: 28504
diff changeset
661 Py_FatalError("gc couldn't allocate \"__del__\"");
a0503bdb0c24 Fixed new seemingly random segfaults, by moving the initialization of
Tim Peters <tim.peters@gmail.com>
parents: 28504
diff changeset
662 }
a0503bdb0c24 Fixed new seemingly random segfaults, by moving the initialization of
Tim Peters <tim.peters@gmail.com>
parents: 28504
diff changeset
663
13183
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
664 if (debug & DEBUG_STATS) {
23377
2f7d869dad4d Move all data for a single generation into a structure. The set of
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 23296
diff changeset
665 PySys_WriteStderr("gc: collecting generation %d...\n",
2f7d869dad4d Move all data for a single generation into a structure. The set of
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 23296
diff changeset
666 generation);
2f7d869dad4d Move all data for a single generation into a structure. The set of
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 23296
diff changeset
667 PySys_WriteStderr("gc: objects in each generation:");
2f7d869dad4d Move all data for a single generation into a structure. The set of
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 23296
diff changeset
668 for (i = 0; i < NUM_GENERATIONS; i++) {
2f7d869dad4d Move all data for a single generation into a structure. The set of
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 23296
diff changeset
669 PySys_WriteStderr(" %ld", gc_list_size(GEN_HEAD(i)));
2f7d869dad4d Move all data for a single generation into a structure. The set of
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 23296
diff changeset
670 }
2f7d869dad4d Move all data for a single generation into a structure. The set of
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 23296
diff changeset
671 PySys_WriteStderr("\n");
2f7d869dad4d Move all data for a single generation into a structure. The set of
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 23296
diff changeset
672 }
2f7d869dad4d Move all data for a single generation into a structure. The set of
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 23296
diff changeset
673
2f7d869dad4d Move all data for a single generation into a structure. The set of
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 23296
diff changeset
674 /* update collection and allocation counters */
2f7d869dad4d Move all data for a single generation into a structure. The set of
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 23296
diff changeset
675 if (generation+1 < NUM_GENERATIONS)
2f7d869dad4d Move all data for a single generation into a structure. The set of
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 23296
diff changeset
676 generations[generation+1].count += 1;
2f7d869dad4d Move all data for a single generation into a structure. The set of
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 23296
diff changeset
677 for (i = 0; i <= generation; i++)
24036
eae496efa460 Fix small bug. The count of objects in all generations younger then the
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 23832
diff changeset
678 generations[i].count = 0;
23377
2f7d869dad4d Move all data for a single generation into a structure. The set of
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 23296
diff changeset
679
2f7d869dad4d Move all data for a single generation into a structure. The set of
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 23296
diff changeset
680 /* merge younger generations with one we are currently collecting */
2f7d869dad4d Move all data for a single generation into a structure. The set of
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 23296
diff changeset
681 for (i = 0; i < generation; i++) {
2f7d869dad4d Move all data for a single generation into a structure. The set of
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 23296
diff changeset
682 gc_list_merge(GEN_HEAD(i), GEN_HEAD(generation));
2f7d869dad4d Move all data for a single generation into a structure. The set of
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 23296
diff changeset
683 }
2f7d869dad4d Move all data for a single generation into a structure. The set of
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 23296
diff changeset
684
2f7d869dad4d Move all data for a single generation into a structure. The set of
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 23296
diff changeset
685 /* handy references */
2f7d869dad4d Move all data for a single generation into a structure. The set of
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 23296
diff changeset
686 young = GEN_HEAD(generation);
24075
32db075def3f OK, I couldn't stand it <0.5 wink>: removed all uncertainty about what's
Tim Peters <tim.peters@gmail.com>
parents: 24074
diff changeset
687 if (generation < NUM_GENERATIONS-1)
23377
2f7d869dad4d Move all data for a single generation into a structure. The set of
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 23296
diff changeset
688 old = GEN_HEAD(generation+1);
24075
32db075def3f OK, I couldn't stand it <0.5 wink>: removed all uncertainty about what's
Tim Peters <tim.peters@gmail.com>
parents: 24074
diff changeset
689 else
32db075def3f OK, I couldn't stand it <0.5 wink>: removed all uncertainty about what's
Tim Peters <tim.peters@gmail.com>
parents: 24074
diff changeset
690 old = young;
13183
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
691
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
692 /* Using ob_refcnt and gc_refs, calculate which objects in the
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
693 * container set are reachable from outside the set (ie. have a
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
694 * refcount greater than 0 when all the references within the
24075
32db075def3f OK, I couldn't stand it <0.5 wink>: removed all uncertainty about what's
Tim Peters <tim.peters@gmail.com>
parents: 24074
diff changeset
695 * set are taken into account
32db075def3f OK, I couldn't stand it <0.5 wink>: removed all uncertainty about what's
Tim Peters <tim.peters@gmail.com>
parents: 24074
diff changeset
696 */
13183
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
697 update_refs(young);
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
698 subtract_refs(young);
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
699
24075
32db075def3f OK, I couldn't stand it <0.5 wink>: removed all uncertainty about what's
Tim Peters <tim.peters@gmail.com>
parents: 24074
diff changeset
700 /* Leave everything reachable from outside young in young, and move
32db075def3f OK, I couldn't stand it <0.5 wink>: removed all uncertainty about what's
Tim Peters <tim.peters@gmail.com>
parents: 24074
diff changeset
701 * everything else (in young) to unreachable.
32db075def3f OK, I couldn't stand it <0.5 wink>: removed all uncertainty about what's
Tim Peters <tim.peters@gmail.com>
parents: 24074
diff changeset
702 * NOTE: This used to move the reachable objects into a reachable
32db075def3f OK, I couldn't stand it <0.5 wink>: removed all uncertainty about what's
Tim Peters <tim.peters@gmail.com>
parents: 24074
diff changeset
703 * set instead. But most things usually turn out to be reachable,
32db075def3f OK, I couldn't stand it <0.5 wink>: removed all uncertainty about what's
Tim Peters <tim.peters@gmail.com>
parents: 24074
diff changeset
704 * so it's more efficient to move the unreachable things.
32db075def3f OK, I couldn't stand it <0.5 wink>: removed all uncertainty about what's
Tim Peters <tim.peters@gmail.com>
parents: 24074
diff changeset
705 */
13183
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
706 gc_list_init(&unreachable);
24075
32db075def3f OK, I couldn't stand it <0.5 wink>: removed all uncertainty about what's
Tim Peters <tim.peters@gmail.com>
parents: 24074
diff changeset
707 move_unreachable(young, &unreachable);
13183
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
708
24075
32db075def3f OK, I couldn't stand it <0.5 wink>: removed all uncertainty about what's
Tim Peters <tim.peters@gmail.com>
parents: 24074
diff changeset
709 /* Move reachable objects to next generation. */
32db075def3f OK, I couldn't stand it <0.5 wink>: removed all uncertainty about what's
Tim Peters <tim.peters@gmail.com>
parents: 24074
diff changeset
710 if (young != old)
32db075def3f OK, I couldn't stand it <0.5 wink>: removed all uncertainty about what's
Tim Peters <tim.peters@gmail.com>
parents: 24074
diff changeset
711 gc_list_merge(young, old);
13183
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
712
24075
32db075def3f OK, I couldn't stand it <0.5 wink>: removed all uncertainty about what's
Tim Peters <tim.peters@gmail.com>
parents: 24074
diff changeset
713 /* All objects in unreachable are trash, but objects reachable from
32db075def3f OK, I couldn't stand it <0.5 wink>: removed all uncertainty about what's
Tim Peters <tim.peters@gmail.com>
parents: 24074
diff changeset
714 * finalizers can't safely be deleted. Python programmers should take
32db075def3f OK, I couldn't stand it <0.5 wink>: removed all uncertainty about what's
Tim Peters <tim.peters@gmail.com>
parents: 24074
diff changeset
715 * care not to create such things. For Python, finalizers means
30988
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults.
Tim Peters <tim.peters@gmail.com>
parents: 30918
diff changeset
716 * instance objects with __del__ methods. Weakrefs with callbacks
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults.
Tim Peters <tim.peters@gmail.com>
parents: 30918
diff changeset
717 * can call arbitrary Python code, so those are special-cased too.
28507
a0503bdb0c24 Fixed new seemingly random segfaults, by moving the initialization of
Tim Peters <tim.peters@gmail.com>
parents: 28504
diff changeset
718 *
30988
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults.
Tim Peters <tim.peters@gmail.com>
parents: 30918
diff changeset
719 * Move unreachable objects with finalizers, and weakrefs with
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults.
Tim Peters <tim.peters@gmail.com>
parents: 30918
diff changeset
720 * callbacks, into different lists.
28520
6653a56002ef Reworked has_finalizer() to use the new _PyObject_Lookup() instead
Tim Peters <tim.peters@gmail.com>
parents: 28516
diff changeset
721 */
13183
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
722 gc_list_init(&finalizers);
30988
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults.
Tim Peters <tim.peters@gmail.com>
parents: 30918
diff changeset
723 gc_list_init(&wr_callbacks);
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults.
Tim Peters <tim.peters@gmail.com>
parents: 30918
diff changeset
724 move_troublemakers(&unreachable, &finalizers, &wr_callbacks);
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults.
Tim Peters <tim.peters@gmail.com>
parents: 30918
diff changeset
725 /* Clear the trash weakrefs with callbacks. This prevents their
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults.
Tim Peters <tim.peters@gmail.com>
parents: 30918
diff changeset
726 * callbacks from getting invoked (when a weakref goes away, so does
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults.
Tim Peters <tim.peters@gmail.com>
parents: 30918
diff changeset
727 * its callback).
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults.
Tim Peters <tim.peters@gmail.com>
parents: 30918
diff changeset
728 * We do this even if the weakrefs are reachable from finalizers.
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults.
Tim Peters <tim.peters@gmail.com>
parents: 30918
diff changeset
729 * If we didn't, breaking cycles in unreachable later could trigger
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults.
Tim Peters <tim.peters@gmail.com>
parents: 30918
diff changeset
730 * deallocation of objects in finalizers, which could in turn
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults.
Tim Peters <tim.peters@gmail.com>
parents: 30918
diff changeset
731 * cause callbacks to trigger. This may not be ideal behavior.
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults.
Tim Peters <tim.peters@gmail.com>
parents: 30918
diff changeset
732 */
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults.
Tim Peters <tim.peters@gmail.com>
parents: 30918
diff changeset
733 clear_weakrefs(&wr_callbacks);
28511
acf3596fcc28 Reworked move_finalizer_reachable() to create two distinct lists:
Tim Peters <tim.peters@gmail.com>
parents: 28510
diff changeset
734 /* finalizers contains the unreachable objects with a finalizer;
30988
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults.
Tim Peters <tim.peters@gmail.com>
parents: 30918
diff changeset
735 * unreachable objects reachable *from* those are also uncollectable,
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults.
Tim Peters <tim.peters@gmail.com>
parents: 30918
diff changeset
736 * and we move those into the finalizers list too.
28511
acf3596fcc28 Reworked move_finalizer_reachable() to create two distinct lists:
Tim Peters <tim.peters@gmail.com>
parents: 28510
diff changeset
737 */
28520
6653a56002ef Reworked has_finalizer() to use the new _PyObject_Lookup() instead
Tim Peters <tim.peters@gmail.com>
parents: 28516
diff changeset
738 move_finalizer_reachable(&finalizers);
13183
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
739
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
740 /* Collect statistics on collectable objects found and print
30988
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults.
Tim Peters <tim.peters@gmail.com>
parents: 30918
diff changeset
741 * debugging information.
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults.
Tim Peters <tim.peters@gmail.com>
parents: 30918
diff changeset
742 */
28520
6653a56002ef Reworked has_finalizer() to use the new _PyObject_Lookup() instead
Tim Peters <tim.peters@gmail.com>
parents: 28516
diff changeset
743 for (gc = unreachable.gc.gc_next; gc != &unreachable;
20381
b4f829941f3d SF bug [#467145] Python 2.2a4 build problem on HPUX 11.0.
Tim Peters <tim.peters@gmail.com>
parents: 20296
diff changeset
744 gc = gc->gc.gc_next) {
13183
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
745 m++;
14294
053627e7ac14 apply patch #101362 by Vladimir Marangozov
Jeremy Hylton <jeremy@alum.mit.edu>
parents: 13878
diff changeset
746 if (debug & DEBUG_COLLECTABLE) {
19585
c43d7a8f00a4 Make more things internal to this file. Remove
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 19128
diff changeset
747 debug_cycle("collectable", FROM_GC(gc));
13183
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
748 }
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
749 }
28521
964bd97ac1f5 Comment repair; no semantic changes.
Tim Peters <tim.peters@gmail.com>
parents: 28520
diff changeset
750 /* Call tp_clear on objects in the unreachable set. This will cause
964bd97ac1f5 Comment repair; no semantic changes.
Tim Peters <tim.peters@gmail.com>
parents: 28520
diff changeset
751 * the reference cycles to be broken. It may also cause some objects
964bd97ac1f5 Comment repair; no semantic changes.
Tim Peters <tim.peters@gmail.com>
parents: 28520
diff changeset
752 * in finalizers to be freed.
964bd97ac1f5 Comment repair; no semantic changes.
Tim Peters <tim.peters@gmail.com>
parents: 28520
diff changeset
753 */
28520
6653a56002ef Reworked has_finalizer() to use the new _PyObject_Lookup() instead
Tim Peters <tim.peters@gmail.com>
parents: 28516
diff changeset
754 delete_garbage(&unreachable, old);
13183
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
755
30988
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults.
Tim Peters <tim.peters@gmail.com>
parents: 30918
diff changeset
756 /* Now that we're done analyzing stuff and breaking cycles, let
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults.
Tim Peters <tim.peters@gmail.com>
parents: 30918
diff changeset
757 * delayed weakref callbacks run.
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults.
Tim Peters <tim.peters@gmail.com>
parents: 30918
diff changeset
758 */
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults.
Tim Peters <tim.peters@gmail.com>
parents: 30918
diff changeset
759 m += release_weakrefs(&wr_callbacks, old);
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults.
Tim Peters <tim.peters@gmail.com>
parents: 30918
diff changeset
760
13183
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
761 /* Collect statistics on uncollectable objects found and print
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
762 * debugging information. */
28512
174ce4cdec47 Switched from METH_VARARGS to METH_NOARGS for the 7 module functions that
Tim Peters <tim.peters@gmail.com>
parents: 28511
diff changeset
763 for (gc = finalizers.gc.gc_next;
28511
acf3596fcc28 Reworked move_finalizer_reachable() to create two distinct lists:
Tim Peters <tim.peters@gmail.com>
parents: 28510
diff changeset
764 gc != &finalizers;
acf3596fcc28 Reworked move_finalizer_reachable() to create two distinct lists:
Tim Peters <tim.peters@gmail.com>
parents: 28510
diff changeset
765 gc = gc->gc.gc_next) {
13183
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
766 n++;
28511
acf3596fcc28 Reworked move_finalizer_reachable() to create two distinct lists:
Tim Peters <tim.peters@gmail.com>
parents: 28510
diff changeset
767 if (debug & DEBUG_UNCOLLECTABLE)
19585
c43d7a8f00a4 Make more things internal to this file. Remove
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 19128
diff changeset
768 debug_cycle("uncollectable", FROM_GC(gc));
28511
acf3596fcc28 Reworked move_finalizer_reachable() to create two distinct lists:
Tim Peters <tim.peters@gmail.com>
parents: 28510
diff changeset
769 }
14294
053627e7ac14 apply patch #101362 by Vladimir Marangozov
Jeremy Hylton <jeremy@alum.mit.edu>
parents: 13878
diff changeset
770 if (debug & DEBUG_STATS) {
13183
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
771 if (m == 0 && n == 0) {
14294
053627e7ac14 apply patch #101362 by Vladimir Marangozov
Jeremy Hylton <jeremy@alum.mit.edu>
parents: 13878
diff changeset
772 PySys_WriteStderr("gc: done.\n");
14756
6e9331e68a3b - Add DEBUG_SAVEALL option. When enabled all garbage objects found by the
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 14424
diff changeset
773 }
6e9331e68a3b - Add DEBUG_SAVEALL option. When enabled all garbage objects found by the
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 14424
diff changeset
774 else {
14294
053627e7ac14 apply patch #101362 by Vladimir Marangozov
Jeremy Hylton <jeremy@alum.mit.edu>
parents: 13878
diff changeset
775 PySys_WriteStderr(
053627e7ac14 apply patch #101362 by Vladimir Marangozov
Jeremy Hylton <jeremy@alum.mit.edu>
parents: 13878
diff changeset
776 "gc: done, %ld unreachable, %ld uncollectable.\n",
053627e7ac14 apply patch #101362 by Vladimir Marangozov
Jeremy Hylton <jeremy@alum.mit.edu>
parents: 13878
diff changeset
777 n+m, n);
13183
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
778 }
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
779 }
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
780
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
781 /* Append instances in the uncollectable set to a Python
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
782 * reachable list of garbage. The programmer has to deal with
28511
acf3596fcc28 Reworked move_finalizer_reachable() to create two distinct lists:
Tim Peters <tim.peters@gmail.com>
parents: 28510
diff changeset
783 * this if they insist on creating this type of structure.
acf3596fcc28 Reworked move_finalizer_reachable() to create two distinct lists:
Tim Peters <tim.peters@gmail.com>
parents: 28510
diff changeset
784 */
28520
6653a56002ef Reworked has_finalizer() to use the new _PyObject_Lookup() instead
Tim Peters <tim.peters@gmail.com>
parents: 28516
diff changeset
785 (void)handle_finalizers(&finalizers, old);
13183
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
786
14330
6dee1985c681 refactor __del__ exception handler into PyErr_WriteUnraisable
Jeremy Hylton <jeremy@alum.mit.edu>
parents: 14294
diff changeset
787 if (PyErr_Occurred()) {
28520
6653a56002ef Reworked has_finalizer() to use the new _PyObject_Lookup() instead
Tim Peters <tim.peters@gmail.com>
parents: 28516
diff changeset
788 if (gc_str == NULL)
28521
964bd97ac1f5 Comment repair; no semantic changes.
Tim Peters <tim.peters@gmail.com>
parents: 28520
diff changeset
789 gc_str = PyString_FromString("garbage collection");
14330
6dee1985c681 refactor __del__ exception handler into PyErr_WriteUnraisable
Jeremy Hylton <jeremy@alum.mit.edu>
parents: 14294
diff changeset
790 PyErr_WriteUnraisable(gc_str);
6dee1985c681 refactor __del__ exception handler into PyErr_WriteUnraisable
Jeremy Hylton <jeremy@alum.mit.edu>
parents: 14294
diff changeset
791 Py_FatalError("unexpected exception during garbage collection");
6dee1985c681 refactor __del__ exception handler into PyErr_WriteUnraisable
Jeremy Hylton <jeremy@alum.mit.edu>
parents: 14294
diff changeset
792 }
13183
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
793 return n+m;
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
794 }
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
795
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
796 static long
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
797 collect_generations(void)
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
798 {
23377
2f7d869dad4d Move all data for a single generation into a structure. The set of
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 23296
diff changeset
799 int i;
13490
cb539824448e Initialize the return value in collect_generations() since it is updated
Vladimir Marangozov <vladimir.marangozov@t-online.de>
parents: 13183
diff changeset
800 long n = 0;
13183
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
801
23377
2f7d869dad4d Move all data for a single generation into a structure. The set of
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 23296
diff changeset
802 /* Find the oldest generation (higest numbered) where the count
2f7d869dad4d Move all data for a single generation into a structure. The set of
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 23296
diff changeset
803 * exceeds the threshold. Objects in the that generation and
2f7d869dad4d Move all data for a single generation into a structure. The set of
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 23296
diff changeset
804 * generations younger than it will be collected. */
2f7d869dad4d Move all data for a single generation into a structure. The set of
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 23296
diff changeset
805 for (i = NUM_GENERATIONS-1; i >= 0; i--) {
2f7d869dad4d Move all data for a single generation into a structure. The set of
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 23296
diff changeset
806 if (generations[i].count > generations[i].threshold) {
2f7d869dad4d Move all data for a single generation into a structure. The set of
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 23296
diff changeset
807 n = collect(i);
2f7d869dad4d Move all data for a single generation into a structure. The set of
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 23296
diff changeset
808 break;
13183
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
809 }
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
810 }
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
811 return n;
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
812 }
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
813
23832
ed1ba37a46b7 Patch #568124: Add doc string macros.
Martin v. Löwis <martin@v.loewis.de>
parents: 23721
diff changeset
814 PyDoc_STRVAR(gc_enable__doc__,
13878
abfa4e4b2f3e Neil Schemenauer: GC enable(), disable(), isenabled() interface.
Vladimir Marangozov <vladimir.marangozov@t-online.de>
parents: 13570
diff changeset
815 "enable() -> None\n"
abfa4e4b2f3e Neil Schemenauer: GC enable(), disable(), isenabled() interface.
Vladimir Marangozov <vladimir.marangozov@t-online.de>
parents: 13570
diff changeset
816 "\n"
23832
ed1ba37a46b7 Patch #568124: Add doc string macros.
Martin v. Löwis <martin@v.loewis.de>
parents: 23721
diff changeset
817 "Enable automatic garbage collection.\n");
13183
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
818
13878
abfa4e4b2f3e Neil Schemenauer: GC enable(), disable(), isenabled() interface.
Vladimir Marangozov <vladimir.marangozov@t-online.de>
parents: 13570
diff changeset
819 static PyObject *
28512
174ce4cdec47 Switched from METH_VARARGS to METH_NOARGS for the 7 module functions that
Tim Peters <tim.peters@gmail.com>
parents: 28511
diff changeset
820 gc_enable(PyObject *self, PyObject *noargs)
13878
abfa4e4b2f3e Neil Schemenauer: GC enable(), disable(), isenabled() interface.
Vladimir Marangozov <vladimir.marangozov@t-online.de>
parents: 13570
diff changeset
821 {
abfa4e4b2f3e Neil Schemenauer: GC enable(), disable(), isenabled() interface.
Vladimir Marangozov <vladimir.marangozov@t-online.de>
parents: 13570
diff changeset
822 enabled = 1;
abfa4e4b2f3e Neil Schemenauer: GC enable(), disable(), isenabled() interface.
Vladimir Marangozov <vladimir.marangozov@t-online.de>
parents: 13570
diff changeset
823 Py_INCREF(Py_None);
abfa4e4b2f3e Neil Schemenauer: GC enable(), disable(), isenabled() interface.
Vladimir Marangozov <vladimir.marangozov@t-online.de>
parents: 13570
diff changeset
824 return Py_None;
abfa4e4b2f3e Neil Schemenauer: GC enable(), disable(), isenabled() interface.
Vladimir Marangozov <vladimir.marangozov@t-online.de>
parents: 13570
diff changeset
825 }
abfa4e4b2f3e Neil Schemenauer: GC enable(), disable(), isenabled() interface.
Vladimir Marangozov <vladimir.marangozov@t-online.de>
parents: 13570
diff changeset
826
23832
ed1ba37a46b7 Patch #568124: Add doc string macros.
Martin v. Löwis <martin@v.loewis.de>
parents: 23721
diff changeset
827 PyDoc_STRVAR(gc_disable__doc__,
13878
abfa4e4b2f3e Neil Schemenauer: GC enable(), disable(), isenabled() interface.
Vladimir Marangozov <vladimir.marangozov@t-online.de>
parents: 13570
diff changeset
828 "disable() -> None\n"
abfa4e4b2f3e Neil Schemenauer: GC enable(), disable(), isenabled() interface.
Vladimir Marangozov <vladimir.marangozov@t-online.de>
parents: 13570
diff changeset
829 "\n"
23832
ed1ba37a46b7 Patch #568124: Add doc string macros.
Martin v. Löwis <martin@v.loewis.de>
parents: 23721
diff changeset
830 "Disable automatic garbage collection.\n");
13878
abfa4e4b2f3e Neil Schemenauer: GC enable(), disable(), isenabled() interface.
Vladimir Marangozov <vladimir.marangozov@t-online.de>
parents: 13570
diff changeset
831
abfa4e4b2f3e Neil Schemenauer: GC enable(), disable(), isenabled() interface.
Vladimir Marangozov <vladimir.marangozov@t-online.de>
parents: 13570
diff changeset
832 static PyObject *
28512
174ce4cdec47 Switched from METH_VARARGS to METH_NOARGS for the 7 module functions that
Tim Peters <tim.peters@gmail.com>
parents: 28511
diff changeset
833 gc_disable(PyObject *self, PyObject *noargs)
13878
abfa4e4b2f3e Neil Schemenauer: GC enable(), disable(), isenabled() interface.
Vladimir Marangozov <vladimir.marangozov@t-online.de>
parents: 13570
diff changeset
834 {
abfa4e4b2f3e Neil Schemenauer: GC enable(), disable(), isenabled() interface.
Vladimir Marangozov <vladimir.marangozov@t-online.de>
parents: 13570
diff changeset
835 enabled = 0;
abfa4e4b2f3e Neil Schemenauer: GC enable(), disable(), isenabled() interface.
Vladimir Marangozov <vladimir.marangozov@t-online.de>
parents: 13570
diff changeset
836 Py_INCREF(Py_None);
abfa4e4b2f3e Neil Schemenauer: GC enable(), disable(), isenabled() interface.
Vladimir Marangozov <vladimir.marangozov@t-online.de>
parents: 13570
diff changeset
837 return Py_None;
abfa4e4b2f3e Neil Schemenauer: GC enable(), disable(), isenabled() interface.
Vladimir Marangozov <vladimir.marangozov@t-online.de>
parents: 13570
diff changeset
838 }
abfa4e4b2f3e Neil Schemenauer: GC enable(), disable(), isenabled() interface.
Vladimir Marangozov <vladimir.marangozov@t-online.de>
parents: 13570
diff changeset
839
23832
ed1ba37a46b7 Patch #568124: Add doc string macros.
Martin v. Löwis <martin@v.loewis.de>
parents: 23721
diff changeset
840 PyDoc_STRVAR(gc_isenabled__doc__,
13878
abfa4e4b2f3e Neil Schemenauer: GC enable(), disable(), isenabled() interface.
Vladimir Marangozov <vladimir.marangozov@t-online.de>
parents: 13570
diff changeset
841 "isenabled() -> status\n"
abfa4e4b2f3e Neil Schemenauer: GC enable(), disable(), isenabled() interface.
Vladimir Marangozov <vladimir.marangozov@t-online.de>
parents: 13570
diff changeset
842 "\n"
23832
ed1ba37a46b7 Patch #568124: Add doc string macros.
Martin v. Löwis <martin@v.loewis.de>
parents: 23721
diff changeset
843 "Returns true if automatic garbage collection is enabled.\n");
13878
abfa4e4b2f3e Neil Schemenauer: GC enable(), disable(), isenabled() interface.
Vladimir Marangozov <vladimir.marangozov@t-online.de>
parents: 13570
diff changeset
844
abfa4e4b2f3e Neil Schemenauer: GC enable(), disable(), isenabled() interface.
Vladimir Marangozov <vladimir.marangozov@t-online.de>
parents: 13570
diff changeset
845 static PyObject *
28512
174ce4cdec47 Switched from METH_VARARGS to METH_NOARGS for the 7 module functions that
Tim Peters <tim.peters@gmail.com>
parents: 28511
diff changeset
846 gc_isenabled(PyObject *self, PyObject *noargs)
13878
abfa4e4b2f3e Neil Schemenauer: GC enable(), disable(), isenabled() interface.
Vladimir Marangozov <vladimir.marangozov@t-online.de>
parents: 13570
diff changeset
847 {
31341
4915fbec608f Convert return value to boolean.
Raymond Hettinger <python@rcn.com>
parents: 31010
diff changeset
848 return PyBool_FromLong((long)enabled);
13878
abfa4e4b2f3e Neil Schemenauer: GC enable(), disable(), isenabled() interface.
Vladimir Marangozov <vladimir.marangozov@t-online.de>
parents: 13570
diff changeset
849 }
abfa4e4b2f3e Neil Schemenauer: GC enable(), disable(), isenabled() interface.
Vladimir Marangozov <vladimir.marangozov@t-online.de>
parents: 13570
diff changeset
850
23832
ed1ba37a46b7 Patch #568124: Add doc string macros.
Martin v. Löwis <martin@v.loewis.de>
parents: 23721
diff changeset
851 PyDoc_STRVAR(gc_collect__doc__,
13183
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
852 "collect() -> n\n"
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
853 "\n"
23832
ed1ba37a46b7 Patch #568124: Add doc string macros.
Martin v. Löwis <martin@v.loewis.de>
parents: 23721
diff changeset
854 "Run a full collection. The number of unreachable objects is returned.\n");
13183
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
855
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
856 static PyObject *
28512
174ce4cdec47 Switched from METH_VARARGS to METH_NOARGS for the 7 module functions that
Tim Peters <tim.peters@gmail.com>
parents: 28511
diff changeset
857 gc_collect(PyObject *self, PyObject *noargs)
13183
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
858 {
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
859 long n;
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
860
28512
174ce4cdec47 Switched from METH_VARARGS to METH_NOARGS for the 7 module functions that
Tim Peters <tim.peters@gmail.com>
parents: 28511
diff changeset
861 if (collecting)
20796
9c23abab962d Make the gc.collect() function respect the collection lock. This fixes
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 20393
diff changeset
862 n = 0; /* already collecting, don't do anything */
9c23abab962d Make the gc.collect() function respect the collection lock. This fixes
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 20393
diff changeset
863 else {
9c23abab962d Make the gc.collect() function respect the collection lock. This fixes
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 20393
diff changeset
864 collecting = 1;
23377
2f7d869dad4d Move all data for a single generation into a structure. The set of
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 23296
diff changeset
865 n = collect(NUM_GENERATIONS - 1);
20796
9c23abab962d Make the gc.collect() function respect the collection lock. This fixes
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 20393
diff changeset
866 collecting = 0;
9c23abab962d Make the gc.collect() function respect the collection lock. This fixes
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 20393
diff changeset
867 }
13183
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
868
14774
52174b002f1f Fix some long/"l" int/"i" mismatches. Fixes bug #113779.
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 14756
diff changeset
869 return Py_BuildValue("l", n);
13183
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
870 }
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
871
23832
ed1ba37a46b7 Patch #568124: Add doc string macros.
Martin v. Löwis <martin@v.loewis.de>
parents: 23721
diff changeset
872 PyDoc_STRVAR(gc_set_debug__doc__,
13183
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
873 "set_debug(flags) -> None\n"
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
874 "\n"
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
875 "Set the garbage collection debugging flags. Debugging information is\n"
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
876 "written to sys.stderr.\n"
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
877 "\n"
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
878 "flags is an integer and can have the following bits turned on:\n"
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
879 "\n"
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
880 " DEBUG_STATS - Print statistics during collection.\n"
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
881 " DEBUG_COLLECTABLE - Print collectable objects found.\n"
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
882 " DEBUG_UNCOLLECTABLE - Print unreachable but uncollectable objects found.\n"
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
883 " DEBUG_INSTANCES - Print instance objects.\n"
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
884 " DEBUG_OBJECTS - Print objects other than instances.\n"
14756
6e9331e68a3b - Add DEBUG_SAVEALL option. When enabled all garbage objects found by the
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 14424
diff changeset
885 " DEBUG_SAVEALL - Save objects to gc.garbage rather than freeing them.\n"
23832
ed1ba37a46b7 Patch #568124: Add doc string macros.
Martin v. Löwis <martin@v.loewis.de>
parents: 23721
diff changeset
886 " DEBUG_LEAK - Debug leaking programs (everything but STATS).\n");
13183
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
887
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
888 static PyObject *
13878
abfa4e4b2f3e Neil Schemenauer: GC enable(), disable(), isenabled() interface.
Vladimir Marangozov <vladimir.marangozov@t-online.de>
parents: 13570
diff changeset
889 gc_set_debug(PyObject *self, PyObject *args)
13183
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
890 {
14774
52174b002f1f Fix some long/"l" int/"i" mismatches. Fixes bug #113779.
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 14756
diff changeset
891 if (!PyArg_ParseTuple(args, "i:set_debug", &debug))
13183
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
892 return NULL;
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
893
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
894 Py_INCREF(Py_None);
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
895 return Py_None;
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
896 }
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
897
23832
ed1ba37a46b7 Patch #568124: Add doc string macros.
Martin v. Löwis <martin@v.loewis.de>
parents: 23721
diff changeset
898 PyDoc_STRVAR(gc_get_debug__doc__,
13183
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
899 "get_debug() -> flags\n"
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
900 "\n"
23832
ed1ba37a46b7 Patch #568124: Add doc string macros.
Martin v. Löwis <martin@v.loewis.de>
parents: 23721
diff changeset
901 "Get the garbage collection debugging flags.\n");
13183
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
902
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
903 static PyObject *
28512
174ce4cdec47 Switched from METH_VARARGS to METH_NOARGS for the 7 module functions that
Tim Peters <tim.peters@gmail.com>
parents: 28511
diff changeset
904 gc_get_debug(PyObject *self, PyObject *noargs)
13183
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
905 {
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
906 return Py_BuildValue("i", debug);
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
907 }
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
908
23832
ed1ba37a46b7 Patch #568124: Add doc string macros.
Martin v. Löwis <martin@v.loewis.de>
parents: 23721
diff changeset
909 PyDoc_STRVAR(gc_set_thresh__doc__,
21833
070d392042e3 Fix spelling mistakes. Bugfix candidates.
Neal Norwitz <nnorwitz@gmail.com>
parents: 21139
diff changeset
910 "set_threshold(threshold0, [threshold1, threshold2]) -> None\n"
13183
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
911 "\n"
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
912 "Sets the collection thresholds. Setting threshold0 to zero disables\n"
23832
ed1ba37a46b7 Patch #568124: Add doc string macros.
Martin v. Löwis <martin@v.loewis.de>
parents: 23721
diff changeset
913 "collection.\n");
13183
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
914
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
915 static PyObject *
13878
abfa4e4b2f3e Neil Schemenauer: GC enable(), disable(), isenabled() interface.
Vladimir Marangozov <vladimir.marangozov@t-online.de>
parents: 13570
diff changeset
916 gc_set_thresh(PyObject *self, PyObject *args)
13183
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
917 {
23377
2f7d869dad4d Move all data for a single generation into a structure. The set of
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 23296
diff changeset
918 int i;
2f7d869dad4d Move all data for a single generation into a structure. The set of
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 23296
diff changeset
919 if (!PyArg_ParseTuple(args, "i|ii:set_threshold",
2f7d869dad4d Move all data for a single generation into a structure. The set of
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 23296
diff changeset
920 &generations[0].threshold,
2f7d869dad4d Move all data for a single generation into a structure. The set of
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 23296
diff changeset
921 &generations[1].threshold,
2f7d869dad4d Move all data for a single generation into a structure. The set of
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 23296
diff changeset
922 &generations[2].threshold))
13183
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
923 return NULL;
23377
2f7d869dad4d Move all data for a single generation into a structure. The set of
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 23296
diff changeset
924 for (i = 2; i < NUM_GENERATIONS; i++) {
2f7d869dad4d Move all data for a single generation into a structure. The set of
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 23296
diff changeset
925 /* generations higher than 2 get the same threshold */
2f7d869dad4d Move all data for a single generation into a structure. The set of
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 23296
diff changeset
926 generations[i].threshold = generations[2].threshold;
2f7d869dad4d Move all data for a single generation into a structure. The set of
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 23296
diff changeset
927 }
13183
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
928
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
929 Py_INCREF(Py_None);
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
930 return Py_None;
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
931 }
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
932
23832
ed1ba37a46b7 Patch #568124: Add doc string macros.
Martin v. Löwis <martin@v.loewis.de>
parents: 23721
diff changeset
933 PyDoc_STRVAR(gc_get_thresh__doc__,
13183
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
934 "get_threshold() -> (threshold0, threshold1, threshold2)\n"
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
935 "\n"
23832
ed1ba37a46b7 Patch #568124: Add doc string macros.
Martin v. Löwis <martin@v.loewis.de>
parents: 23721
diff changeset
936 "Return the current collection thresholds\n");
13183
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
937
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
938 static PyObject *
28512
174ce4cdec47 Switched from METH_VARARGS to METH_NOARGS for the 7 module functions that
Tim Peters <tim.peters@gmail.com>
parents: 28511
diff changeset
939 gc_get_thresh(PyObject *self, PyObject *noargs)
13183
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
940 {
23377
2f7d869dad4d Move all data for a single generation into a structure. The set of
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 23296
diff changeset
941 return Py_BuildValue("(iii)",
2f7d869dad4d Move all data for a single generation into a structure. The set of
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 23296
diff changeset
942 generations[0].threshold,
2f7d869dad4d Move all data for a single generation into a structure. The set of
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 23296
diff changeset
943 generations[1].threshold,
2f7d869dad4d Move all data for a single generation into a structure. The set of
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 23296
diff changeset
944 generations[2].threshold);
13183
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
945 }
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
946
19096
45ccf3b889b5 Add get_referents function. Closes SF patch #402925.
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 15013
diff changeset
947 static int
21038
afb789aada16 Rename get_referents to get_referrers. Fixes #483815.
Martin v. Löwis <martin@v.loewis.de>
parents: 20820
diff changeset
948 referrersvisit(PyObject* obj, PyObject *objs)
19096
45ccf3b889b5 Add get_referents function. Closes SF patch #402925.
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 15013
diff changeset
949 {
21105
d19513e2893c Use identity instead of equality when looking for referrers. Fixes #485781.
Martin v. Löwis <martin@v.loewis.de>
parents: 21038
diff changeset
950 int i;
d19513e2893c Use identity instead of equality when looking for referrers. Fixes #485781.
Martin v. Löwis <martin@v.loewis.de>
parents: 21038
diff changeset
951 for (i = 0; i < PyTuple_GET_SIZE(objs); i++)
d19513e2893c Use identity instead of equality when looking for referrers. Fixes #485781.
Martin v. Löwis <martin@v.loewis.de>
parents: 21038
diff changeset
952 if (PyTuple_GET_ITEM(objs, i) == obj)
d19513e2893c Use identity instead of equality when looking for referrers. Fixes #485781.
Martin v. Löwis <martin@v.loewis.de>
parents: 21038
diff changeset
953 return 1;
19096
45ccf3b889b5 Add get_referents function. Closes SF patch #402925.
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 15013
diff changeset
954 return 0;
45ccf3b889b5 Add get_referents function. Closes SF patch #402925.
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 15013
diff changeset
955 }
45ccf3b889b5 Add get_referents function. Closes SF patch #402925.
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 15013
diff changeset
956
19128
4901a935490d Remove "referents" structure (it's not needed). Check return value
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 19097
diff changeset
957 static int
21038
afb789aada16 Rename get_referents to get_referrers. Fixes #483815.
Martin v. Löwis <martin@v.loewis.de>
parents: 20820
diff changeset
958 gc_referrers_for(PyObject *objs, PyGC_Head *list, PyObject *resultlist)
19096
45ccf3b889b5 Add get_referents function. Closes SF patch #402925.
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 15013
diff changeset
959 {
45ccf3b889b5 Add get_referents function. Closes SF patch #402925.
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 15013
diff changeset
960 PyGC_Head *gc;
45ccf3b889b5 Add get_referents function. Closes SF patch #402925.
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 15013
diff changeset
961 PyObject *obj;
45ccf3b889b5 Add get_referents function. Closes SF patch #402925.
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 15013
diff changeset
962 traverseproc traverse;
20381
b4f829941f3d SF bug [#467145] Python 2.2a4 build problem on HPUX 11.0.
Tim Peters <tim.peters@gmail.com>
parents: 20296
diff changeset
963 for (gc = list->gc.gc_next; gc != list; gc = gc->gc.gc_next) {
19585
c43d7a8f00a4 Make more things internal to this file. Remove
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 19128
diff changeset
964 obj = FROM_GC(gc);
19096
45ccf3b889b5 Add get_referents function. Closes SF patch #402925.
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 15013
diff changeset
965 traverse = obj->ob_type->tp_traverse;
45ccf3b889b5 Add get_referents function. Closes SF patch #402925.
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 15013
diff changeset
966 if (obj == objs || obj == resultlist)
45ccf3b889b5 Add get_referents function. Closes SF patch #402925.
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 15013
diff changeset
967 continue;
21038
afb789aada16 Rename get_referents to get_referrers. Fixes #483815.
Martin v. Löwis <martin@v.loewis.de>
parents: 20820
diff changeset
968 if (traverse(obj, (visitproc)referrersvisit, objs)) {
19128
4901a935490d Remove "referents" structure (it's not needed). Check return value
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 19097
diff changeset
969 if (PyList_Append(resultlist, obj) < 0)
4901a935490d Remove "referents" structure (it's not needed). Check return value
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 19097
diff changeset
970 return 0; /* error */
19096
45ccf3b889b5 Add get_referents function. Closes SF patch #402925.
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 15013
diff changeset
971 }
45ccf3b889b5 Add get_referents function. Closes SF patch #402925.
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 15013
diff changeset
972 }
19128
4901a935490d Remove "referents" structure (it's not needed). Check return value
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 19097
diff changeset
973 return 1; /* no error */
19096
45ccf3b889b5 Add get_referents function. Closes SF patch #402925.
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 15013
diff changeset
974 }
45ccf3b889b5 Add get_referents function. Closes SF patch #402925.
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 15013
diff changeset
975
23832
ed1ba37a46b7 Patch #568124: Add doc string macros.
Martin v. Löwis <martin@v.loewis.de>
parents: 23721
diff changeset
976 PyDoc_STRVAR(gc_get_referrers__doc__,
21038
afb789aada16 Rename get_referents to get_referrers. Fixes #483815.
Martin v. Löwis <martin@v.loewis.de>
parents: 20820
diff changeset
977 "get_referrers(*objs) -> list\n\
23832
ed1ba37a46b7 Patch #568124: Add doc string macros.
Martin v. Löwis <martin@v.loewis.de>
parents: 23721
diff changeset
978 Return the list of objects that directly refer to any of objs.");
19096
45ccf3b889b5 Add get_referents function. Closes SF patch #402925.
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 15013
diff changeset
979
19128
4901a935490d Remove "referents" structure (it's not needed). Check return value
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 19097
diff changeset
980 static PyObject *
21038
afb789aada16 Rename get_referents to get_referrers. Fixes #483815.
Martin v. Löwis <martin@v.loewis.de>
parents: 20820
diff changeset
981 gc_get_referrers(PyObject *self, PyObject *args)
19096
45ccf3b889b5 Add get_referents function. Closes SF patch #402925.
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 15013
diff changeset
982 {
23377
2f7d869dad4d Move all data for a single generation into a structure. The set of
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 23296
diff changeset
983 int i;
19096
45ccf3b889b5 Add get_referents function. Closes SF patch #402925.
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 15013
diff changeset
984 PyObject *result = PyList_New(0);
23377
2f7d869dad4d Move all data for a single generation into a structure. The set of
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 23296
diff changeset
985 for (i = 0; i < NUM_GENERATIONS; i++) {
2f7d869dad4d Move all data for a single generation into a structure. The set of
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 23296
diff changeset
986 if (!(gc_referrers_for(args, GEN_HEAD(i), result))) {
2f7d869dad4d Move all data for a single generation into a structure. The set of
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 23296
diff changeset
987 Py_DECREF(result);
2f7d869dad4d Move all data for a single generation into a structure. The set of
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 23296
diff changeset
988 return NULL;
2f7d869dad4d Move all data for a single generation into a structure. The set of
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 23296
diff changeset
989 }
19128
4901a935490d Remove "referents" structure (it's not needed). Check return value
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 19097
diff changeset
990 }
19096
45ccf3b889b5 Add get_referents function. Closes SF patch #402925.
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 15013
diff changeset
991 return result;
45ccf3b889b5 Add get_referents function. Closes SF patch #402925.
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 15013
diff changeset
992 }
13183
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
993
28522
487df294d328 Finished implementing gc.get_referrents(): dealt with error and end
Tim Peters <tim.peters@gmail.com>
parents: 28521
diff changeset
994 /* Append obj to list; return true if error (out of memory), false if OK. */
28497
40d9659b56c9 Add get_referrents() helper function.
Jeremy Hylton <jeremy@alum.mit.edu>
parents: 26138
diff changeset
995 static int
28523
c01fdc3a9180 s/referrents/referents/g. Gotta love that referrers remains rife with rs.
Tim Peters <tim.peters@gmail.com>
parents: 28522
diff changeset
996 referentsvisit(PyObject *obj, PyObject *list)
28497
40d9659b56c9 Add get_referrents() helper function.
Jeremy Hylton <jeremy@alum.mit.edu>
parents: 26138
diff changeset
997 {
28522
487df294d328 Finished implementing gc.get_referrents(): dealt with error and end
Tim Peters <tim.peters@gmail.com>
parents: 28521
diff changeset
998 return PyList_Append(list, obj) < 0;
28497
40d9659b56c9 Add get_referrents() helper function.
Jeremy Hylton <jeremy@alum.mit.edu>
parents: 26138
diff changeset
999 }
40d9659b56c9 Add get_referrents() helper function.
Jeremy Hylton <jeremy@alum.mit.edu>
parents: 26138
diff changeset
1000
28523
c01fdc3a9180 s/referrents/referents/g. Gotta love that referrers remains rife with rs.
Tim Peters <tim.peters@gmail.com>
parents: 28522
diff changeset
1001 PyDoc_STRVAR(gc_get_referents__doc__,
c01fdc3a9180 s/referrents/referents/g. Gotta love that referrers remains rife with rs.
Tim Peters <tim.peters@gmail.com>
parents: 28522
diff changeset
1002 "get_referents(*objs) -> list\n\
28498
3e399a8618db Add get_referrents() helper function.
Jeremy Hylton <jeremy@alum.mit.edu>
parents: 28497
diff changeset
1003 Return the list of objects that are directly referred to by objs.");
28497
40d9659b56c9 Add get_referrents() helper function.
Jeremy Hylton <jeremy@alum.mit.edu>
parents: 26138
diff changeset
1004
40d9659b56c9 Add get_referrents() helper function.
Jeremy Hylton <jeremy@alum.mit.edu>
parents: 26138
diff changeset
1005 static PyObject *
28523
c01fdc3a9180 s/referrents/referents/g. Gotta love that referrers remains rife with rs.
Tim Peters <tim.peters@gmail.com>
parents: 28522
diff changeset
1006 gc_get_referents(PyObject *self, PyObject *args)
28497
40d9659b56c9 Add get_referrents() helper function.
Jeremy Hylton <jeremy@alum.mit.edu>
parents: 26138
diff changeset
1007 {
40d9659b56c9 Add get_referrents() helper function.
Jeremy Hylton <jeremy@alum.mit.edu>
parents: 26138
diff changeset
1008 int i;
40d9659b56c9 Add get_referrents() helper function.
Jeremy Hylton <jeremy@alum.mit.edu>
parents: 26138
diff changeset
1009 PyObject *result = PyList_New(0);
28522
487df294d328 Finished implementing gc.get_referrents(): dealt with error and end
Tim Peters <tim.peters@gmail.com>
parents: 28521
diff changeset
1010
487df294d328 Finished implementing gc.get_referrents(): dealt with error and end
Tim Peters <tim.peters@gmail.com>
parents: 28521
diff changeset
1011 if (result == NULL)
487df294d328 Finished implementing gc.get_referrents(): dealt with error and end
Tim Peters <tim.peters@gmail.com>
parents: 28521
diff changeset
1012 return NULL;
487df294d328 Finished implementing gc.get_referrents(): dealt with error and end
Tim Peters <tim.peters@gmail.com>
parents: 28521
diff changeset
1013
28497
40d9659b56c9 Add get_referrents() helper function.
Jeremy Hylton <jeremy@alum.mit.edu>
parents: 26138
diff changeset
1014 for (i = 0; i < PyTuple_GET_SIZE(args); i++) {
28522
487df294d328 Finished implementing gc.get_referrents(): dealt with error and end
Tim Peters <tim.peters@gmail.com>
parents: 28521
diff changeset
1015 traverseproc traverse;
28507
a0503bdb0c24 Fixed new seemingly random segfaults, by moving the initialization of
Tim Peters <tim.peters@gmail.com>
parents: 28504
diff changeset
1016 PyObject *obj = PyTuple_GET_ITEM(args, i);
28522
487df294d328 Finished implementing gc.get_referrents(): dealt with error and end
Tim Peters <tim.peters@gmail.com>
parents: 28521
diff changeset
1017
487df294d328 Finished implementing gc.get_referrents(): dealt with error and end
Tim Peters <tim.peters@gmail.com>
parents: 28521
diff changeset
1018 if (! PyObject_IS_GC(obj))
28497
40d9659b56c9 Add get_referrents() helper function.
Jeremy Hylton <jeremy@alum.mit.edu>
parents: 26138
diff changeset
1019 continue;
28522
487df294d328 Finished implementing gc.get_referrents(): dealt with error and end
Tim Peters <tim.peters@gmail.com>
parents: 28521
diff changeset
1020 traverse = obj->ob_type->tp_traverse;
487df294d328 Finished implementing gc.get_referrents(): dealt with error and end
Tim Peters <tim.peters@gmail.com>
parents: 28521
diff changeset
1021 if (! traverse)
487df294d328 Finished implementing gc.get_referrents(): dealt with error and end
Tim Peters <tim.peters@gmail.com>
parents: 28521
diff changeset
1022 continue;
28523
c01fdc3a9180 s/referrents/referents/g. Gotta love that referrers remains rife with rs.
Tim Peters <tim.peters@gmail.com>
parents: 28522
diff changeset
1023 if (traverse(obj, (visitproc)referentsvisit, result)) {
28522
487df294d328 Finished implementing gc.get_referrents(): dealt with error and end
Tim Peters <tim.peters@gmail.com>
parents: 28521
diff changeset
1024 Py_DECREF(result);
28497
40d9659b56c9 Add get_referrents() helper function.
Jeremy Hylton <jeremy@alum.mit.edu>
parents: 26138
diff changeset
1025 return NULL;
28522
487df294d328 Finished implementing gc.get_referrents(): dealt with error and end
Tim Peters <tim.peters@gmail.com>
parents: 28521
diff changeset
1026 }
28497
40d9659b56c9 Add get_referrents() helper function.
Jeremy Hylton <jeremy@alum.mit.edu>
parents: 26138
diff changeset
1027 }
40d9659b56c9 Add get_referrents() helper function.
Jeremy Hylton <jeremy@alum.mit.edu>
parents: 26138
diff changeset
1028 return result;
40d9659b56c9 Add get_referrents() helper function.
Jeremy Hylton <jeremy@alum.mit.edu>
parents: 26138
diff changeset
1029 }
40d9659b56c9 Add get_referrents() helper function.
Jeremy Hylton <jeremy@alum.mit.edu>
parents: 26138
diff changeset
1030
23832
ed1ba37a46b7 Patch #568124: Add doc string macros.
Martin v. Löwis <martin@v.loewis.de>
parents: 23721
diff changeset
1031 PyDoc_STRVAR(gc_get_objects__doc__,
19097
9e6f7804ef14 Add get_objects function. This is a low level function (like
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 19096
diff changeset
1032 "get_objects() -> [...]\n"
9e6f7804ef14 Add get_objects function. This is a low level function (like
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 19096
diff changeset
1033 "\n"
9e6f7804ef14 Add get_objects function. This is a low level function (like
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 19096
diff changeset
1034 "Return a list of objects tracked by the collector (excluding the list\n"
23832
ed1ba37a46b7 Patch #568124: Add doc string macros.
Martin v. Löwis <martin@v.loewis.de>
parents: 23721
diff changeset
1035 "returned).\n");
19097
9e6f7804ef14 Add get_objects function. This is a low level function (like
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 19096
diff changeset
1036
9e6f7804ef14 Add get_objects function. This is a low level function (like
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 19096
diff changeset
1037 static PyObject *
28512
174ce4cdec47 Switched from METH_VARARGS to METH_NOARGS for the 7 module functions that
Tim Peters <tim.peters@gmail.com>
parents: 28511
diff changeset
1038 gc_get_objects(PyObject *self, PyObject *noargs)
19097
9e6f7804ef14 Add get_objects function. This is a low level function (like
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 19096
diff changeset
1039 {
23377
2f7d869dad4d Move all data for a single generation into a structure. The set of
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 23296
diff changeset
1040 int i;
19097
9e6f7804ef14 Add get_objects function. This is a low level function (like
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 19096
diff changeset
1041 PyObject* result;
9e6f7804ef14 Add get_objects function. This is a low level function (like
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 19096
diff changeset
1042
28512
174ce4cdec47 Switched from METH_VARARGS to METH_NOARGS for the 7 module functions that
Tim Peters <tim.peters@gmail.com>
parents: 28511
diff changeset
1043 result = PyList_New(0);
174ce4cdec47 Switched from METH_VARARGS to METH_NOARGS for the 7 module functions that
Tim Peters <tim.peters@gmail.com>
parents: 28511
diff changeset
1044 if (result == NULL)
19097
9e6f7804ef14 Add get_objects function. This is a low level function (like
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 19096
diff changeset
1045 return NULL;
23377
2f7d869dad4d Move all data for a single generation into a structure. The set of
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 23296
diff changeset
1046 for (i = 0; i < NUM_GENERATIONS; i++) {
2f7d869dad4d Move all data for a single generation into a structure. The set of
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 23296
diff changeset
1047 if (append_objects(result, GEN_HEAD(i))) {
2f7d869dad4d Move all data for a single generation into a structure. The set of
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 23296
diff changeset
1048 Py_DECREF(result);
2f7d869dad4d Move all data for a single generation into a structure. The set of
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 23296
diff changeset
1049 return NULL;
2f7d869dad4d Move all data for a single generation into a structure. The set of
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 23296
diff changeset
1050 }
21130
6e34151aefe6 Patch #486743: remove bad INCREF, propagate exception in append_objects.
Martin v. Löwis <martin@v.loewis.de>
parents: 21105
diff changeset
1051 }
19097
9e6f7804ef14 Add get_objects function. This is a low level function (like
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 19096
diff changeset
1052 return result;
9e6f7804ef14 Add get_objects function. This is a low level function (like
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 19096
diff changeset
1053 }
9e6f7804ef14 Add get_objects function. This is a low level function (like
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 19096
diff changeset
1054
9e6f7804ef14 Add get_objects function. This is a low level function (like
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 19096
diff changeset
1055
23832
ed1ba37a46b7 Patch #568124: Add doc string macros.
Martin v. Löwis <martin@v.loewis.de>
parents: 23721
diff changeset
1056 PyDoc_STRVAR(gc__doc__,
13183
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
1057 "This module provides access to the garbage collector for reference cycles.\n"
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
1058 "\n"
13878
abfa4e4b2f3e Neil Schemenauer: GC enable(), disable(), isenabled() interface.
Vladimir Marangozov <vladimir.marangozov@t-online.de>
parents: 13570
diff changeset
1059 "enable() -- Enable automatic garbage collection.\n"
abfa4e4b2f3e Neil Schemenauer: GC enable(), disable(), isenabled() interface.
Vladimir Marangozov <vladimir.marangozov@t-online.de>
parents: 13570
diff changeset
1060 "disable() -- Disable automatic garbage collection.\n"
abfa4e4b2f3e Neil Schemenauer: GC enable(), disable(), isenabled() interface.
Vladimir Marangozov <vladimir.marangozov@t-online.de>
parents: 13570
diff changeset
1061 "isenabled() -- Returns true if automatic collection is enabled.\n"
13183
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
1062 "collect() -- Do a full collection right now.\n"
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
1063 "set_debug() -- Set debugging flags.\n"
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
1064 "get_debug() -- Get debugging flags.\n"
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
1065 "set_threshold() -- Set the collection thresholds.\n"
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
1066 "get_threshold() -- Return the current the collection thresholds.\n"
19097
9e6f7804ef14 Add get_objects function. This is a low level function (like
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 19096
diff changeset
1067 "get_objects() -- Return a list of all objects tracked by the collector.\n"
28497
40d9659b56c9 Add get_referrents() helper function.
Jeremy Hylton <jeremy@alum.mit.edu>
parents: 26138
diff changeset
1068 "get_referrers() -- Return the list of objects that refer to an object.\n"
28523
c01fdc3a9180 s/referrents/referents/g. Gotta love that referrers remains rife with rs.
Tim Peters <tim.peters@gmail.com>
parents: 28522
diff changeset
1069 "get_referents() -- Return the list of objects that an object refers to.\n");
13183
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
1070
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
1071 static PyMethodDef GcMethods[] = {
28512
174ce4cdec47 Switched from METH_VARARGS to METH_NOARGS for the 7 module functions that
Tim Peters <tim.peters@gmail.com>
parents: 28511
diff changeset
1072 {"enable", gc_enable, METH_NOARGS, gc_enable__doc__},
174ce4cdec47 Switched from METH_VARARGS to METH_NOARGS for the 7 module functions that
Tim Peters <tim.peters@gmail.com>
parents: 28511
diff changeset
1073 {"disable", gc_disable, METH_NOARGS, gc_disable__doc__},
174ce4cdec47 Switched from METH_VARARGS to METH_NOARGS for the 7 module functions that
Tim Peters <tim.peters@gmail.com>
parents: 28511
diff changeset
1074 {"isenabled", gc_isenabled, METH_NOARGS, gc_isenabled__doc__},
13878
abfa4e4b2f3e Neil Schemenauer: GC enable(), disable(), isenabled() interface.
Vladimir Marangozov <vladimir.marangozov@t-online.de>
parents: 13570
diff changeset
1075 {"set_debug", gc_set_debug, METH_VARARGS, gc_set_debug__doc__},
28512
174ce4cdec47 Switched from METH_VARARGS to METH_NOARGS for the 7 module functions that
Tim Peters <tim.peters@gmail.com>
parents: 28511
diff changeset
1076 {"get_debug", gc_get_debug, METH_NOARGS, gc_get_debug__doc__},
13878
abfa4e4b2f3e Neil Schemenauer: GC enable(), disable(), isenabled() interface.
Vladimir Marangozov <vladimir.marangozov@t-online.de>
parents: 13570
diff changeset
1077 {"set_threshold", gc_set_thresh, METH_VARARGS, gc_set_thresh__doc__},
28512
174ce4cdec47 Switched from METH_VARARGS to METH_NOARGS for the 7 module functions that
Tim Peters <tim.peters@gmail.com>
parents: 28511
diff changeset
1078 {"get_threshold", gc_get_thresh, METH_NOARGS, gc_get_thresh__doc__},
174ce4cdec47 Switched from METH_VARARGS to METH_NOARGS for the 7 module functions that
Tim Peters <tim.peters@gmail.com>
parents: 28511
diff changeset
1079 {"collect", gc_collect, METH_NOARGS, gc_collect__doc__},
174ce4cdec47 Switched from METH_VARARGS to METH_NOARGS for the 7 module functions that
Tim Peters <tim.peters@gmail.com>
parents: 28511
diff changeset
1080 {"get_objects", gc_get_objects,METH_NOARGS, gc_get_objects__doc__},
21038
afb789aada16 Rename get_referents to get_referrers. Fixes #483815.
Martin v. Löwis <martin@v.loewis.de>
parents: 20820
diff changeset
1081 {"get_referrers", gc_get_referrers, METH_VARARGS,
afb789aada16 Rename get_referents to get_referrers. Fixes #483815.
Martin v. Löwis <martin@v.loewis.de>
parents: 20820
diff changeset
1082 gc_get_referrers__doc__},
28523
c01fdc3a9180 s/referrents/referents/g. Gotta love that referrers remains rife with rs.
Tim Peters <tim.peters@gmail.com>
parents: 28522
diff changeset
1083 {"get_referents", gc_get_referents, METH_VARARGS,
c01fdc3a9180 s/referrents/referents/g. Gotta love that referrers remains rife with rs.
Tim Peters <tim.peters@gmail.com>
parents: 28522
diff changeset
1084 gc_get_referents__doc__},
13183
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
1085 {NULL, NULL} /* Sentinel */
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
1086 };
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
1087
30311
f003e48f562d Bug #794140: cygwin builds do not embed
Jason Tishler <jason@tishler.net>
parents: 28651
diff changeset
1088 PyMODINIT_FUNC
13183
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
1089 initgc(void)
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
1090 {
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
1091 PyObject *m;
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
1092
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
1093 m = Py_InitModule4("gc",
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
1094 GcMethods,
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
1095 gc__doc__,
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
1096 NULL,
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
1097 PYTHON_API_VERSION);
28516
78f846fb570a initgc(): Rewrote to use the PyModule_AddXYZ API; cuts code size.
Tim Peters <tim.peters@gmail.com>
parents: 28515
diff changeset
1098
13183
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
1099 if (garbage == NULL) {
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
1100 garbage = PyList_New(0);
28516
78f846fb570a initgc(): Rewrote to use the PyModule_AddXYZ API; cuts code size.
Tim Peters <tim.peters@gmail.com>
parents: 28515
diff changeset
1101 if (garbage == NULL)
78f846fb570a initgc(): Rewrote to use the PyModule_AddXYZ API; cuts code size.
Tim Peters <tim.peters@gmail.com>
parents: 28515
diff changeset
1102 return;
13183
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
1103 }
28516
78f846fb570a initgc(): Rewrote to use the PyModule_AddXYZ API; cuts code size.
Tim Peters <tim.peters@gmail.com>
parents: 28515
diff changeset
1104 if (PyModule_AddObject(m, "garbage", garbage) < 0)
78f846fb570a initgc(): Rewrote to use the PyModule_AddXYZ API; cuts code size.
Tim Peters <tim.peters@gmail.com>
parents: 28515
diff changeset
1105 return;
78f846fb570a initgc(): Rewrote to use the PyModule_AddXYZ API; cuts code size.
Tim Peters <tim.peters@gmail.com>
parents: 28515
diff changeset
1106 #define ADD_INT(NAME) if (PyModule_AddIntConstant(m, #NAME, NAME) < 0) return
78f846fb570a initgc(): Rewrote to use the PyModule_AddXYZ API; cuts code size.
Tim Peters <tim.peters@gmail.com>
parents: 28515
diff changeset
1107 ADD_INT(DEBUG_STATS);
78f846fb570a initgc(): Rewrote to use the PyModule_AddXYZ API; cuts code size.
Tim Peters <tim.peters@gmail.com>
parents: 28515
diff changeset
1108 ADD_INT(DEBUG_COLLECTABLE);
78f846fb570a initgc(): Rewrote to use the PyModule_AddXYZ API; cuts code size.
Tim Peters <tim.peters@gmail.com>
parents: 28515
diff changeset
1109 ADD_INT(DEBUG_UNCOLLECTABLE);
78f846fb570a initgc(): Rewrote to use the PyModule_AddXYZ API; cuts code size.
Tim Peters <tim.peters@gmail.com>
parents: 28515
diff changeset
1110 ADD_INT(DEBUG_INSTANCES);
78f846fb570a initgc(): Rewrote to use the PyModule_AddXYZ API; cuts code size.
Tim Peters <tim.peters@gmail.com>
parents: 28515
diff changeset
1111 ADD_INT(DEBUG_OBJECTS);
78f846fb570a initgc(): Rewrote to use the PyModule_AddXYZ API; cuts code size.
Tim Peters <tim.peters@gmail.com>
parents: 28515
diff changeset
1112 ADD_INT(DEBUG_SAVEALL);
78f846fb570a initgc(): Rewrote to use the PyModule_AddXYZ API; cuts code size.
Tim Peters <tim.peters@gmail.com>
parents: 28515
diff changeset
1113 ADD_INT(DEBUG_LEAK);
78f846fb570a initgc(): Rewrote to use the PyModule_AddXYZ API; cuts code size.
Tim Peters <tim.peters@gmail.com>
parents: 28515
diff changeset
1114 #undef ADD_INT
13183
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
1115 }
54bffdddc0ef final patches from Neil Schemenauer for garbage collection
Jeremy Hylton <jeremy@alum.mit.edu>
parents:
diff changeset
1116
28651
7fda09f751ad - New C API PyGC_Collect(), same as calling gc.collect().
Guido van Rossum <guido@python.org>
parents: 28523
diff changeset
1117 /* API to invoke gc.collect() from C */
7fda09f751ad - New C API PyGC_Collect(), same as calling gc.collect().
Guido van Rossum <guido@python.org>
parents: 28523
diff changeset
1118 long
7fda09f751ad - New C API PyGC_Collect(), same as calling gc.collect().
Guido van Rossum <guido@python.org>
parents: 28523
diff changeset
1119 PyGC_Collect(void)
7fda09f751ad - New C API PyGC_Collect(), same as calling gc.collect().
Guido van Rossum <guido@python.org>
parents: 28523
diff changeset
1120 {
7fda09f751ad - New C API PyGC_Collect(), same as calling gc.collect().
Guido van Rossum <guido@python.org>
parents: 28523
diff changeset
1121 long n;
7fda09f751ad - New C API PyGC_Collect(), same as calling gc.collect().
Guido van Rossum <guido@python.org>
parents: 28523
diff changeset
1122
7fda09f751ad - New C API PyGC_Collect(), same as calling gc.collect().
Guido van Rossum <guido@python.org>
parents: 28523
diff changeset
1123 if (collecting)
7fda09f751ad - New C API PyGC_Collect(), same as calling gc.collect().
Guido van Rossum <guido@python.org>
parents: 28523
diff changeset
1124 n = 0; /* already collecting, don't do anything */
7fda09f751ad - New C API PyGC_Collect(), same as calling gc.collect().
Guido van Rossum <guido@python.org>
parents: 28523
diff changeset
1125 else {
7fda09f751ad - New C API PyGC_Collect(), same as calling gc.collect().
Guido van Rossum <guido@python.org>
parents: 28523
diff changeset
1126 collecting = 1;
7fda09f751ad - New C API PyGC_Collect(), same as calling gc.collect().
Guido van Rossum <guido@python.org>
parents: 28523
diff changeset
1127 n = collect(NUM_GENERATIONS - 1);
7fda09f751ad - New C API PyGC_Collect(), same as calling gc.collect().
Guido van Rossum <guido@python.org>
parents: 28523
diff changeset
1128 collecting = 0;
7fda09f751ad - New C API PyGC_Collect(), same as calling gc.collect().
Guido van Rossum <guido@python.org>
parents: 28523
diff changeset
1129 }
7fda09f751ad - New C API PyGC_Collect(), same as calling gc.collect().
Guido van Rossum <guido@python.org>
parents: 28523
diff changeset
1130
7fda09f751ad - New C API PyGC_Collect(), same as calling gc.collect().
Guido van Rossum <guido@python.org>
parents: 28523
diff changeset
1131 return n;
7fda09f751ad - New C API PyGC_Collect(), same as calling gc.collect().
Guido van Rossum <guido@python.org>
parents: 28523
diff changeset
1132 }
7fda09f751ad - New C API PyGC_Collect(), same as calling gc.collect().
Guido van Rossum <guido@python.org>
parents: 28523
diff changeset
1133
19585
c43d7a8f00a4 Make more things internal to this file. Remove
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 19128
diff changeset
1134 /* for debugging */
28651
7fda09f751ad - New C API PyGC_Collect(), same as calling gc.collect().
Guido van Rossum <guido@python.org>
parents: 28523
diff changeset
1135 void
7fda09f751ad - New C API PyGC_Collect(), same as calling gc.collect().
Guido van Rossum <guido@python.org>
parents: 28523
diff changeset
1136 _PyGC_Dump(PyGC_Head *g)
19585
c43d7a8f00a4 Make more things internal to this file. Remove
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 19128
diff changeset
1137 {
c43d7a8f00a4 Make more things internal to this file. Remove
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 19128
diff changeset
1138 _PyObject_Dump(FROM_GC(g));
c43d7a8f00a4 Make more things internal to this file. Remove
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 19128
diff changeset
1139 }
c43d7a8f00a4 Make more things internal to this file. Remove
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 19128
diff changeset
1140
c43d7a8f00a4 Make more things internal to this file. Remove
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 19128
diff changeset
1141 /* extension modules might be compiled with GC support so these
c43d7a8f00a4 Make more things internal to this file. Remove
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 19128
diff changeset
1142 functions must always be available */
c43d7a8f00a4 Make more things internal to this file. Remove
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 19128
diff changeset
1143
22972
95819f7f0bcd Allow PyObject_Del to be used as a function designator. Provide binary
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 22648
diff changeset
1144 #undef PyObject_GC_Track
95819f7f0bcd Allow PyObject_Del to be used as a function designator. Provide binary
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 22648
diff changeset
1145 #undef PyObject_GC_UnTrack
95819f7f0bcd Allow PyObject_Del to be used as a function designator. Provide binary
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 22648
diff changeset
1146 #undef PyObject_GC_Del
95819f7f0bcd Allow PyObject_Del to be used as a function designator. Provide binary
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 22648
diff changeset
1147 #undef _PyObject_GC_Malloc
95819f7f0bcd Allow PyObject_Del to be used as a function designator. Provide binary
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 22648
diff changeset
1148
19585
c43d7a8f00a4 Make more things internal to this file. Remove
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 19128
diff changeset
1149 void
22972
95819f7f0bcd Allow PyObject_Del to be used as a function designator. Provide binary
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 22648
diff changeset
1150 PyObject_GC_Track(void *op)
19585
c43d7a8f00a4 Make more things internal to this file. Remove
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 19128
diff changeset
1151 {
c43d7a8f00a4 Make more things internal to this file. Remove
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 19128
diff changeset
1152 _PyObject_GC_TRACK(op);
c43d7a8f00a4 Make more things internal to this file. Remove
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 19128
diff changeset
1153 }
c43d7a8f00a4 Make more things internal to this file. Remove
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 19128
diff changeset
1154
22972
95819f7f0bcd Allow PyObject_Del to be used as a function designator. Provide binary
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 22648
diff changeset
1155 /* for binary compatibility with 2.2 */
19585
c43d7a8f00a4 Make more things internal to this file. Remove
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 19128
diff changeset
1156 void
22972
95819f7f0bcd Allow PyObject_Del to be used as a function designator. Provide binary
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 22648
diff changeset
1157 _PyObject_GC_Track(PyObject *op)
95819f7f0bcd Allow PyObject_Del to be used as a function designator. Provide binary
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 22648
diff changeset
1158 {
95819f7f0bcd Allow PyObject_Del to be used as a function designator. Provide binary
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 22648
diff changeset
1159 PyObject_GC_Track(op);
95819f7f0bcd Allow PyObject_Del to be used as a function designator. Provide binary
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 22648
diff changeset
1160 }
95819f7f0bcd Allow PyObject_Del to be used as a function designator. Provide binary
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 22648
diff changeset
1161
95819f7f0bcd Allow PyObject_Del to be used as a function designator. Provide binary
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 22648
diff changeset
1162 void
95819f7f0bcd Allow PyObject_Del to be used as a function designator. Provide binary
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 22648
diff changeset
1163 PyObject_GC_UnTrack(void *op)
19585
c43d7a8f00a4 Make more things internal to this file. Remove
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 19128
diff changeset
1164 {
24122
d332484e394a Trashcan cleanup: Now that cyclic gc is always there, the trashcan
Tim Peters <tim.peters@gmail.com>
parents: 24121
diff changeset
1165 /* Obscure: the Py_TRASHCAN mechanism requires that we be able to
d332484e394a Trashcan cleanup: Now that cyclic gc is always there, the trashcan
Tim Peters <tim.peters@gmail.com>
parents: 24121
diff changeset
1166 * call PyObject_GC_UnTrack twice on an object.
d332484e394a Trashcan cleanup: Now that cyclic gc is always there, the trashcan
Tim Peters <tim.peters@gmail.com>
parents: 24121
diff changeset
1167 */
23495
68e3f3dd4d48 Add IS_TRACKED and IS_MOVED macros. This makes the logic a little more clear.
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 23377
diff changeset
1168 if (IS_TRACKED(op))
22625
898c392477d9 This is Neil's fix for SF bug 535905 (Evil Trashcan and GC interaction).
Guido van Rossum <guido@python.org>
parents: 22449
diff changeset
1169 _PyObject_GC_UNTRACK(op);
19585
c43d7a8f00a4 Make more things internal to this file. Remove
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 19128
diff changeset
1170 }
c43d7a8f00a4 Make more things internal to this file. Remove
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 19128
diff changeset
1171
22972
95819f7f0bcd Allow PyObject_Del to be used as a function designator. Provide binary
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 22648
diff changeset
1172 /* for binary compatibility with 2.2 */
95819f7f0bcd Allow PyObject_Del to be used as a function designator. Provide binary
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 22648
diff changeset
1173 void
95819f7f0bcd Allow PyObject_Del to be used as a function designator. Provide binary
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 22648
diff changeset
1174 _PyObject_GC_UnTrack(PyObject *op)
95819f7f0bcd Allow PyObject_Del to be used as a function designator. Provide binary
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 22648
diff changeset
1175 {
95819f7f0bcd Allow PyObject_Del to be used as a function designator. Provide binary
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 22648
diff changeset
1176 PyObject_GC_UnTrack(op);
95819f7f0bcd Allow PyObject_Del to be used as a function designator. Provide binary
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 22648
diff changeset
1177 }
95819f7f0bcd Allow PyObject_Del to be used as a function designator. Provide binary
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 22648
diff changeset
1178
19585
c43d7a8f00a4 Make more things internal to this file. Remove
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 19128
diff changeset
1179 PyObject *
22972
95819f7f0bcd Allow PyObject_Del to be used as a function designator. Provide binary
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 22648
diff changeset
1180 _PyObject_GC_Malloc(size_t basicsize)
19585
c43d7a8f00a4 Make more things internal to this file. Remove
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 19128
diff changeset
1181 {
c43d7a8f00a4 Make more things internal to this file. Remove
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 19128
diff changeset
1182 PyObject *op;
22972
95819f7f0bcd Allow PyObject_Del to be used as a function designator. Provide binary
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 22648
diff changeset
1183 PyGC_Head *g = PyObject_MALLOC(sizeof(PyGC_Head) + basicsize);
19585
c43d7a8f00a4 Make more things internal to this file. Remove
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 19128
diff changeset
1184 if (g == NULL)
23721
48e937e1b3fe Remove casts to PyObject * when declaration is for PyObject *
Jeremy Hylton <jeremy@alum.mit.edu>
parents: 23495
diff changeset
1185 return PyErr_NoMemory();
24077
a5162fd65c3d Reserved another gc_refs value for untracked objects. Every live gc
Tim Peters <tim.peters@gmail.com>
parents: 24075
diff changeset
1186 g->gc.gc_refs = GC_UNTRACKED;
23377
2f7d869dad4d Move all data for a single generation into a structure. The set of
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 23296
diff changeset
1187 generations[0].count++; /* number of allocated GC objects */
2f7d869dad4d Move all data for a single generation into a structure. The set of
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 23296
diff changeset
1188 if (generations[0].count > generations[0].threshold &&
19585
c43d7a8f00a4 Make more things internal to this file. Remove
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 19128
diff changeset
1189 enabled &&
23377
2f7d869dad4d Move all data for a single generation into a structure. The set of
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 23296
diff changeset
1190 generations[0].threshold &&
19585
c43d7a8f00a4 Make more things internal to this file. Remove
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 19128
diff changeset
1191 !collecting &&
c43d7a8f00a4 Make more things internal to this file. Remove
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 19128
diff changeset
1192 !PyErr_Occurred()) {
c43d7a8f00a4 Make more things internal to this file. Remove
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 19128
diff changeset
1193 collecting = 1;
23377
2f7d869dad4d Move all data for a single generation into a structure. The set of
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 23296
diff changeset
1194 collect_generations();
19585
c43d7a8f00a4 Make more things internal to this file. Remove
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 19128
diff changeset
1195 collecting = 0;
c43d7a8f00a4 Make more things internal to this file. Remove
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 19128
diff changeset
1196 }
c43d7a8f00a4 Make more things internal to this file. Remove
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 19128
diff changeset
1197 op = FROM_GC(g);
c43d7a8f00a4 Make more things internal to this file. Remove
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 19128
diff changeset
1198 return op;
c43d7a8f00a4 Make more things internal to this file. Remove
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 19128
diff changeset
1199 }
c43d7a8f00a4 Make more things internal to this file. Remove
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 19128
diff changeset
1200
c43d7a8f00a4 Make more things internal to this file. Remove
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 19128
diff changeset
1201 PyObject *
c43d7a8f00a4 Make more things internal to this file. Remove
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 19128
diff changeset
1202 _PyObject_GC_New(PyTypeObject *tp)
c43d7a8f00a4 Make more things internal to this file. Remove
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 19128
diff changeset
1203 {
22972
95819f7f0bcd Allow PyObject_Del to be used as a function designator. Provide binary
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 22648
diff changeset
1204 PyObject *op = _PyObject_GC_Malloc(_PyObject_SIZE(tp));
23296
17cafe805f04 _PyObject_GC_New: Could call PyObject_INIT with a NULL 1st argument.
Tim Peters <tim.peters@gmail.com>
parents: 22972
diff changeset
1205 if (op != NULL)
17cafe805f04 _PyObject_GC_New: Could call PyObject_INIT with a NULL 1st argument.
Tim Peters <tim.peters@gmail.com>
parents: 22972
diff changeset
1206 op = PyObject_INIT(op, tp);
17cafe805f04 _PyObject_GC_New: Could call PyObject_INIT with a NULL 1st argument.
Tim Peters <tim.peters@gmail.com>
parents: 22972
diff changeset
1207 return op;
19585
c43d7a8f00a4 Make more things internal to this file. Remove
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 19128
diff changeset
1208 }
c43d7a8f00a4 Make more things internal to this file. Remove
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 19128
diff changeset
1209
c43d7a8f00a4 Make more things internal to this file. Remove
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 19128
diff changeset
1210 PyVarObject *
20294
426b379a138b _PyObject_VAR_SIZE: always round up to a multiple-of-pointer-size value.
Tim Peters <tim.peters@gmail.com>
parents: 20293
diff changeset
1211 _PyObject_GC_NewVar(PyTypeObject *tp, int nitems)
19585
c43d7a8f00a4 Make more things internal to this file. Remove
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 19128
diff changeset
1212 {
22972
95819f7f0bcd Allow PyObject_Del to be used as a function designator. Provide binary
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 22648
diff changeset
1213 const size_t size = _PyObject_VAR_SIZE(tp, nitems);
95819f7f0bcd Allow PyObject_Del to be used as a function designator. Provide binary
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 22648
diff changeset
1214 PyVarObject *op = (PyVarObject *) _PyObject_GC_Malloc(size);
23296
17cafe805f04 _PyObject_GC_New: Could call PyObject_INIT with a NULL 1st argument.
Tim Peters <tim.peters@gmail.com>
parents: 22972
diff changeset
1215 if (op != NULL)
17cafe805f04 _PyObject_GC_New: Could call PyObject_INIT with a NULL 1st argument.
Tim Peters <tim.peters@gmail.com>
parents: 22972
diff changeset
1216 op = PyObject_INIT_VAR(op, tp, nitems);
17cafe805f04 _PyObject_GC_New: Could call PyObject_INIT with a NULL 1st argument.
Tim Peters <tim.peters@gmail.com>
parents: 22972
diff changeset
1217 return op;
19585
c43d7a8f00a4 Make more things internal to this file. Remove
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 19128
diff changeset
1218 }
c43d7a8f00a4 Make more things internal to this file. Remove
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 19128
diff changeset
1219
c43d7a8f00a4 Make more things internal to this file. Remove
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 19128
diff changeset
1220 PyVarObject *
20294
426b379a138b _PyObject_VAR_SIZE: always round up to a multiple-of-pointer-size value.
Tim Peters <tim.peters@gmail.com>
parents: 20293
diff changeset
1221 _PyObject_GC_Resize(PyVarObject *op, int nitems)
19585
c43d7a8f00a4 Make more things internal to this file. Remove
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 19128
diff changeset
1222 {
20296
6cc0b48049ec Guido suggests, and I agree, to insist that SIZEOF_VOID_P be a power of 2.
Tim Peters <tim.peters@gmail.com>
parents: 20294
diff changeset
1223 const size_t basicsize = _PyObject_VAR_SIZE(op->ob_type, nitems);
19585
c43d7a8f00a4 Make more things internal to this file. Remove
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 19128
diff changeset
1224 PyGC_Head *g = AS_GC(op);
22972
95819f7f0bcd Allow PyObject_Del to be used as a function designator. Provide binary
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 22648
diff changeset
1225 g = PyObject_REALLOC(g, sizeof(PyGC_Head) + basicsize);
19585
c43d7a8f00a4 Make more things internal to this file. Remove
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 19128
diff changeset
1226 if (g == NULL)
c43d7a8f00a4 Make more things internal to this file. Remove
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 19128
diff changeset
1227 return (PyVarObject *)PyErr_NoMemory();
c43d7a8f00a4 Make more things internal to this file. Remove
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 19128
diff changeset
1228 op = (PyVarObject *) FROM_GC(g);
20294
426b379a138b _PyObject_VAR_SIZE: always round up to a multiple-of-pointer-size value.
Tim Peters <tim.peters@gmail.com>
parents: 20293
diff changeset
1229 op->ob_size = nitems;
19585
c43d7a8f00a4 Make more things internal to this file. Remove
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 19128
diff changeset
1230 return op;
c43d7a8f00a4 Make more things internal to this file. Remove
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 19128
diff changeset
1231 }
c43d7a8f00a4 Make more things internal to this file. Remove
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 19128
diff changeset
1232
c43d7a8f00a4 Make more things internal to this file. Remove
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 19128
diff changeset
1233 void
22972
95819f7f0bcd Allow PyObject_Del to be used as a function designator. Provide binary
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 22648
diff changeset
1234 PyObject_GC_Del(void *op)
19585
c43d7a8f00a4 Make more things internal to this file. Remove
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 19128
diff changeset
1235 {
c43d7a8f00a4 Make more things internal to this file. Remove
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 19128
diff changeset
1236 PyGC_Head *g = AS_GC(op);
23495
68e3f3dd4d48 Add IS_TRACKED and IS_MOVED macros. This makes the logic a little more clear.
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 23377
diff changeset
1237 if (IS_TRACKED(op))
19585
c43d7a8f00a4 Make more things internal to this file. Remove
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 19128
diff changeset
1238 gc_list_remove(g);
23377
2f7d869dad4d Move all data for a single generation into a structure. The set of
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 23296
diff changeset
1239 if (generations[0].count > 0) {
2f7d869dad4d Move all data for a single generation into a structure. The set of
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 23296
diff changeset
1240 generations[0].count--;
19585
c43d7a8f00a4 Make more things internal to this file. Remove
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 19128
diff changeset
1241 }
22972
95819f7f0bcd Allow PyObject_Del to be used as a function designator. Provide binary
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 22648
diff changeset
1242 PyObject_FREE(g);
19585
c43d7a8f00a4 Make more things internal to this file. Remove
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 19128
diff changeset
1243 }
c43d7a8f00a4 Make more things internal to this file. Remove
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 19128
diff changeset
1244
22972
95819f7f0bcd Allow PyObject_Del to be used as a function designator. Provide binary
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 22648
diff changeset
1245 /* for binary compatibility with 2.2 */
95819f7f0bcd Allow PyObject_Del to be used as a function designator. Provide binary
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 22648
diff changeset
1246 #undef _PyObject_GC_Del
95819f7f0bcd Allow PyObject_Del to be used as a function designator. Provide binary
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 22648
diff changeset
1247 void
95819f7f0bcd Allow PyObject_Del to be used as a function designator. Provide binary
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 22648
diff changeset
1248 _PyObject_GC_Del(PyObject *op)
95819f7f0bcd Allow PyObject_Del to be used as a function designator. Provide binary
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 22648
diff changeset
1249 {
95819f7f0bcd Allow PyObject_Del to be used as a function designator. Provide binary
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 22648
diff changeset
1250 PyObject_GC_Del(op);
95819f7f0bcd Allow PyObject_Del to be used as a function designator. Provide binary
Neil Schemenauer <nascheme@enme.ucalgary.ca>
parents: 22648
diff changeset
1251 }