cpython-lru_cache-weakref: Modules/gcmodule.c annotate

annotate Modules/gcmodule.c @ 37850:ebe59cd18273

Use explicit relative import for an, ehm, relative import.

author	Thomas Wouters <thomas@python.org>
date	Tue, 18 Apr 2006 21:41:36 +0000
parents	2d24f3a37a1b
children	1f4549865aad f731859e9b3b

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
33869 223d20afc8b5 gc list function cleanup. Tim Peters <tim.peters@gmail.com> parents: 33867 diff changeset	142 #if 0
223d20afc8b5 gc list function cleanup. Tim Peters <tim.peters@gmail.com> parents: 33867 diff changeset	143 /* This became unused after gc_list_move() was introduced. */
223d20afc8b5 gc list function cleanup. Tim Peters <tim.peters@gmail.com> parents: 33867 diff changeset	144 /* Append `node` to `list`. */
13183 54bffdddc0ef final patches from Neil Schemenauer for garbage collection Jeremy Hylton <jeremy@alum.mit.edu> parents: diff changeset	145 static void
54bffdddc0ef final patches from Neil Schemenauer for garbage collection Jeremy Hylton <jeremy@alum.mit.edu> parents: diff changeset	146 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	147 {
20381 b4f829941f3d SF bug [#467145] Python 2.2a4 build problem on HPUX 11.0. Tim Peters <tim.peters@gmail.com> parents: 20296 diff changeset	148 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	149 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	150 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	151 list->gc.gc_prev = node;
13183 54bffdddc0ef final patches from Neil Schemenauer for garbage collection Jeremy Hylton <jeremy@alum.mit.edu> parents: diff changeset	152 }
33869 223d20afc8b5 gc list function cleanup. Tim Peters <tim.peters@gmail.com> parents: 33867 diff changeset	153 #endif
13183 54bffdddc0ef final patches from Neil Schemenauer for garbage collection Jeremy Hylton <jeremy@alum.mit.edu> parents: diff changeset	154
33869 223d20afc8b5 gc list function cleanup. Tim Peters <tim.peters@gmail.com> parents: 33867 diff changeset	155 /* Remove `node` from the gc list it's currently in. */
13183 54bffdddc0ef final patches from Neil Schemenauer for garbage collection Jeremy Hylton <jeremy@alum.mit.edu> parents: diff changeset	156 static void
54bffdddc0ef final patches from Neil Schemenauer for garbage collection Jeremy Hylton <jeremy@alum.mit.edu> parents: diff changeset	157 gc_list_remove(PyGC_Head *node)
54bffdddc0ef final patches from Neil Schemenauer for garbage collection Jeremy Hylton <jeremy@alum.mit.edu> parents: diff changeset	158 {
20381 b4f829941f3d SF bug [#467145] Python 2.2a4 build problem on HPUX 11.0. Tim Peters <tim.peters@gmail.com> parents: 20296 diff changeset	159 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	160 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	161 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	162 }
54bffdddc0ef final patches from Neil Schemenauer for garbage collection Jeremy Hylton <jeremy@alum.mit.edu> parents: diff changeset	163
33869 223d20afc8b5 gc list function cleanup. Tim Peters <tim.peters@gmail.com> parents: 33867 diff changeset	164 /* Move `node` from the gc list it's currently in (which is not explicitly
223d20afc8b5 gc list function cleanup. Tim Peters <tim.peters@gmail.com> parents: 33867 diff changeset	165 * named here) to the end of `list`. This is semantically the same as
223d20afc8b5 gc list function cleanup. Tim Peters <tim.peters@gmail.com> parents: 33867 diff changeset	166 * gc_list_remove(node) followed by gc_list_append(node, list).
223d20afc8b5 gc list function cleanup. Tim Peters <tim.peters@gmail.com> parents: 33867 diff changeset	167 */
223d20afc8b5 gc list function cleanup. Tim Peters <tim.peters@gmail.com> parents: 33867 diff changeset	168 static void
223d20afc8b5 gc list function cleanup. Tim Peters <tim.peters@gmail.com> parents: 33867 diff changeset	169 gc_list_move(PyGC_Head node, PyGC_Head list)
223d20afc8b5 gc list function cleanup. Tim Peters <tim.peters@gmail.com> parents: 33867 diff changeset	170 {
33876 633cadebf68d gc_list_move(): Make this truly equivalent to remove+append. While Tim Peters <tim.peters@gmail.com> parents: 33869 diff changeset	171 PyGC_Head *new_prev;
33869 223d20afc8b5 gc list function cleanup. Tim Peters <tim.peters@gmail.com> parents: 33867 diff changeset	172 PyGC_Head *current_prev = node->gc.gc_prev;
223d20afc8b5 gc list function cleanup. Tim Peters <tim.peters@gmail.com> parents: 33867 diff changeset	173 PyGC_Head *current_next = node->gc.gc_next;
33876 633cadebf68d gc_list_move(): Make this truly equivalent to remove+append. While Tim Peters <tim.peters@gmail.com> parents: 33869 diff changeset	174 /* Unlink from current list. */
33869 223d20afc8b5 gc list function cleanup. Tim Peters <tim.peters@gmail.com> parents: 33867 diff changeset	175 current_prev->gc.gc_next = current_next;
223d20afc8b5 gc list function cleanup. Tim Peters <tim.peters@gmail.com> parents: 33867 diff changeset	176 current_next->gc.gc_prev = current_prev;
33876 633cadebf68d gc_list_move(): Make this truly equivalent to remove+append. While Tim Peters <tim.peters@gmail.com> parents: 33869 diff changeset	177 /* Relink at end of new list. */
633cadebf68d gc_list_move(): Make this truly equivalent to remove+append. While Tim Peters <tim.peters@gmail.com> parents: 33869 diff changeset	178 new_prev = node->gc.gc_prev = list->gc.gc_prev;
633cadebf68d gc_list_move(): Make this truly equivalent to remove+append. While Tim Peters <tim.peters@gmail.com> parents: 33869 diff changeset	179 new_prev->gc.gc_next = list->gc.gc_prev = node;
33869 223d20afc8b5 gc list function cleanup. Tim Peters <tim.peters@gmail.com> parents: 33867 diff changeset	180 node->gc.gc_next = list;
223d20afc8b5 gc list function cleanup. Tim Peters <tim.peters@gmail.com> parents: 33867 diff changeset	181 }
223d20afc8b5 gc list function cleanup. Tim Peters <tim.peters@gmail.com> parents: 33867 diff changeset	182
223d20afc8b5 gc list function cleanup. Tim Peters <tim.peters@gmail.com> parents: 33867 diff changeset	183 /* append list `from` onto list `to`; `from` becomes an empty list */
13183 54bffdddc0ef final patches from Neil Schemenauer for garbage collection Jeremy Hylton <jeremy@alum.mit.edu> parents: diff changeset	184 static void
54bffdddc0ef final patches from Neil Schemenauer for garbage collection Jeremy Hylton <jeremy@alum.mit.edu> parents: diff changeset	185 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	186 {
54bffdddc0ef final patches from Neil Schemenauer for garbage collection Jeremy Hylton <jeremy@alum.mit.edu> parents: diff changeset	187 PyGC_Head *tail;
33869 223d20afc8b5 gc list function cleanup. Tim Peters <tim.peters@gmail.com> parents: 33867 diff changeset	188 assert(from != to);
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	189 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	190 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	191 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	192 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	193 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	194 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	195 }
54bffdddc0ef final patches from Neil Schemenauer for garbage collection Jeremy Hylton <jeremy@alum.mit.edu> parents: diff changeset	196 gc_list_init(from);
54bffdddc0ef final patches from Neil Schemenauer for garbage collection Jeremy Hylton <jeremy@alum.mit.edu> parents: diff changeset	197 }
54bffdddc0ef final patches from Neil Schemenauer for garbage collection Jeremy Hylton <jeremy@alum.mit.edu> parents: diff changeset	198
36839 7c1aca8e3d7d Make PyGC_Collect() use Py_ssize_t. Neal Norwitz <nnorwitz@gmail.com> parents: 36769 diff changeset	199 static Py_ssize_t
13183 54bffdddc0ef final patches from Neil Schemenauer for garbage collection Jeremy Hylton <jeremy@alum.mit.edu> parents: diff changeset	200 gc_list_size(PyGC_Head *list)
54bffdddc0ef final patches from Neil Schemenauer for garbage collection Jeremy Hylton <jeremy@alum.mit.edu> parents: diff changeset	201 {
54bffdddc0ef final patches from Neil Schemenauer for garbage collection Jeremy Hylton <jeremy@alum.mit.edu> parents: diff changeset	202 PyGC_Head *gc;
36839 7c1aca8e3d7d Make PyGC_Collect() use Py_ssize_t. Neal Norwitz <nnorwitz@gmail.com> parents: 36769 diff changeset	203 Py_ssize_t 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	204 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	205 n++;
54bffdddc0ef final patches from Neil Schemenauer for garbage collection Jeremy Hylton <jeremy@alum.mit.edu> parents: diff changeset	206 }
54bffdddc0ef final patches from Neil Schemenauer for garbage collection Jeremy Hylton <jeremy@alum.mit.edu> parents: diff changeset	207 return n;
54bffdddc0ef final patches from Neil Schemenauer for garbage collection Jeremy Hylton <jeremy@alum.mit.edu> parents: diff changeset	208 }
54bffdddc0ef final patches from Neil Schemenauer for garbage collection Jeremy Hylton <jeremy@alum.mit.edu> parents: diff changeset	209
28515 4c596dd60c22 handle_finalizers(): Rewrote to call append_objects() and gc_list_merge() Tim Peters <tim.peters@gmail.com> parents: 28512 diff changeset	210 /* 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	211 * 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	212 */
4c596dd60c22 handle_finalizers(): Rewrote to call append_objects() and gc_list_merge() Tim Peters <tim.peters@gmail.com> parents: 28512 diff changeset	213 static int
4c596dd60c22 handle_finalizers(): Rewrote to call append_objects() and gc_list_merge() Tim Peters <tim.peters@gmail.com> parents: 28512 diff changeset	214 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	215 {
4c596dd60c22 handle_finalizers(): Rewrote to call append_objects() and gc_list_merge() Tim Peters <tim.peters@gmail.com> parents: 28512 diff changeset	216 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	217 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	218 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	219 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	220 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	221 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	222 }
4c596dd60c22 handle_finalizers(): Rewrote to call append_objects() and gc_list_merge() Tim Peters <tim.peters@gmail.com> parents: 28512 diff changeset	223 }
4c596dd60c22 handle_finalizers(): Rewrote to call append_objects() and gc_list_merge() Tim Peters <tim.peters@gmail.com> parents: 28512 diff changeset	224 }
4c596dd60c22 handle_finalizers(): Rewrote to call append_objects() and gc_list_merge() Tim Peters <tim.peters@gmail.com> parents: 28512 diff changeset	225 return 0;
4c596dd60c22 handle_finalizers(): Rewrote to call append_objects() and gc_list_merge() Tim Peters <tim.peters@gmail.com> parents: 28512 diff changeset	226 }
4c596dd60c22 handle_finalizers(): Rewrote to call append_objects() and gc_list_merge() Tim Peters <tim.peters@gmail.com> parents: 28512 diff changeset	227
13183 54bffdddc0ef final patches from Neil Schemenauer for garbage collection Jeremy Hylton <jeremy@alum.mit.edu> parents: diff changeset	228 /* end of list stuff */
54bffdddc0ef final patches from Neil Schemenauer for garbage collection Jeremy Hylton <jeremy@alum.mit.edu> parents: diff changeset	229
54bffdddc0ef final patches from Neil Schemenauer for garbage collection Jeremy Hylton <jeremy@alum.mit.edu> parents: diff changeset	230
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	231 /* 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	232 * 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	233 * containers.
24072 86b3760d285d SF bug #574132: Major GC related performance regression Tim Peters <tim.peters@gmail.com> parents: 24036 diff changeset	234 */
13183 54bffdddc0ef final patches from Neil Schemenauer for garbage collection Jeremy Hylton <jeremy@alum.mit.edu> parents: diff changeset	235 static void
54bffdddc0ef final patches from Neil Schemenauer for garbage collection Jeremy Hylton <jeremy@alum.mit.edu> parents: diff changeset	236 update_refs(PyGC_Head *containers)
54bffdddc0ef final patches from Neil Schemenauer for garbage collection Jeremy Hylton <jeremy@alum.mit.edu> parents: diff changeset	237 {
20381 b4f829941f3d SF bug [#467145] Python 2.2a4 build problem on HPUX 11.0. Tim Peters <tim.peters@gmail.com> parents: 20296 diff changeset	238 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	239 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	240 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	241 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	242 /* 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	243 * 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	244 * 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	245 * 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	246 * 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	247 * 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	248 * 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	249 * 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	250 * 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	251 * 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	252 * 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	253 * 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	254 * 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	255 * 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	256 * 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	257 * 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	258 * 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	259 */
8aa9237f6dd6 update_refs(): assert that incoming refcounts aren't 0. The comment Tim Peters <tim.peters@gmail.com> parents: 30311 diff changeset	260 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	261 }
13183 54bffdddc0ef final patches from Neil Schemenauer for garbage collection Jeremy Hylton <jeremy@alum.mit.edu> parents: diff changeset	262 }
54bffdddc0ef final patches from Neil Schemenauer for garbage collection Jeremy Hylton <jeremy@alum.mit.edu> parents: diff changeset	263
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	264 /* 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	265 static int
54bffdddc0ef final patches from Neil Schemenauer for garbage collection Jeremy Hylton <jeremy@alum.mit.edu> parents: diff changeset	266 visit_decref(PyObject op, void data)
54bffdddc0ef final patches from Neil Schemenauer for garbage collection Jeremy Hylton <jeremy@alum.mit.edu> parents: diff changeset	267 {
24074 a1805a54666f visit_decref(): Two optimizations. Tim Peters <tim.peters@gmail.com> parents: 24072 diff changeset	268 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	269 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	270 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	271 /* 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	272 * 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	273 * 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	274 */
24097 f7abbd15b4f4 visit_decref(): Added another assert. Tim Peters <tim.peters@gmail.com> parents: 24085 diff changeset	275 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	276 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	277 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	278 }
13183 54bffdddc0ef final patches from Neil Schemenauer for garbage collection Jeremy Hylton <jeremy@alum.mit.edu> parents: diff changeset	279 return 0;
54bffdddc0ef final patches from Neil Schemenauer for garbage collection Jeremy Hylton <jeremy@alum.mit.edu> parents: diff changeset	280 }
54bffdddc0ef final patches from Neil Schemenauer for garbage collection Jeremy Hylton <jeremy@alum.mit.edu> parents: diff changeset	281
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	282 /* 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	283 * 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	284 * 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	285 * 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	286 */
13183 54bffdddc0ef final patches from Neil Schemenauer for garbage collection Jeremy Hylton <jeremy@alum.mit.edu> parents: diff changeset	287 static void
54bffdddc0ef final patches from Neil Schemenauer for garbage collection Jeremy Hylton <jeremy@alum.mit.edu> parents: diff changeset	288 subtract_refs(PyGC_Head *containers)
54bffdddc0ef final patches from Neil Schemenauer for garbage collection Jeremy Hylton <jeremy@alum.mit.edu> parents: diff changeset	289 {
54bffdddc0ef final patches from Neil Schemenauer for garbage collection Jeremy Hylton <jeremy@alum.mit.edu> parents: diff changeset	290 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	291 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	292 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	293 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	294 (void) traverse(FROM_GC(gc),
13183 54bffdddc0ef final patches from Neil Schemenauer for garbage collection Jeremy Hylton <jeremy@alum.mit.edu> parents: diff changeset	295 (visitproc)visit_decref,
54bffdddc0ef final patches from Neil Schemenauer for garbage collection Jeremy Hylton <jeremy@alum.mit.edu> parents: diff changeset	296 NULL);
54bffdddc0ef final patches from Neil Schemenauer for garbage collection Jeremy Hylton <jeremy@alum.mit.edu> parents: diff changeset	297 }
54bffdddc0ef final patches from Neil Schemenauer for garbage collection Jeremy Hylton <jeremy@alum.mit.edu> parents: diff changeset	298 }
54bffdddc0ef final patches from Neil Schemenauer for garbage collection Jeremy Hylton <jeremy@alum.mit.edu> parents: diff changeset	299
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	300 /* 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	301 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	302 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	303 {
24077 a5162fd65c3d Reserved another gc_refs value for untracked objects. Every live gc Tim Peters <tim.peters@gmail.com> parents: 24075 diff changeset	304 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	305 PyGC_Head *gc = AS_GC(op);
36769 ab1b53d54901 Change GC refcount to Py_ssize_t. Martin v. Löwis <martin@v.loewis.de> parents: 36524 diff changeset	306 const Py_ssize_t gc_refs = gc->gc.gc_refs;
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	307
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	308 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	309 /* 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	310 * 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	311 * 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	312 * 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	313 */
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	314 gc->gc.gc_refs = 1;
13183 54bffdddc0ef final patches from Neil Schemenauer for garbage collection Jeremy Hylton <jeremy@alum.mit.edu> parents: diff changeset	315 }
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	316 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	317 /* 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	318 * 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	319 * 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	320 * 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	321 * 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	322 */
33869 223d20afc8b5 gc list function cleanup. Tim Peters <tim.peters@gmail.com> parents: 33867 diff changeset	323 gc_list_move(gc, reachable);
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	324 gc->gc.gc_refs = 1;
13183 54bffdddc0ef final patches from Neil Schemenauer for garbage collection Jeremy Hylton <jeremy@alum.mit.edu> parents: diff changeset	325 }
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	326 /* 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	327 * 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	328 * 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	329 * 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	330 * 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	331 * 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	332 * 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	333 */
24077 a5162fd65c3d Reserved another gc_refs value for untracked objects. Every live gc Tim Peters <tim.peters@gmail.com> parents: 24075 diff changeset	334 else {
a5162fd65c3d Reserved another gc_refs value for untracked objects. Every live gc Tim Peters <tim.peters@gmail.com> parents: 24075 diff changeset	335 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	336 \|\| 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	337 \|\| 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	338 }
13183 54bffdddc0ef final patches from Neil Schemenauer for garbage collection Jeremy Hylton <jeremy@alum.mit.edu> parents: diff changeset	339 }
54bffdddc0ef final patches from Neil Schemenauer for garbage collection Jeremy Hylton <jeremy@alum.mit.edu> parents: diff changeset	340 return 0;
54bffdddc0ef final patches from Neil Schemenauer for garbage collection Jeremy Hylton <jeremy@alum.mit.edu> parents: diff changeset	341 }
54bffdddc0ef final patches from Neil Schemenauer for garbage collection Jeremy Hylton <jeremy@alum.mit.edu> parents: diff changeset	342
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	343 /* 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	344 * 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	345 * 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	346 * 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	347 * 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	348 * 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	349 * not.
24072 86b3760d285d SF bug #574132: Major GC related performance regression Tim Peters <tim.peters@gmail.com> parents: 24036 diff changeset	350 */
13183 54bffdddc0ef final patches from Neil Schemenauer for garbage collection Jeremy Hylton <jeremy@alum.mit.edu> parents: diff changeset	351 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	352 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	353 {
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	354 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	355
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	356 /* 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	357 * = 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	358 * 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	359 * 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	360 * 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	361 * 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	362 * 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	363 */
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
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 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	366 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	367
24085 22d2f037af9d Finished transitioning to using gc_refs to track gc objects' states. Tim Peters <tim.peters@gmail.com> parents: 24077 diff changeset	368 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	369 /* 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	370 * 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	371 * 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	372 * 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	373 * 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	374 * 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	375 * 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	376 */
22d2f037af9d Finished transitioning to using gc_refs to track gc objects' states. Tim Peters <tim.peters@gmail.com> parents: 24077 diff changeset	377 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	378 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	379 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	380 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	381 (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	382 (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	383 (void *)young);
22d2f037af9d Finished transitioning to using gc_refs to track gc objects' states. Tim Peters <tim.peters@gmail.com> parents: 24077 diff changeset	384 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	385 }
22d2f037af9d Finished transitioning to using gc_refs to track gc objects' states. Tim Peters <tim.peters@gmail.com> parents: 24077 diff changeset	386 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	387 /* 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	388 * 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	389 * 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	390 * 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	391 * 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	392 * 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	393 */
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	394 next = gc->gc.gc_next;
33869 223d20afc8b5 gc list function cleanup. Tim Peters <tim.peters@gmail.com> parents: 33867 diff changeset	395 gc_list_move(gc, 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	396 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	397 }
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	398 gc = next;
13183 54bffdddc0ef final patches from Neil Schemenauer for garbage collection Jeremy Hylton <jeremy@alum.mit.edu> parents: diff changeset	399 }
54bffdddc0ef final patches from Neil Schemenauer for garbage collection Jeremy Hylton <jeremy@alum.mit.edu> parents: diff changeset	400 }
54bffdddc0ef final patches from Neil Schemenauer for garbage collection Jeremy Hylton <jeremy@alum.mit.edu> parents: diff changeset	401
28508 8233a0294c41 New comments. Rewrote has_finalizer() as a sequence of ifs instead of Tim Peters <tim.peters@gmail.com> parents: 28507 diff changeset	402 /* 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	403 * 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	404 *__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	405 * 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	406 * 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	407 * 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	408 */
20818 9aded6235d89 Add has_finalizer predictate function. Use it when deciding which Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 20810 diff changeset	409 static int
9aded6235d89 Add has_finalizer predictate function. Use it when deciding which Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 20810 diff changeset	410 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	411 {
28508 8233a0294c41 New comments. Rewrote has_finalizer() as a sequence of ifs instead of Tim Peters <tim.peters@gmail.com> parents: 28507 diff changeset	412 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	413 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	414 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	415 }
35298 b2fe5f8fcfdd PEP 342 implementation. Per Guido's comments, the generator throw() Phillip J. Eby <pje@telecommunity.com> parents: 35103 diff changeset	416 else
28508 8233a0294c41 New comments. Rewrote has_finalizer() as a sequence of ifs instead of Tim Peters <tim.peters@gmail.com> parents: 28507 diff changeset	417 return op->ob_type->tp_del != NULL;
20818 9aded6235d89 Add has_finalizer predictate function. Use it when deciding which Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 20810 diff changeset	418 }
9aded6235d89 Add has_finalizer predictate function. Use it when deciding which Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 20810 diff changeset	419
33862 facb5a2f4b53 SF 1055820: weakref callback vs gc vs threads Tim Peters <tim.peters@gmail.com> parents: 31341 diff changeset	420 /* Move the objects in unreachable with __del__ methods into `finalizers`.
facb5a2f4b53 SF 1055820: weakref callback vs gc vs threads Tim Peters <tim.peters@gmail.com> parents: 31341 diff changeset	421 * Objects moved into `finalizers` have gc_refs set to GC_REACHABLE; the
facb5a2f4b53 SF 1055820: weakref callback vs gc vs threads Tim Peters <tim.peters@gmail.com> parents: 31341 diff changeset	422 * objects 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	423 */
13183 54bffdddc0ef final patches from Neil Schemenauer for garbage collection Jeremy Hylton <jeremy@alum.mit.edu> parents: diff changeset	424 static void
33862 facb5a2f4b53 SF 1055820: weakref callback vs gc vs threads Tim Peters <tim.peters@gmail.com> parents: 31341 diff changeset	425 move_finalizers(PyGC_Head unreachable, PyGC_Head finalizers)
13183 54bffdddc0ef final patches from Neil Schemenauer for garbage collection Jeremy Hylton <jeremy@alum.mit.edu> parents: diff changeset	426 {
33862 facb5a2f4b53 SF 1055820: weakref callback vs gc vs threads Tim Peters <tim.peters@gmail.com> parents: 31341 diff changeset	427 PyGC_Head *gc;
facb5a2f4b53 SF 1055820: weakref callback vs gc vs threads Tim Peters <tim.peters@gmail.com> parents: 31341 diff changeset	428 PyGC_Head *next;
28520 6653a56002ef Reworked has_finalizer() to use the new _PyObject_Lookup() instead Tim Peters <tim.peters@gmail.com> parents: 28516 diff changeset	429
33862 facb5a2f4b53 SF 1055820: weakref callback vs gc vs threads Tim Peters <tim.peters@gmail.com> parents: 31341 diff changeset	430 /* March over unreachable. Move objects with finalizers into
facb5a2f4b53 SF 1055820: weakref callback vs gc vs threads Tim Peters <tim.peters@gmail.com> parents: 31341 diff changeset	431 * `finalizers`.
facb5a2f4b53 SF 1055820: weakref callback vs gc vs threads Tim Peters <tim.peters@gmail.com> parents: 31341 diff changeset	432 */
facb5a2f4b53 SF 1055820: weakref callback vs gc vs threads Tim Peters <tim.peters@gmail.com> parents: 31341 diff changeset	433 for (gc = unreachable->gc.gc_next; gc != unreachable; gc = next) {
19585 c43d7a8f00a4 Make more things internal to this file. Remove Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 19128 diff changeset	434 PyObject *op = FROM_GC(gc);
28504 cb5db5561cdc Fix Tim's boom example. Jeremy Hylton <jeremy@alum.mit.edu> parents: 28498 diff changeset	435
28510 0de0ded19968 move_finalizers(): Rewrote. It's not necessary for this routine Tim Peters <tim.peters@gmail.com> parents: 28508 diff changeset	436 assert(IS_TENTATIVELY_UNREACHABLE(op));
33862 facb5a2f4b53 SF 1055820: weakref callback vs gc vs threads Tim Peters <tim.peters@gmail.com> parents: 31341 diff changeset	437 next = gc->gc.gc_next;
28510 0de0ded19968 move_finalizers(): Rewrote. It's not necessary for this routine Tim Peters <tim.peters@gmail.com> parents: 28508 diff changeset	438
28520 6653a56002ef Reworked has_finalizer() to use the new _PyObject_Lookup() instead Tim Peters <tim.peters@gmail.com> parents: 28516 diff changeset	439 if (has_finalizer(op)) {
33869 223d20afc8b5 gc list function cleanup. Tim Peters <tim.peters@gmail.com> parents: 33867 diff changeset	440 gc_list_move(gc, finalizers);
28520 6653a56002ef Reworked has_finalizer() to use the new _PyObject_Lookup() instead Tim Peters <tim.peters@gmail.com> parents: 28516 diff changeset	441 gc->gc.gc_refs = GC_REACHABLE;
28504 cb5db5561cdc Fix Tim's boom example. Jeremy Hylton <jeremy@alum.mit.edu> parents: 28498 diff changeset	442 }
13183 54bffdddc0ef final patches from Neil Schemenauer for garbage collection Jeremy Hylton <jeremy@alum.mit.edu> parents: diff changeset	443 }
54bffdddc0ef final patches from Neil Schemenauer for garbage collection Jeremy Hylton <jeremy@alum.mit.edu> parents: diff changeset	444 }
54bffdddc0ef final patches from Neil Schemenauer for garbage collection Jeremy Hylton <jeremy@alum.mit.edu> parents: diff changeset	445
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	446 /* 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	447 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	448 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	449 {
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	450 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	451 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	452 PyGC_Head *gc = AS_GC(op);
33869 223d20afc8b5 gc list function cleanup. Tim Peters <tim.peters@gmail.com> parents: 33867 diff changeset	453 gc_list_move(gc, tolist);
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	454 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	455 }
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	456 }
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	457 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	458 }
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	459
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	460 /* 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	461 * 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	462 */
13183 54bffdddc0ef final patches from Neil Schemenauer for garbage collection Jeremy Hylton <jeremy@alum.mit.edu> parents: diff changeset	463 static void
28520 6653a56002ef Reworked has_finalizer() to use the new _PyObject_Lookup() instead Tim Peters <tim.peters@gmail.com> parents: 28516 diff changeset	464 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	465 {
54bffdddc0ef final patches from Neil Schemenauer for garbage collection Jeremy Hylton <jeremy@alum.mit.edu> parents: diff changeset	466 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	467 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	468 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	469 /* 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	470 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	471 (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	472 (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	473 (void *)finalizers);
13183 54bffdddc0ef final patches from Neil Schemenauer for garbage collection Jeremy Hylton <jeremy@alum.mit.edu> parents: diff changeset	474 }
54bffdddc0ef final patches from Neil Schemenauer for garbage collection Jeremy Hylton <jeremy@alum.mit.edu> parents: diff changeset	475 }
54bffdddc0ef final patches from Neil Schemenauer for garbage collection Jeremy Hylton <jeremy@alum.mit.edu> parents: diff changeset	476
33862 facb5a2f4b53 SF 1055820: weakref callback vs gc vs threads Tim Peters <tim.peters@gmail.com> parents: 31341 diff changeset	477 /* Clear all weakrefs to unreachable objects, and if such a weakref has a
facb5a2f4b53 SF 1055820: weakref callback vs gc vs threads Tim Peters <tim.peters@gmail.com> parents: 31341 diff changeset	478 * callback, invoke it if necessary. Note that it's possible for such
facb5a2f4b53 SF 1055820: weakref callback vs gc vs threads Tim Peters <tim.peters@gmail.com> parents: 31341 diff changeset	479 * weakrefs to be outside the unreachable set -- indeed, those are precisely
facb5a2f4b53 SF 1055820: weakref callback vs gc vs threads Tim Peters <tim.peters@gmail.com> parents: 31341 diff changeset	480 * the weakrefs whose callbacks must be invoked. See gc_weakref.txt for
facb5a2f4b53 SF 1055820: weakref callback vs gc vs threads Tim Peters <tim.peters@gmail.com> parents: 31341 diff changeset	481 * overview & some details. Some weakrefs with callbacks may be reclaimed
facb5a2f4b53 SF 1055820: weakref callback vs gc vs threads Tim Peters <tim.peters@gmail.com> parents: 31341 diff changeset	482 * directly by this routine; the number reclaimed is the return value. Other
facb5a2f4b53 SF 1055820: weakref callback vs gc vs threads Tim Peters <tim.peters@gmail.com> parents: 31341 diff changeset	483 * weakrefs with callbacks may be moved into the `old` generation. Objects
facb5a2f4b53 SF 1055820: weakref callback vs gc vs threads Tim Peters <tim.peters@gmail.com> parents: 31341 diff changeset	484 * moved into `old` have gc_refs set to GC_REACHABLE; the objects remaining in
facb5a2f4b53 SF 1055820: weakref callback vs gc vs threads Tim Peters <tim.peters@gmail.com> parents: 31341 diff changeset	485 * unreachable are left at GC_TENTATIVELY_UNREACHABLE. When this returns,
facb5a2f4b53 SF 1055820: weakref callback vs gc vs threads Tim Peters <tim.peters@gmail.com> parents: 31341 diff changeset	486 * no object in `unreachable` is weakly referenced anymore.
30988 caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults. Tim Peters <tim.peters@gmail.com> parents: 30918 diff changeset	487 */
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults. Tim Peters <tim.peters@gmail.com> parents: 30918 diff changeset	488 static int
33862 facb5a2f4b53 SF 1055820: weakref callback vs gc vs threads Tim Peters <tim.peters@gmail.com> parents: 31341 diff changeset	489 handle_weakrefs(PyGC_Head unreachable, PyGC_Head old)
30988 caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults. Tim Peters <tim.peters@gmail.com> parents: 30918 diff changeset	490 {
33862 facb5a2f4b53 SF 1055820: weakref callback vs gc vs threads Tim Peters <tim.peters@gmail.com> parents: 31341 diff changeset	491 PyGC_Head *gc;
facb5a2f4b53 SF 1055820: weakref callback vs gc vs threads Tim Peters <tim.peters@gmail.com> parents: 31341 diff changeset	492 PyObject op; / generally FROM_GC(gc) */
facb5a2f4b53 SF 1055820: weakref callback vs gc vs threads Tim Peters <tim.peters@gmail.com> parents: 31341 diff changeset	493 PyWeakReference wr; / generally a cast of op */
facb5a2f4b53 SF 1055820: weakref callback vs gc vs threads Tim Peters <tim.peters@gmail.com> parents: 31341 diff changeset	494 PyGC_Head wrcb_to_call; /* weakrefs with callbacks to call */
facb5a2f4b53 SF 1055820: weakref callback vs gc vs threads Tim Peters <tim.peters@gmail.com> parents: 31341 diff changeset	495 PyGC_Head *next;
30988 caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults. Tim Peters <tim.peters@gmail.com> parents: 30918 diff changeset	496 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	497
33862 facb5a2f4b53 SF 1055820: weakref callback vs gc vs threads Tim Peters <tim.peters@gmail.com> parents: 31341 diff changeset	498 gc_list_init(&wrcb_to_call);
facb5a2f4b53 SF 1055820: weakref callback vs gc vs threads Tim Peters <tim.peters@gmail.com> parents: 31341 diff changeset	499
facb5a2f4b53 SF 1055820: weakref callback vs gc vs threads Tim Peters <tim.peters@gmail.com> parents: 31341 diff changeset	500 /* Clear all weakrefs to the objects in unreachable. If such a weakref
facb5a2f4b53 SF 1055820: weakref callback vs gc vs threads Tim Peters <tim.peters@gmail.com> parents: 31341 diff changeset	501 * also has a callback, move it into `wrcb_to_call` if the callback
33867 07d94a162cf8 handle_weakrefs(): Simplification -- there's no need to make a second Tim Peters <tim.peters@gmail.com> parents: 33862 diff changeset	502 * needs to be invoked. Note that we cannot invoke any callbacks until
07d94a162cf8 handle_weakrefs(): Simplification -- there's no need to make a second Tim Peters <tim.peters@gmail.com> parents: 33862 diff changeset	503 * all weakrefs to unreachable objects are cleared, lest the callback
07d94a162cf8 handle_weakrefs(): Simplification -- there's no need to make a second Tim Peters <tim.peters@gmail.com> parents: 33862 diff changeset	504 * resurrect an unreachable object via a still-active weakref. We
07d94a162cf8 handle_weakrefs(): Simplification -- there's no need to make a second Tim Peters <tim.peters@gmail.com> parents: 33862 diff changeset	505 * make another pass over wrcb_to_call, invoking callbacks, after this
07d94a162cf8 handle_weakrefs(): Simplification -- there's no need to make a second Tim Peters <tim.peters@gmail.com> parents: 33862 diff changeset	506 * pass completes.
33862 facb5a2f4b53 SF 1055820: weakref callback vs gc vs threads Tim Peters <tim.peters@gmail.com> parents: 31341 diff changeset	507 */
facb5a2f4b53 SF 1055820: weakref callback vs gc vs threads Tim Peters <tim.peters@gmail.com> parents: 31341 diff changeset	508 for (gc = unreachable->gc.gc_next; gc != unreachable; gc = next) {
facb5a2f4b53 SF 1055820: weakref callback vs gc vs threads Tim Peters <tim.peters@gmail.com> parents: 31341 diff changeset	509 PyWeakReference **wrlist;
facb5a2f4b53 SF 1055820: weakref callback vs gc vs threads Tim Peters <tim.peters@gmail.com> parents: 31341 diff changeset	510
facb5a2f4b53 SF 1055820: weakref callback vs gc vs threads Tim Peters <tim.peters@gmail.com> parents: 31341 diff changeset	511 op = FROM_GC(gc);
facb5a2f4b53 SF 1055820: weakref callback vs gc vs threads Tim Peters <tim.peters@gmail.com> parents: 31341 diff changeset	512 assert(IS_TENTATIVELY_UNREACHABLE(op));
facb5a2f4b53 SF 1055820: weakref callback vs gc vs threads Tim Peters <tim.peters@gmail.com> parents: 31341 diff changeset	513 next = gc->gc.gc_next;
facb5a2f4b53 SF 1055820: weakref callback vs gc vs threads Tim Peters <tim.peters@gmail.com> parents: 31341 diff changeset	514
facb5a2f4b53 SF 1055820: weakref callback vs gc vs threads Tim Peters <tim.peters@gmail.com> parents: 31341 diff changeset	515 if (! PyType_SUPPORTS_WEAKREFS(op->ob_type))
facb5a2f4b53 SF 1055820: weakref callback vs gc vs threads Tim Peters <tim.peters@gmail.com> parents: 31341 diff changeset	516 continue;
facb5a2f4b53 SF 1055820: weakref callback vs gc vs threads Tim Peters <tim.peters@gmail.com> parents: 31341 diff changeset	517
facb5a2f4b53 SF 1055820: weakref callback vs gc vs threads Tim Peters <tim.peters@gmail.com> parents: 31341 diff changeset	518 /* It supports weakrefs. Does it have any? */
facb5a2f4b53 SF 1055820: weakref callback vs gc vs threads Tim Peters <tim.peters@gmail.com> parents: 31341 diff changeset	519 wrlist = (PyWeakReference **)
facb5a2f4b53 SF 1055820: weakref callback vs gc vs threads Tim Peters <tim.peters@gmail.com> parents: 31341 diff changeset	520 PyObject_GET_WEAKREFS_LISTPTR(op);
facb5a2f4b53 SF 1055820: weakref callback vs gc vs threads Tim Peters <tim.peters@gmail.com> parents: 31341 diff changeset	521
facb5a2f4b53 SF 1055820: weakref callback vs gc vs threads Tim Peters <tim.peters@gmail.com> parents: 31341 diff changeset	522 /* `op` may have some weakrefs. March over the list, clear
facb5a2f4b53 SF 1055820: weakref callback vs gc vs threads Tim Peters <tim.peters@gmail.com> parents: 31341 diff changeset	523 * all the weakrefs, and move the weakrefs with callbacks
33867 07d94a162cf8 handle_weakrefs(): Simplification -- there's no need to make a second Tim Peters <tim.peters@gmail.com> parents: 33862 diff changeset	524 * that must be called into wrcb_to_call.
33862 facb5a2f4b53 SF 1055820: weakref callback vs gc vs threads Tim Peters <tim.peters@gmail.com> parents: 31341 diff changeset	525 */
facb5a2f4b53 SF 1055820: weakref callback vs gc vs threads Tim Peters <tim.peters@gmail.com> parents: 31341 diff changeset	526 for (wr = wrlist; wr != NULL; wr = wrlist) {
facb5a2f4b53 SF 1055820: weakref callback vs gc vs threads Tim Peters <tim.peters@gmail.com> parents: 31341 diff changeset	527 PyGC_Head wrasgc; / AS_GC(wr) */
facb5a2f4b53 SF 1055820: weakref callback vs gc vs threads Tim Peters <tim.peters@gmail.com> parents: 31341 diff changeset	528
facb5a2f4b53 SF 1055820: weakref callback vs gc vs threads Tim Peters <tim.peters@gmail.com> parents: 31341 diff changeset	529 /* _PyWeakref_ClearRef clears the weakref but leaves
facb5a2f4b53 SF 1055820: weakref callback vs gc vs threads Tim Peters <tim.peters@gmail.com> parents: 31341 diff changeset	530 * the callback pointer intact. Obscure: it also
facb5a2f4b53 SF 1055820: weakref callback vs gc vs threads Tim Peters <tim.peters@gmail.com> parents: 31341 diff changeset	531 * changes *wrlist.
facb5a2f4b53 SF 1055820: weakref callback vs gc vs threads Tim Peters <tim.peters@gmail.com> parents: 31341 diff changeset	532 */
facb5a2f4b53 SF 1055820: weakref callback vs gc vs threads Tim Peters <tim.peters@gmail.com> parents: 31341 diff changeset	533 assert(wr->wr_object == op);
facb5a2f4b53 SF 1055820: weakref callback vs gc vs threads Tim Peters <tim.peters@gmail.com> parents: 31341 diff changeset	534 _PyWeakref_ClearRef(wr);
facb5a2f4b53 SF 1055820: weakref callback vs gc vs threads Tim Peters <tim.peters@gmail.com> parents: 31341 diff changeset	535 assert(wr->wr_object == Py_None);
facb5a2f4b53 SF 1055820: weakref callback vs gc vs threads Tim Peters <tim.peters@gmail.com> parents: 31341 diff changeset	536 if (wr->wr_callback == NULL)
facb5a2f4b53 SF 1055820: weakref callback vs gc vs threads Tim Peters <tim.peters@gmail.com> parents: 31341 diff changeset	537 continue; /* no callback */
30988 caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults. Tim Peters <tim.peters@gmail.com> parents: 30918 diff changeset	538
33862 facb5a2f4b53 SF 1055820: weakref callback vs gc vs threads Tim Peters <tim.peters@gmail.com> parents: 31341 diff changeset	539 /* Headache time. `op` is going away, and is weakly referenced by
facb5a2f4b53 SF 1055820: weakref callback vs gc vs threads Tim Peters <tim.peters@gmail.com> parents: 31341 diff changeset	540 * `wr`, which has a callback. Should the callback be invoked? If wr
facb5a2f4b53 SF 1055820: weakref callback vs gc vs threads Tim Peters <tim.peters@gmail.com> parents: 31341 diff changeset	541 * is also trash, no:
facb5a2f4b53 SF 1055820: weakref callback vs gc vs threads Tim Peters <tim.peters@gmail.com> parents: 31341 diff changeset	542 *
facb5a2f4b53 SF 1055820: weakref callback vs gc vs threads Tim Peters <tim.peters@gmail.com> parents: 31341 diff changeset	543 * 1. There's no need to call it. The object and the weakref are
facb5a2f4b53 SF 1055820: weakref callback vs gc vs threads Tim Peters <tim.peters@gmail.com> parents: 31341 diff changeset	544 * both going away, so it's legitimate to pretend the weakref is
facb5a2f4b53 SF 1055820: weakref callback vs gc vs threads Tim Peters <tim.peters@gmail.com> parents: 31341 diff changeset	545 * going away first. The user has to ensure a weakref outlives its
facb5a2f4b53 SF 1055820: weakref callback vs gc vs threads Tim Peters <tim.peters@gmail.com> parents: 31341 diff changeset	546 * referent if they want a guarantee that the wr callback will get
facb5a2f4b53 SF 1055820: weakref callback vs gc vs threads Tim Peters <tim.peters@gmail.com> parents: 31341 diff changeset	547 * invoked.
facb5a2f4b53 SF 1055820: weakref callback vs gc vs threads Tim Peters <tim.peters@gmail.com> parents: 31341 diff changeset	548 *
facb5a2f4b53 SF 1055820: weakref callback vs gc vs threads Tim Peters <tim.peters@gmail.com> parents: 31341 diff changeset	549 * 2. It may be catastrophic to call it. If the callback is also in
facb5a2f4b53 SF 1055820: weakref callback vs gc vs threads Tim Peters <tim.peters@gmail.com> parents: 31341 diff changeset	550 * cyclic trash (CT), then although the CT is unreachable from
facb5a2f4b53 SF 1055820: weakref callback vs gc vs threads Tim Peters <tim.peters@gmail.com> parents: 31341 diff changeset	551 * outside the current generation, CT may be reachable from the
facb5a2f4b53 SF 1055820: weakref callback vs gc vs threads Tim Peters <tim.peters@gmail.com> parents: 31341 diff changeset	552 * callback. Then the callback could resurrect insane objects.
facb5a2f4b53 SF 1055820: weakref callback vs gc vs threads Tim Peters <tim.peters@gmail.com> parents: 31341 diff changeset	553 *
facb5a2f4b53 SF 1055820: weakref callback vs gc vs threads Tim Peters <tim.peters@gmail.com> parents: 31341 diff changeset	554 * Since the callback is never needed and may be unsafe in this case,
33867 07d94a162cf8 handle_weakrefs(): Simplification -- there's no need to make a second Tim Peters <tim.peters@gmail.com> parents: 33862 diff changeset	555 * wr is simply left in the unreachable set. Note that because we
07d94a162cf8 handle_weakrefs(): Simplification -- there's no need to make a second Tim Peters <tim.peters@gmail.com> parents: 33862 diff changeset	556 * already called _PyWeakref_ClearRef(wr), its callback will never
07d94a162cf8 handle_weakrefs(): Simplification -- there's no need to make a second Tim Peters <tim.peters@gmail.com> parents: 33862 diff changeset	557 * trigger.
33862 facb5a2f4b53 SF 1055820: weakref callback vs gc vs threads Tim Peters <tim.peters@gmail.com> parents: 31341 diff changeset	558 *
facb5a2f4b53 SF 1055820: weakref callback vs gc vs threads Tim Peters <tim.peters@gmail.com> parents: 31341 diff changeset	559 * OTOH, if wr isn't part of CT, we should invoke the callback: the
facb5a2f4b53 SF 1055820: weakref callback vs gc vs threads Tim Peters <tim.peters@gmail.com> parents: 31341 diff changeset	560 * weakref outlived the trash. Note that since wr isn't CT in this
facb5a2f4b53 SF 1055820: weakref callback vs gc vs threads Tim Peters <tim.peters@gmail.com> parents: 31341 diff changeset	561 * case, its callback can't be CT either -- wr acted as an external
facb5a2f4b53 SF 1055820: weakref callback vs gc vs threads Tim Peters <tim.peters@gmail.com> parents: 31341 diff changeset	562 * root to this generation, and therefore its callback did too. So
facb5a2f4b53 SF 1055820: weakref callback vs gc vs threads Tim Peters <tim.peters@gmail.com> parents: 31341 diff changeset	563 * nothing in CT is reachable from the callback either, so it's hard
facb5a2f4b53 SF 1055820: weakref callback vs gc vs threads Tim Peters <tim.peters@gmail.com> parents: 31341 diff changeset	564 * to imagine how calling it later could create a problem for us. wr
facb5a2f4b53 SF 1055820: weakref callback vs gc vs threads Tim Peters <tim.peters@gmail.com> parents: 31341 diff changeset	565 * is moved to wrcb_to_call in this case.
facb5a2f4b53 SF 1055820: weakref callback vs gc vs threads Tim Peters <tim.peters@gmail.com> parents: 31341 diff changeset	566 */
33867 07d94a162cf8 handle_weakrefs(): Simplification -- there's no need to make a second Tim Peters <tim.peters@gmail.com> parents: 33862 diff changeset	567 if (IS_TENTATIVELY_UNREACHABLE(wr))
07d94a162cf8 handle_weakrefs(): Simplification -- there's no need to make a second Tim Peters <tim.peters@gmail.com> parents: 33862 diff changeset	568 continue;
07d94a162cf8 handle_weakrefs(): Simplification -- there's no need to make a second Tim Peters <tim.peters@gmail.com> parents: 33862 diff changeset	569 assert(IS_REACHABLE(wr));
07d94a162cf8 handle_weakrefs(): Simplification -- there's no need to make a second Tim Peters <tim.peters@gmail.com> parents: 33862 diff changeset	570
33862 facb5a2f4b53 SF 1055820: weakref callback vs gc vs threads Tim Peters <tim.peters@gmail.com> parents: 31341 diff changeset	571 /* Create a new reference so that wr can't go away
facb5a2f4b53 SF 1055820: weakref callback vs gc vs threads Tim Peters <tim.peters@gmail.com> parents: 31341 diff changeset	572 * before we can process it again.
facb5a2f4b53 SF 1055820: weakref callback vs gc vs threads Tim Peters <tim.peters@gmail.com> parents: 31341 diff changeset	573 */
facb5a2f4b53 SF 1055820: weakref callback vs gc vs threads Tim Peters <tim.peters@gmail.com> parents: 31341 diff changeset	574 Py_INCREF(wr);
facb5a2f4b53 SF 1055820: weakref callback vs gc vs threads Tim Peters <tim.peters@gmail.com> parents: 31341 diff changeset	575
33867 07d94a162cf8 handle_weakrefs(): Simplification -- there's no need to make a second Tim Peters <tim.peters@gmail.com> parents: 33862 diff changeset	576 /* Move wr to wrcb_to_call, for the next pass. */
33862 facb5a2f4b53 SF 1055820: weakref callback vs gc vs threads Tim Peters <tim.peters@gmail.com> parents: 31341 diff changeset	577 wrasgc = AS_GC(wr);
33867 07d94a162cf8 handle_weakrefs(): Simplification -- there's no need to make a second Tim Peters <tim.peters@gmail.com> parents: 33862 diff changeset	578 assert(wrasgc != next); /* wrasgc is reachable, but
07d94a162cf8 handle_weakrefs(): Simplification -- there's no need to make a second Tim Peters <tim.peters@gmail.com> parents: 33862 diff changeset	579 next isn't, so they can't
07d94a162cf8 handle_weakrefs(): Simplification -- there's no need to make a second Tim Peters <tim.peters@gmail.com> parents: 33862 diff changeset	580 be the same */
33869 223d20afc8b5 gc list function cleanup. Tim Peters <tim.peters@gmail.com> parents: 33867 diff changeset	581 gc_list_move(wrasgc, &wrcb_to_call);
33862 facb5a2f4b53 SF 1055820: weakref callback vs gc vs threads Tim Peters <tim.peters@gmail.com> parents: 31341 diff changeset	582 }
facb5a2f4b53 SF 1055820: weakref callback vs gc vs threads Tim Peters <tim.peters@gmail.com> parents: 31341 diff changeset	583 }
facb5a2f4b53 SF 1055820: weakref callback vs gc vs threads Tim Peters <tim.peters@gmail.com> parents: 31341 diff changeset	584
33867 07d94a162cf8 handle_weakrefs(): Simplification -- there's no need to make a second Tim Peters <tim.peters@gmail.com> parents: 33862 diff changeset	585 /* Invoke the callbacks we decided to honor. It's safe to invoke them
07d94a162cf8 handle_weakrefs(): Simplification -- there's no need to make a second Tim Peters <tim.peters@gmail.com> parents: 33862 diff changeset	586 * because they can't reference unreachable objects.
33862 facb5a2f4b53 SF 1055820: weakref callback vs gc vs threads Tim Peters <tim.peters@gmail.com> parents: 31341 diff changeset	587 */
facb5a2f4b53 SF 1055820: weakref callback vs gc vs threads Tim Peters <tim.peters@gmail.com> parents: 31341 diff changeset	588 while (! gc_list_is_empty(&wrcb_to_call)) {
facb5a2f4b53 SF 1055820: weakref callback vs gc vs threads Tim Peters <tim.peters@gmail.com> parents: 31341 diff changeset	589 PyObject *temp;
facb5a2f4b53 SF 1055820: weakref callback vs gc vs threads Tim Peters <tim.peters@gmail.com> parents: 31341 diff changeset	590 PyObject *callback;
facb5a2f4b53 SF 1055820: weakref callback vs gc vs threads Tim Peters <tim.peters@gmail.com> parents: 31341 diff changeset	591
facb5a2f4b53 SF 1055820: weakref callback vs gc vs threads Tim Peters <tim.peters@gmail.com> parents: 31341 diff changeset	592 gc = wrcb_to_call.gc.gc_next;
facb5a2f4b53 SF 1055820: weakref callback vs gc vs threads Tim Peters <tim.peters@gmail.com> parents: 31341 diff changeset	593 op = FROM_GC(gc);
facb5a2f4b53 SF 1055820: weakref callback vs gc vs threads Tim Peters <tim.peters@gmail.com> parents: 31341 diff changeset	594 assert(IS_REACHABLE(op));
facb5a2f4b53 SF 1055820: weakref callback vs gc vs threads Tim Peters <tim.peters@gmail.com> parents: 31341 diff changeset	595 assert(PyWeakref_Check(op));
facb5a2f4b53 SF 1055820: weakref callback vs gc vs threads Tim Peters <tim.peters@gmail.com> parents: 31341 diff changeset	596 wr = (PyWeakReference *)op;
facb5a2f4b53 SF 1055820: weakref callback vs gc vs threads Tim Peters <tim.peters@gmail.com> parents: 31341 diff changeset	597 callback = wr->wr_callback;
facb5a2f4b53 SF 1055820: weakref callback vs gc vs threads Tim Peters <tim.peters@gmail.com> parents: 31341 diff changeset	598 assert(callback != NULL);
facb5a2f4b53 SF 1055820: weakref callback vs gc vs threads Tim Peters <tim.peters@gmail.com> parents: 31341 diff changeset	599
facb5a2f4b53 SF 1055820: weakref callback vs gc vs threads Tim Peters <tim.peters@gmail.com> parents: 31341 diff changeset	600 /* copy-paste of weakrefobject.c's handle_callback() */
facb5a2f4b53 SF 1055820: weakref callback vs gc vs threads Tim Peters <tim.peters@gmail.com> parents: 31341 diff changeset	601 temp = PyObject_CallFunction(callback, "O", wr);
facb5a2f4b53 SF 1055820: weakref callback vs gc vs threads Tim Peters <tim.peters@gmail.com> parents: 31341 diff changeset	602 if (temp == NULL)
facb5a2f4b53 SF 1055820: weakref callback vs gc vs threads Tim Peters <tim.peters@gmail.com> parents: 31341 diff changeset	603 PyErr_WriteUnraisable(callback);
facb5a2f4b53 SF 1055820: weakref callback vs gc vs threads Tim Peters <tim.peters@gmail.com> parents: 31341 diff changeset	604 else
facb5a2f4b53 SF 1055820: weakref callback vs gc vs threads Tim Peters <tim.peters@gmail.com> parents: 31341 diff changeset	605 Py_DECREF(temp);
facb5a2f4b53 SF 1055820: weakref callback vs gc vs threads Tim Peters <tim.peters@gmail.com> parents: 31341 diff changeset	606
facb5a2f4b53 SF 1055820: weakref callback vs gc vs threads Tim Peters <tim.peters@gmail.com> parents: 31341 diff changeset	607 /* Give up the reference we created in the first pass. When
facb5a2f4b53 SF 1055820: weakref callback vs gc vs threads Tim Peters <tim.peters@gmail.com> parents: 31341 diff changeset	608 * op's refcount hits 0 (which it may or may not do right now),
33867 07d94a162cf8 handle_weakrefs(): Simplification -- there's no need to make a second Tim Peters <tim.peters@gmail.com> parents: 33862 diff changeset	609 * op's tp_dealloc will decref op->wr_callback too. Note
07d94a162cf8 handle_weakrefs(): Simplification -- there's no need to make a second Tim Peters <tim.peters@gmail.com> parents: 33862 diff changeset	610 * that the refcount probably will hit 0 now, and because this
07d94a162cf8 handle_weakrefs(): Simplification -- there's no need to make a second Tim Peters <tim.peters@gmail.com> parents: 33862 diff changeset	611 * weakref was reachable to begin with, gc didn't already
07d94a162cf8 handle_weakrefs(): Simplification -- there's no need to make a second Tim Peters <tim.peters@gmail.com> parents: 33862 diff changeset	612 * add it to its count of freed objects. Example: a reachable
07d94a162cf8 handle_weakrefs(): Simplification -- there's no need to make a second Tim Peters <tim.peters@gmail.com> parents: 33862 diff changeset	613 * weak value dict maps some key to this reachable weakref.
07d94a162cf8 handle_weakrefs(): Simplification -- there's no need to make a second Tim Peters <tim.peters@gmail.com> parents: 33862 diff changeset	614 * The callback removes this key->weakref mapping from the
07d94a162cf8 handle_weakrefs(): Simplification -- there's no need to make a second Tim Peters <tim.peters@gmail.com> parents: 33862 diff changeset	615 * dict, leaving no other references to the weakref (excepting
07d94a162cf8 handle_weakrefs(): Simplification -- there's no need to make a second Tim Peters <tim.peters@gmail.com> parents: 33862 diff changeset	616 * ours).
33862 facb5a2f4b53 SF 1055820: weakref callback vs gc vs threads Tim Peters <tim.peters@gmail.com> parents: 31341 diff changeset	617 */
facb5a2f4b53 SF 1055820: weakref callback vs gc vs threads Tim Peters <tim.peters@gmail.com> parents: 31341 diff changeset	618 Py_DECREF(op);
facb5a2f4b53 SF 1055820: weakref callback vs gc vs threads Tim Peters <tim.peters@gmail.com> parents: 31341 diff changeset	619 if (wrcb_to_call.gc.gc_next == gc) {
facb5a2f4b53 SF 1055820: weakref callback vs gc vs threads Tim Peters <tim.peters@gmail.com> parents: 31341 diff changeset	620 /* object is still alive -- move it */
33869 223d20afc8b5 gc list function cleanup. Tim Peters <tim.peters@gmail.com> parents: 33867 diff changeset	621 gc_list_move(gc, old);
33862 facb5a2f4b53 SF 1055820: weakref callback vs gc vs threads Tim Peters <tim.peters@gmail.com> parents: 31341 diff changeset	622 }
facb5a2f4b53 SF 1055820: weakref callback vs gc vs threads Tim Peters <tim.peters@gmail.com> parents: 31341 diff changeset	623 else
facb5a2f4b53 SF 1055820: weakref callback vs gc vs threads Tim Peters <tim.peters@gmail.com> parents: 31341 diff changeset	624 ++num_freed;
facb5a2f4b53 SF 1055820: weakref callback vs gc vs threads Tim Peters <tim.peters@gmail.com> parents: 31341 diff changeset	625 }
facb5a2f4b53 SF 1055820: weakref callback vs gc vs threads Tim Peters <tim.peters@gmail.com> parents: 31341 diff changeset	626
30988 caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults. Tim Peters <tim.peters@gmail.com> parents: 30918 diff changeset	627 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	628 }
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults. Tim Peters <tim.peters@gmail.com> parents: 30918 diff changeset	629
13183 54bffdddc0ef final patches from Neil Schemenauer for garbage collection Jeremy Hylton <jeremy@alum.mit.edu> parents: diff changeset	630 static void
14294 053627e7ac14 apply patch #101362 by Vladimir Marangozov Jeremy Hylton <jeremy@alum.mit.edu> parents: 13878 diff changeset	631 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	632 {
54bffdddc0ef final patches from Neil Schemenauer for garbage collection Jeremy Hylton <jeremy@alum.mit.edu> parents: diff changeset	633 char *cname;
20818 9aded6235d89 Add has_finalizer predictate function. Use it when deciding which Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 20810 diff changeset	634 /* simple version of instance_repr */
13183 54bffdddc0ef final patches from Neil Schemenauer for garbage collection Jeremy Hylton <jeremy@alum.mit.edu> parents: diff changeset	635 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	636 if (classname != NULL && PyString_Check(classname))
54bffdddc0ef final patches from Neil Schemenauer for garbage collection Jeremy Hylton <jeremy@alum.mit.edu> parents: diff changeset	637 cname = PyString_AsString(classname);
54bffdddc0ef final patches from Neil Schemenauer for garbage collection Jeremy Hylton <jeremy@alum.mit.edu> parents: diff changeset	638 else
54bffdddc0ef final patches from Neil Schemenauer for garbage collection Jeremy Hylton <jeremy@alum.mit.edu> parents: diff changeset	639 cname = "?";
14294 053627e7ac14 apply patch #101362 by Vladimir Marangozov Jeremy Hylton <jeremy@alum.mit.edu> parents: 13878 diff changeset	640 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	641 msg, cname, inst);
13183 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
54bffdddc0ef final patches from Neil Schemenauer for garbage collection Jeremy Hylton <jeremy@alum.mit.edu> parents: diff changeset	644 static void
14294 053627e7ac14 apply patch #101362 by Vladimir Marangozov Jeremy Hylton <jeremy@alum.mit.edu> parents: 13878 diff changeset	645 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	646 {
54bffdddc0ef final patches from Neil Schemenauer for garbage collection Jeremy Hylton <jeremy@alum.mit.edu> parents: diff changeset	647 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	648 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	649 }
6e9331e68a3b - Add DEBUG_SAVEALL option. When enabled all garbage objects found by the Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 14424 diff changeset	650 else if (debug & DEBUG_OBJECTS) {
14294 053627e7ac14 apply patch #101362 by Vladimir Marangozov Jeremy Hylton <jeremy@alum.mit.edu> parents: 13878 diff changeset	651 PySys_WriteStderr("gc: %.100s <%.100s %p>\n",
053627e7ac14 apply patch #101362 by Vladimir Marangozov Jeremy Hylton <jeremy@alum.mit.edu> parents: 13878 diff changeset	652 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	653 }
54bffdddc0ef final patches from Neil Schemenauer for garbage collection Jeremy Hylton <jeremy@alum.mit.edu> parents: diff changeset	654 }
54bffdddc0ef final patches from Neil Schemenauer for garbage collection Jeremy Hylton <jeremy@alum.mit.edu> parents: diff changeset	655
28511 acf3596fcc28 Reworked move_finalizer_reachable() to create two distinct lists: Tim Peters <tim.peters@gmail.com> parents: 28510 diff changeset	656 /* 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	657 * 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	658 * 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	659 * 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	660 * __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	661 * 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	662 * 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	663 * 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	664 */
28515 4c596dd60c22 handle_finalizers(): Rewrote to call append_objects() and gc_list_merge() Tim Peters <tim.peters@gmail.com> parents: 28512 diff changeset	665 static int
28520 6653a56002ef Reworked has_finalizer() to use the new _PyObject_Lookup() instead Tim Peters <tim.peters@gmail.com> parents: 28516 diff changeset	666 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	667 {
28520 6653a56002ef Reworked has_finalizer() to use the new _PyObject_Lookup() instead Tim Peters <tim.peters@gmail.com> parents: 28516 diff changeset	668 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	669
13183 54bffdddc0ef final patches from Neil Schemenauer for garbage collection Jeremy Hylton <jeremy@alum.mit.edu> parents: diff changeset	670 if (garbage == NULL) {
54bffdddc0ef final patches from Neil Schemenauer for garbage collection Jeremy Hylton <jeremy@alum.mit.edu> parents: diff changeset	671 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	672 if (garbage == NULL)
acf3596fcc28 Reworked move_finalizer_reachable() to create two distinct lists: Tim Peters <tim.peters@gmail.com> parents: 28510 diff changeset	673 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	674 }
28520 6653a56002ef Reworked has_finalizer() to use the new _PyObject_Lookup() instead Tim Peters <tim.peters@gmail.com> parents: 28516 diff changeset	675 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	676 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	677
6653a56002ef Reworked has_finalizer() to use the new _PyObject_Lookup() instead Tim Peters <tim.peters@gmail.com> parents: 28516 diff changeset	678 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	679 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	680 return -1;
6653a56002ef Reworked has_finalizer() to use the new _PyObject_Lookup() instead Tim Peters <tim.peters@gmail.com> parents: 28516 diff changeset	681 }
13183 54bffdddc0ef final patches from Neil Schemenauer for garbage collection Jeremy Hylton <jeremy@alum.mit.edu> parents: diff changeset	682 }
28520 6653a56002ef Reworked has_finalizer() to use the new _PyObject_Lookup() instead Tim Peters <tim.peters@gmail.com> parents: 28516 diff changeset	683
28515 4c596dd60c22 handle_finalizers(): Rewrote to call append_objects() and gc_list_merge() Tim Peters <tim.peters@gmail.com> parents: 28512 diff changeset	684 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	685 return 0;
13183 54bffdddc0ef final patches from Neil Schemenauer for garbage collection Jeremy Hylton <jeremy@alum.mit.edu> parents: diff changeset	686 }
54bffdddc0ef final patches from Neil Schemenauer for garbage collection Jeremy Hylton <jeremy@alum.mit.edu> parents: diff changeset	687
14756 6e9331e68a3b - Add DEBUG_SAVEALL option. When enabled all garbage objects found by the Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 14424 diff changeset	688 /* 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	689 * 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	690 * 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	691 */
13183 54bffdddc0ef final patches from Neil Schemenauer for garbage collection Jeremy Hylton <jeremy@alum.mit.edu> parents: diff changeset	692 static void
28504 cb5db5561cdc Fix Tim's boom example. Jeremy Hylton <jeremy@alum.mit.edu> parents: 28498 diff changeset	693 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	694 {
54bffdddc0ef final patches from Neil Schemenauer for garbage collection Jeremy Hylton <jeremy@alum.mit.edu> parents: diff changeset	695 inquiry clear;
54bffdddc0ef final patches from Neil Schemenauer for garbage collection Jeremy Hylton <jeremy@alum.mit.edu> parents: diff changeset	696
28504 cb5db5561cdc Fix Tim's boom example. Jeremy Hylton <jeremy@alum.mit.edu> parents: 28498 diff changeset	697 while (!gc_list_is_empty(collectable)) {
cb5db5561cdc Fix Tim's boom example. Jeremy Hylton <jeremy@alum.mit.edu> parents: 28498 diff changeset	698 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	699 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	700
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	701 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	702 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	703 PyList_Append(garbage, op);
13183 54bffdddc0ef final patches from Neil Schemenauer for garbage collection Jeremy Hylton <jeremy@alum.mit.edu> parents: diff changeset	704 }
14756 6e9331e68a3b - Add DEBUG_SAVEALL option. When enabled all garbage objects found by the Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 14424 diff changeset	705 else {
6e9331e68a3b - Add DEBUG_SAVEALL option. When enabled all garbage objects found by the Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 14424 diff changeset	706 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	707 Py_INCREF(op);
23721 48e937e1b3fe Remove casts to PyObject * when declaration is for PyObject * Jeremy Hylton <jeremy@alum.mit.edu> parents: 23495 diff changeset	708 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	709 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	710 }
6e9331e68a3b - Add DEBUG_SAVEALL option. When enabled all garbage objects found by the Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 14424 diff changeset	711 }
28504 cb5db5561cdc Fix Tim's boom example. Jeremy Hylton <jeremy@alum.mit.edu> parents: 28498 diff changeset	712 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	713 /* object is still alive, move it, it may die later */
33869 223d20afc8b5 gc list function cleanup. Tim Peters <tim.peters@gmail.com> parents: 33867 diff changeset	714 gc_list_move(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	715 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	716 }
54bffdddc0ef final patches from Neil Schemenauer for garbage collection Jeremy Hylton <jeremy@alum.mit.edu> parents: diff changeset	717 }
54bffdddc0ef final patches from Neil Schemenauer for garbage collection Jeremy Hylton <jeremy@alum.mit.edu> parents: diff changeset	718 }
54bffdddc0ef final patches from Neil Schemenauer for garbage collection Jeremy Hylton <jeremy@alum.mit.edu> parents: diff changeset	719
54bffdddc0ef final patches from Neil Schemenauer for garbage collection Jeremy Hylton <jeremy@alum.mit.edu> parents: diff changeset	720 /* 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	721 * collection process works. */
36839 7c1aca8e3d7d Make PyGC_Collect() use Py_ssize_t. Neal Norwitz <nnorwitz@gmail.com> parents: 36769 diff changeset	722 static Py_ssize_t
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	723 collect(int generation)
13183 54bffdddc0ef final patches from Neil Schemenauer for garbage collection Jeremy Hylton <jeremy@alum.mit.edu> parents: diff changeset	724 {
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	725 int i;
36839 7c1aca8e3d7d Make PyGC_Collect() use Py_ssize_t. Neal Norwitz <nnorwitz@gmail.com> parents: 36769 diff changeset	726 Py_ssize_t m = 0; /* # objects collected */
7c1aca8e3d7d Make PyGC_Collect() use Py_ssize_t. Neal Norwitz <nnorwitz@gmail.com> parents: 36769 diff changeset	727 Py_ssize_t 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	728 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	729 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	730 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	731 PyGC_Head finalizers; /* objects with, & reachable from, __del__ */
13183 54bffdddc0ef final patches from Neil Schemenauer for garbage collection Jeremy Hylton <jeremy@alum.mit.edu> parents: diff changeset	732 PyGC_Head *gc;
54bffdddc0ef final patches from Neil Schemenauer for garbage collection Jeremy Hylton <jeremy@alum.mit.edu> parents: diff changeset	733
28507 a0503bdb0c24 Fixed new seemingly random segfaults, by moving the initialization of Tim Peters <tim.peters@gmail.com> parents: 28504 diff changeset	734 if (delstr == NULL) {
a0503bdb0c24 Fixed new seemingly random segfaults, by moving the initialization of Tim Peters <tim.peters@gmail.com> parents: 28504 diff changeset	735 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	736 if (delstr == NULL)
a0503bdb0c24 Fixed new seemingly random segfaults, by moving the initialization of Tim Peters <tim.peters@gmail.com> parents: 28504 diff changeset	737 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	738 }
a0503bdb0c24 Fixed new seemingly random segfaults, by moving the initialization of Tim Peters <tim.peters@gmail.com> parents: 28504 diff changeset	739
13183 54bffdddc0ef final patches from Neil Schemenauer for garbage collection Jeremy Hylton <jeremy@alum.mit.edu> parents: diff changeset	740 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	741 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	742 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	743 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	744 for (i = 0; i < NUM_GENERATIONS; i++) {
36860 8ebf7997c6cd Fix warnings on x86 (32-bit) and support Win64. Neal Norwitz <nnorwitz@gmail.com> parents: 36839 diff changeset	745 #ifdef MS_WIN64
8ebf7997c6cd Fix warnings on x86 (32-bit) and support Win64. Neal Norwitz <nnorwitz@gmail.com> parents: 36839 diff changeset	746 PySys_WriteStderr(" %Id", gc_list_size(GEN_HEAD(i)));
8ebf7997c6cd Fix warnings on x86 (32-bit) and support Win64. Neal Norwitz <nnorwitz@gmail.com> parents: 36839 diff changeset	747 #else
8ebf7997c6cd Fix warnings on x86 (32-bit) and support Win64. Neal Norwitz <nnorwitz@gmail.com> parents: 36839 diff changeset	748 PySys_WriteStderr(" %ld",
8ebf7997c6cd Fix warnings on x86 (32-bit) and support Win64. Neal Norwitz <nnorwitz@gmail.com> parents: 36839 diff changeset	749 Py_SAFE_DOWNCAST(gc_list_size(GEN_HEAD(i)),
8ebf7997c6cd Fix warnings on x86 (32-bit) and support Win64. Neal Norwitz <nnorwitz@gmail.com> parents: 36839 diff changeset	750 Py_ssize_t, long));
8ebf7997c6cd Fix warnings on x86 (32-bit) and support Win64. Neal Norwitz <nnorwitz@gmail.com> parents: 36839 diff changeset	751 #endif
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	752 }
2f7d869dad4d Move all data for a single generation into a structure. The set of Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 23296 diff changeset	753 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	754 }
2f7d869dad4d Move all data for a single generation into a structure. The set of Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 23296 diff changeset	755
2f7d869dad4d Move all data for a single generation into a structure. The set of Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 23296 diff changeset	756 /* 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	757 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	758 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	759 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	760 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	761
2f7d869dad4d Move all data for a single generation into a structure. The set of Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 23296 diff changeset	762 /* 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	763 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	764 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	765 }
2f7d869dad4d Move all data for a single generation into a structure. The set of Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 23296 diff changeset	766
2f7d869dad4d Move all data for a single generation into a structure. The set of Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 23296 diff changeset	767 /* 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	768 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	769 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	770 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	771 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	772 old = young;
13183 54bffdddc0ef final patches from Neil Schemenauer for garbage collection Jeremy Hylton <jeremy@alum.mit.edu> parents: diff changeset	773
54bffdddc0ef final patches from Neil Schemenauer for garbage collection Jeremy Hylton <jeremy@alum.mit.edu> parents: diff changeset	774 /* Using ob_refcnt and gc_refs, calculate which objects in the
33862 facb5a2f4b53 SF 1055820: weakref callback vs gc vs threads Tim Peters <tim.peters@gmail.com> parents: 31341 diff changeset	775 * container set are reachable from outside the set (i.e., have a
13183 54bffdddc0ef final patches from Neil Schemenauer for garbage collection Jeremy Hylton <jeremy@alum.mit.edu> parents: diff changeset	776 * refcount greater than 0 when all the references within the
33862 facb5a2f4b53 SF 1055820: weakref callback vs gc vs threads Tim Peters <tim.peters@gmail.com> parents: 31341 diff changeset	777 * set are taken into account).
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	778 */
13183 54bffdddc0ef final patches from Neil Schemenauer for garbage collection Jeremy Hylton <jeremy@alum.mit.edu> parents: diff changeset	779 update_refs(young);
54bffdddc0ef final patches from Neil Schemenauer for garbage collection Jeremy Hylton <jeremy@alum.mit.edu> parents: diff changeset	780 subtract_refs(young);
54bffdddc0ef final patches from Neil Schemenauer for garbage collection Jeremy Hylton <jeremy@alum.mit.edu> parents: diff changeset	781
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	782 /* 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	783 * 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	784 * 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	785 * 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	786 * 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	787 */
13183 54bffdddc0ef final patches from Neil Schemenauer for garbage collection Jeremy Hylton <jeremy@alum.mit.edu> parents: diff changeset	788 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	789 move_unreachable(young, &unreachable);
13183 54bffdddc0ef final patches from Neil Schemenauer for garbage collection Jeremy Hylton <jeremy@alum.mit.edu> parents: diff changeset	790
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	791 /* 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	792 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	793 gc_list_merge(young, old);
13183 54bffdddc0ef final patches from Neil Schemenauer for garbage collection Jeremy Hylton <jeremy@alum.mit.edu> parents: diff changeset	794
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	795 /* 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	796 * 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	797 * 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	798 * instance objects with __del__ methods. Weakrefs with callbacks
33862 facb5a2f4b53 SF 1055820: weakref callback vs gc vs threads Tim Peters <tim.peters@gmail.com> parents: 31341 diff changeset	799 * can also call arbitrary Python code but they will be dealt with by
facb5a2f4b53 SF 1055820: weakref callback vs gc vs threads Tim Peters <tim.peters@gmail.com> parents: 31341 diff changeset	800 * handle_weakrefs().
28520 6653a56002ef Reworked has_finalizer() to use the new _PyObject_Lookup() instead Tim Peters <tim.peters@gmail.com> parents: 28516 diff changeset	801 */
13183 54bffdddc0ef final patches from Neil Schemenauer for garbage collection Jeremy Hylton <jeremy@alum.mit.edu> parents: diff changeset	802 gc_list_init(&finalizers);
33862 facb5a2f4b53 SF 1055820: weakref callback vs gc vs threads Tim Peters <tim.peters@gmail.com> parents: 31341 diff changeset	803 move_finalizers(&unreachable, &finalizers);
28511 acf3596fcc28 Reworked move_finalizer_reachable() to create two distinct lists: Tim Peters <tim.peters@gmail.com> parents: 28510 diff changeset	804 /* 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	805 * 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	806 * 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	807 */
28520 6653a56002ef Reworked has_finalizer() to use the new _PyObject_Lookup() instead Tim Peters <tim.peters@gmail.com> parents: 28516 diff changeset	808 move_finalizer_reachable(&finalizers);
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 /* 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	811 * debugging information.
caa1a48da4cc SF bug 839548: Bug in type's GC handling causes segfaults. Tim Peters <tim.peters@gmail.com> parents: 30918 diff changeset	812 */
28520 6653a56002ef Reworked has_finalizer() to use the new _PyObject_Lookup() instead Tim Peters <tim.peters@gmail.com> parents: 28516 diff changeset	813 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	814 gc = gc->gc.gc_next) {
13183 54bffdddc0ef final patches from Neil Schemenauer for garbage collection Jeremy Hylton <jeremy@alum.mit.edu> parents: diff changeset	815 m++;
14294 053627e7ac14 apply patch #101362 by Vladimir Marangozov Jeremy Hylton <jeremy@alum.mit.edu> parents: 13878 diff changeset	816 if (debug & DEBUG_COLLECTABLE) {
19585 c43d7a8f00a4 Make more things internal to this file. Remove Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 19128 diff changeset	817 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	818 }
54bffdddc0ef final patches from Neil Schemenauer for garbage collection Jeremy Hylton <jeremy@alum.mit.edu> parents: diff changeset	819 }
33862 facb5a2f4b53 SF 1055820: weakref callback vs gc vs threads Tim Peters <tim.peters@gmail.com> parents: 31341 diff changeset	820
facb5a2f4b53 SF 1055820: weakref callback vs gc vs threads Tim Peters <tim.peters@gmail.com> parents: 31341 diff changeset	821 /* Clear weakrefs and invoke callbacks as necessary. */
facb5a2f4b53 SF 1055820: weakref callback vs gc vs threads Tim Peters <tim.peters@gmail.com> parents: 31341 diff changeset	822 m += handle_weakrefs(&unreachable, old);
facb5a2f4b53 SF 1055820: weakref callback vs gc vs threads Tim Peters <tim.peters@gmail.com> parents: 31341 diff changeset	823
28521 964bd97ac1f5 Comment repair; no semantic changes. Tim Peters <tim.peters@gmail.com> parents: 28520 diff changeset	824 /* 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	825 * 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	826 * in finalizers to be freed.
964bd97ac1f5 Comment repair; no semantic changes. Tim Peters <tim.peters@gmail.com> parents: 28520 diff changeset	827 */
28520 6653a56002ef Reworked has_finalizer() to use the new _PyObject_Lookup() instead Tim Peters <tim.peters@gmail.com> parents: 28516 diff changeset	828 delete_garbage(&unreachable, old);
13183 54bffdddc0ef final patches from Neil Schemenauer for garbage collection Jeremy Hylton <jeremy@alum.mit.edu> parents: diff changeset	829
54bffdddc0ef final patches from Neil Schemenauer for garbage collection Jeremy Hylton <jeremy@alum.mit.edu> parents: diff changeset	830 /* 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	831 * 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	832 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	833 gc != &finalizers;
acf3596fcc28 Reworked move_finalizer_reachable() to create two distinct lists: Tim Peters <tim.peters@gmail.com> parents: 28510 diff changeset	834 gc = gc->gc.gc_next) {
13183 54bffdddc0ef final patches from Neil Schemenauer for garbage collection Jeremy Hylton <jeremy@alum.mit.edu> parents: diff changeset	835 n++;
28511 acf3596fcc28 Reworked move_finalizer_reachable() to create two distinct lists: Tim Peters <tim.peters@gmail.com> parents: 28510 diff changeset	836 if (debug & DEBUG_UNCOLLECTABLE)
19585 c43d7a8f00a4 Make more things internal to this file. Remove Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 19128 diff changeset	837 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	838 }
14294 053627e7ac14 apply patch #101362 by Vladimir Marangozov Jeremy Hylton <jeremy@alum.mit.edu> parents: 13878 diff changeset	839 if (debug & DEBUG_STATS) {
13183 54bffdddc0ef final patches from Neil Schemenauer for garbage collection Jeremy Hylton <jeremy@alum.mit.edu> parents: diff changeset	840 if (m == 0 && n == 0) {
14294 053627e7ac14 apply patch #101362 by Vladimir Marangozov Jeremy Hylton <jeremy@alum.mit.edu> parents: 13878 diff changeset	841 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	842 }
6e9331e68a3b - Add DEBUG_SAVEALL option. When enabled all garbage objects found by the Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 14424 diff changeset	843 else {
36860 8ebf7997c6cd Fix warnings on x86 (32-bit) and support Win64. Neal Norwitz <nnorwitz@gmail.com> parents: 36839 diff changeset	844 #ifdef MS_WIN64
8ebf7997c6cd Fix warnings on x86 (32-bit) and support Win64. Neal Norwitz <nnorwitz@gmail.com> parents: 36839 diff changeset	845 PySys_WriteStderr(
8ebf7997c6cd Fix warnings on x86 (32-bit) and support Win64. Neal Norwitz <nnorwitz@gmail.com> parents: 36839 diff changeset	846 "gc: done, %Id unreachable, %Id uncollectable.\n",
8ebf7997c6cd Fix warnings on x86 (32-bit) and support Win64. Neal Norwitz <nnorwitz@gmail.com> parents: 36839 diff changeset	847 n+m, n);
8ebf7997c6cd Fix warnings on x86 (32-bit) and support Win64. Neal Norwitz <nnorwitz@gmail.com> parents: 36839 diff changeset	848 #else
14294 053627e7ac14 apply patch #101362 by Vladimir Marangozov Jeremy Hylton <jeremy@alum.mit.edu> parents: 13878 diff changeset	849 PySys_WriteStderr(
053627e7ac14 apply patch #101362 by Vladimir Marangozov Jeremy Hylton <jeremy@alum.mit.edu> parents: 13878 diff changeset	850 "gc: done, %ld unreachable, %ld uncollectable.\n",
36860 8ebf7997c6cd Fix warnings on x86 (32-bit) and support Win64. Neal Norwitz <nnorwitz@gmail.com> parents: 36839 diff changeset	851 Py_SAFE_DOWNCAST(n+m, Py_ssize_t, long),
8ebf7997c6cd Fix warnings on x86 (32-bit) and support Win64. Neal Norwitz <nnorwitz@gmail.com> parents: 36839 diff changeset	852 Py_SAFE_DOWNCAST(n, Py_ssize_t, long));
8ebf7997c6cd Fix warnings on x86 (32-bit) and support Win64. Neal Norwitz <nnorwitz@gmail.com> parents: 36839 diff changeset	853 #endif
13183 54bffdddc0ef final patches from Neil Schemenauer for garbage collection Jeremy Hylton <jeremy@alum.mit.edu> parents: diff changeset	854 }
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
54bffdddc0ef final patches from Neil Schemenauer for garbage collection Jeremy Hylton <jeremy@alum.mit.edu> parents: diff changeset	857 /* 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	858 * 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	859 * 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	860 */
28520 6653a56002ef Reworked has_finalizer() to use the new _PyObject_Lookup() instead Tim Peters <tim.peters@gmail.com> parents: 28516 diff changeset	861 (void)handle_finalizers(&finalizers, old);
13183 54bffdddc0ef final patches from Neil Schemenauer for garbage collection Jeremy Hylton <jeremy@alum.mit.edu> parents: diff changeset	862
14330 6dee1985c681 refactor __del__ exception handler into PyErr_WriteUnraisable Jeremy Hylton <jeremy@alum.mit.edu> parents: 14294 diff changeset	863 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	864 if (gc_str == NULL)
28521 964bd97ac1f5 Comment repair; no semantic changes. Tim Peters <tim.peters@gmail.com> parents: 28520 diff changeset	865 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	866 PyErr_WriteUnraisable(gc_str);
6dee1985c681 refactor __del__ exception handler into PyErr_WriteUnraisable Jeremy Hylton <jeremy@alum.mit.edu> parents: 14294 diff changeset	867 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	868 }
13183 54bffdddc0ef final patches from Neil Schemenauer for garbage collection Jeremy Hylton <jeremy@alum.mit.edu> parents: diff changeset	869 return n+m;
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
36839 7c1aca8e3d7d Make PyGC_Collect() use Py_ssize_t. Neal Norwitz <nnorwitz@gmail.com> parents: 36769 diff changeset	872 static Py_ssize_t
13183 54bffdddc0ef final patches from Neil Schemenauer for garbage collection Jeremy Hylton <jeremy@alum.mit.edu> parents: diff changeset	873 collect_generations(void)
54bffdddc0ef final patches from Neil Schemenauer for garbage collection Jeremy Hylton <jeremy@alum.mit.edu> parents: diff changeset	874 {
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	875 int i;
36839 7c1aca8e3d7d Make PyGC_Collect() use Py_ssize_t. Neal Norwitz <nnorwitz@gmail.com> parents: 36769 diff changeset	876 Py_ssize_t n = 0;
13183 54bffdddc0ef final patches from Neil Schemenauer for garbage collection Jeremy Hylton <jeremy@alum.mit.edu> parents: diff changeset	877
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	878 /* 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	879 * 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	880 * 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	881 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	882 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	883 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	884 break;
13183 54bffdddc0ef final patches from Neil Schemenauer for garbage collection Jeremy Hylton <jeremy@alum.mit.edu> parents: diff changeset	885 }
54bffdddc0ef final patches from Neil Schemenauer for garbage collection Jeremy Hylton <jeremy@alum.mit.edu> parents: diff changeset	886 }
54bffdddc0ef final patches from Neil Schemenauer for garbage collection Jeremy Hylton <jeremy@alum.mit.edu> parents: diff changeset	887 return n;
54bffdddc0ef final patches from Neil Schemenauer for garbage collection Jeremy Hylton <jeremy@alum.mit.edu> parents: diff changeset	888 }
54bffdddc0ef final patches from Neil Schemenauer for garbage collection Jeremy Hylton <jeremy@alum.mit.edu> parents: diff changeset	889
23832 ed1ba37a46b7 Patch #568124: Add doc string macros. Martin v. Löwis <martin@v.loewis.de> parents: 23721 diff changeset	890 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	891 "enable() -> None\n"
abfa4e4b2f3e Neil Schemenauer: GC enable(), disable(), isenabled() interface. Vladimir Marangozov <vladimir.marangozov@t-online.de> parents: 13570 diff changeset	892 "\n"
23832 ed1ba37a46b7 Patch #568124: Add doc string macros. Martin v. Löwis <martin@v.loewis.de> parents: 23721 diff changeset	893 "Enable automatic garbage collection.\n");
13183 54bffdddc0ef final patches from Neil Schemenauer for garbage collection Jeremy Hylton <jeremy@alum.mit.edu> parents: diff changeset	894
13878 abfa4e4b2f3e Neil Schemenauer: GC enable(), disable(), isenabled() interface. Vladimir Marangozov <vladimir.marangozov@t-online.de> parents: 13570 diff changeset	895 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	896 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	897 {
abfa4e4b2f3e Neil Schemenauer: GC enable(), disable(), isenabled() interface. Vladimir Marangozov <vladimir.marangozov@t-online.de> parents: 13570 diff changeset	898 enabled = 1;
abfa4e4b2f3e Neil Schemenauer: GC enable(), disable(), isenabled() interface. Vladimir Marangozov <vladimir.marangozov@t-online.de> parents: 13570 diff changeset	899 Py_INCREF(Py_None);
abfa4e4b2f3e Neil Schemenauer: GC enable(), disable(), isenabled() interface. Vladimir Marangozov <vladimir.marangozov@t-online.de> parents: 13570 diff changeset	900 return Py_None;
abfa4e4b2f3e Neil Schemenauer: GC enable(), disable(), isenabled() interface. Vladimir Marangozov <vladimir.marangozov@t-online.de> parents: 13570 diff changeset	901 }
abfa4e4b2f3e Neil Schemenauer: GC enable(), disable(), isenabled() interface. Vladimir Marangozov <vladimir.marangozov@t-online.de> parents: 13570 diff changeset	902
23832 ed1ba37a46b7 Patch #568124: Add doc string macros. Martin v. Löwis <martin@v.loewis.de> parents: 23721 diff changeset	903 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	904 "disable() -> None\n"
abfa4e4b2f3e Neil Schemenauer: GC enable(), disable(), isenabled() interface. Vladimir Marangozov <vladimir.marangozov@t-online.de> parents: 13570 diff changeset	905 "\n"
23832 ed1ba37a46b7 Patch #568124: Add doc string macros. Martin v. Löwis <martin@v.loewis.de> parents: 23721 diff changeset	906 "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	907
abfa4e4b2f3e Neil Schemenauer: GC enable(), disable(), isenabled() interface. Vladimir Marangozov <vladimir.marangozov@t-online.de> parents: 13570 diff changeset	908 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	909 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	910 {
abfa4e4b2f3e Neil Schemenauer: GC enable(), disable(), isenabled() interface. Vladimir Marangozov <vladimir.marangozov@t-online.de> parents: 13570 diff changeset	911 enabled = 0;
abfa4e4b2f3e Neil Schemenauer: GC enable(), disable(), isenabled() interface. Vladimir Marangozov <vladimir.marangozov@t-online.de> parents: 13570 diff changeset	912 Py_INCREF(Py_None);
abfa4e4b2f3e Neil Schemenauer: GC enable(), disable(), isenabled() interface. Vladimir Marangozov <vladimir.marangozov@t-online.de> parents: 13570 diff changeset	913 return Py_None;
abfa4e4b2f3e Neil Schemenauer: GC enable(), disable(), isenabled() interface. Vladimir Marangozov <vladimir.marangozov@t-online.de> parents: 13570 diff changeset	914 }
abfa4e4b2f3e Neil Schemenauer: GC enable(), disable(), isenabled() interface. Vladimir Marangozov <vladimir.marangozov@t-online.de> parents: 13570 diff changeset	915
23832 ed1ba37a46b7 Patch #568124: Add doc string macros. Martin v. Löwis <martin@v.loewis.de> parents: 23721 diff changeset	916 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	917 "isenabled() -> status\n"
abfa4e4b2f3e Neil Schemenauer: GC enable(), disable(), isenabled() interface. Vladimir Marangozov <vladimir.marangozov@t-online.de> parents: 13570 diff changeset	918 "\n"
23832 ed1ba37a46b7 Patch #568124: Add doc string macros. Martin v. Löwis <martin@v.loewis.de> parents: 23721 diff changeset	919 "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	920
abfa4e4b2f3e Neil Schemenauer: GC enable(), disable(), isenabled() interface. Vladimir Marangozov <vladimir.marangozov@t-online.de> parents: 13570 diff changeset	921 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	922 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	923 {
31341 4915fbec608f Convert return value to boolean. Raymond Hettinger <python@rcn.com> parents: 31010 diff changeset	924 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	925 }
abfa4e4b2f3e Neil Schemenauer: GC enable(), disable(), isenabled() interface. Vladimir Marangozov <vladimir.marangozov@t-online.de> parents: 13570 diff changeset	926
23832 ed1ba37a46b7 Patch #568124: Add doc string macros. Martin v. Löwis <martin@v.loewis.de> parents: 23721 diff changeset	927 PyDoc_STRVAR(gc_collect__doc__,
36863 2d24f3a37a1b SF patch #1443865; gc.get_count() added and optional argument 'generation' Barry Warsaw <barry@python.org> parents: 36860 diff changeset	928 "collect([generation]) -> n\n"
13183 54bffdddc0ef final patches from Neil Schemenauer for garbage collection Jeremy Hylton <jeremy@alum.mit.edu> parents: diff changeset	929 "\n"
36863 2d24f3a37a1b SF patch #1443865; gc.get_count() added and optional argument 'generation' Barry Warsaw <barry@python.org> parents: 36860 diff changeset	930 "With no arguments, run a full collection. The optional argument\n"
2d24f3a37a1b SF patch #1443865; gc.get_count() added and optional argument 'generation' Barry Warsaw <barry@python.org> parents: 36860 diff changeset	931 "may be an integer specifying which generation to collect. A ValueError\n"
2d24f3a37a1b SF patch #1443865; gc.get_count() added and optional argument 'generation' Barry Warsaw <barry@python.org> parents: 36860 diff changeset	932 "is raised if the generation number is invalid.\n\n"
2d24f3a37a1b SF patch #1443865; gc.get_count() added and optional argument 'generation' Barry Warsaw <barry@python.org> parents: 36860 diff changeset	933 "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	934
54bffdddc0ef final patches from Neil Schemenauer for garbage collection Jeremy Hylton <jeremy@alum.mit.edu> parents: diff changeset	935 static PyObject *
36863 2d24f3a37a1b SF patch #1443865; gc.get_count() added and optional argument 'generation' Barry Warsaw <barry@python.org> parents: 36860 diff changeset	936 gc_collect(PyObject self, PyObject args, PyObject *kws)
13183 54bffdddc0ef final patches from Neil Schemenauer for garbage collection Jeremy Hylton <jeremy@alum.mit.edu> parents: diff changeset	937 {
36863 2d24f3a37a1b SF patch #1443865; gc.get_count() added and optional argument 'generation' Barry Warsaw <barry@python.org> parents: 36860 diff changeset	938 static char *keywords[] = {"generation", NULL};
2d24f3a37a1b SF patch #1443865; gc.get_count() added and optional argument 'generation' Barry Warsaw <barry@python.org> parents: 36860 diff changeset	939 int genarg = NUM_GENERATIONS - 1;
36839 7c1aca8e3d7d Make PyGC_Collect() use Py_ssize_t. Neal Norwitz <nnorwitz@gmail.com> parents: 36769 diff changeset	940 Py_ssize_t n;
13183 54bffdddc0ef final patches from Neil Schemenauer for garbage collection Jeremy Hylton <jeremy@alum.mit.edu> parents: diff changeset	941
36863 2d24f3a37a1b SF patch #1443865; gc.get_count() added and optional argument 'generation' Barry Warsaw <barry@python.org> parents: 36860 diff changeset	942 if (!PyArg_ParseTupleAndKeywords(args, kws, "\|i", keywords, &genarg))
2d24f3a37a1b SF patch #1443865; gc.get_count() added and optional argument 'generation' Barry Warsaw <barry@python.org> parents: 36860 diff changeset	943 return NULL;
2d24f3a37a1b SF patch #1443865; gc.get_count() added and optional argument 'generation' Barry Warsaw <barry@python.org> parents: 36860 diff changeset	944
2d24f3a37a1b SF patch #1443865; gc.get_count() added and optional argument 'generation' Barry Warsaw <barry@python.org> parents: 36860 diff changeset	945 else if (genarg < 0 \|\| genarg >= NUM_GENERATIONS) {
2d24f3a37a1b SF patch #1443865; gc.get_count() added and optional argument 'generation' Barry Warsaw <barry@python.org> parents: 36860 diff changeset	946 PyErr_SetString(PyExc_ValueError, "invalid generation");
2d24f3a37a1b SF patch #1443865; gc.get_count() added and optional argument 'generation' Barry Warsaw <barry@python.org> parents: 36860 diff changeset	947 return NULL;
2d24f3a37a1b SF patch #1443865; gc.get_count() added and optional argument 'generation' Barry Warsaw <barry@python.org> parents: 36860 diff changeset	948 }
2d24f3a37a1b SF patch #1443865; gc.get_count() added and optional argument 'generation' Barry Warsaw <barry@python.org> parents: 36860 diff changeset	949
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	950 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	951 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	952 else {
9c23abab962d Make the gc.collect() function respect the collection lock. This fixes Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 20393 diff changeset	953 collecting = 1;
36863 2d24f3a37a1b SF patch #1443865; gc.get_count() added and optional argument 'generation' Barry Warsaw <barry@python.org> parents: 36860 diff changeset	954 n = collect(genarg);
20796 9c23abab962d Make the gc.collect() function respect the collection lock. This fixes Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 20393 diff changeset	955 collecting = 0;
9c23abab962d Make the gc.collect() function respect the collection lock. This fixes Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 20393 diff changeset	956 }
13183 54bffdddc0ef final patches from Neil Schemenauer for garbage collection Jeremy Hylton <jeremy@alum.mit.edu> parents: diff changeset	957
36839 7c1aca8e3d7d Make PyGC_Collect() use Py_ssize_t. Neal Norwitz <nnorwitz@gmail.com> parents: 36769 diff changeset	958 return PyInt_FromSsize_t(n);
13183 54bffdddc0ef final patches from Neil Schemenauer for garbage collection Jeremy Hylton <jeremy@alum.mit.edu> parents: diff changeset	959 }
54bffdddc0ef final patches from Neil Schemenauer for garbage collection Jeremy Hylton <jeremy@alum.mit.edu> parents: diff changeset	960
23832 ed1ba37a46b7 Patch #568124: Add doc string macros. Martin v. Löwis <martin@v.loewis.de> parents: 23721 diff changeset	961 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	962 "set_debug(flags) -> None\n"
54bffdddc0ef final patches from Neil Schemenauer for garbage collection Jeremy Hylton <jeremy@alum.mit.edu> parents: diff changeset	963 "\n"
54bffdddc0ef final patches from Neil Schemenauer for garbage collection Jeremy Hylton <jeremy@alum.mit.edu> parents: diff changeset	964 "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	965 "written to sys.stderr.\n"
54bffdddc0ef final patches from Neil Schemenauer for garbage collection Jeremy Hylton <jeremy@alum.mit.edu> parents: diff changeset	966 "\n"
54bffdddc0ef final patches from Neil Schemenauer for garbage collection Jeremy Hylton <jeremy@alum.mit.edu> parents: diff changeset	967 "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	968 "\n"
54bffdddc0ef final patches from Neil Schemenauer for garbage collection Jeremy Hylton <jeremy@alum.mit.edu> parents: diff changeset	969 " 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	970 " 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	971 " 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	972 " DEBUG_INSTANCES - Print instance objects.\n"
54bffdddc0ef final patches from Neil Schemenauer for garbage collection Jeremy Hylton <jeremy@alum.mit.edu> parents: diff changeset	973 " 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	974 " 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	975 " 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	976
54bffdddc0ef final patches from Neil Schemenauer for garbage collection Jeremy Hylton <jeremy@alum.mit.edu> parents: diff changeset	977 static PyObject *
13878 abfa4e4b2f3e Neil Schemenauer: GC enable(), disable(), isenabled() interface. Vladimir Marangozov <vladimir.marangozov@t-online.de> parents: 13570 diff changeset	978 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	979 {
14774 52174b002f1f Fix some long/"l" int/"i" mismatches. Fixes bug #113779. Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 14756 diff changeset	980 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	981 return NULL;
54bffdddc0ef final patches from Neil Schemenauer for garbage collection Jeremy Hylton <jeremy@alum.mit.edu> parents: diff changeset	982
54bffdddc0ef final patches from Neil Schemenauer for garbage collection Jeremy Hylton <jeremy@alum.mit.edu> parents: diff changeset	983 Py_INCREF(Py_None);
54bffdddc0ef final patches from Neil Schemenauer for garbage collection Jeremy Hylton <jeremy@alum.mit.edu> parents: diff changeset	984 return Py_None;
54bffdddc0ef final patches from Neil Schemenauer for garbage collection Jeremy Hylton <jeremy@alum.mit.edu> parents: diff changeset	985 }
54bffdddc0ef final patches from Neil Schemenauer for garbage collection Jeremy Hylton <jeremy@alum.mit.edu> parents: diff changeset	986
23832 ed1ba37a46b7 Patch #568124: Add doc string macros. Martin v. Löwis <martin@v.loewis.de> parents: 23721 diff changeset	987 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	988 "get_debug() -> flags\n"
54bffdddc0ef final patches from Neil Schemenauer for garbage collection Jeremy Hylton <jeremy@alum.mit.edu> parents: diff changeset	989 "\n"
23832 ed1ba37a46b7 Patch #568124: Add doc string macros. Martin v. Löwis <martin@v.loewis.de> parents: 23721 diff changeset	990 "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	991
54bffdddc0ef final patches from Neil Schemenauer for garbage collection Jeremy Hylton <jeremy@alum.mit.edu> parents: diff changeset	992 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	993 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	994 {
54bffdddc0ef final patches from Neil Schemenauer for garbage collection Jeremy Hylton <jeremy@alum.mit.edu> parents: diff changeset	995 return Py_BuildValue("i", debug);
54bffdddc0ef final patches from Neil Schemenauer for garbage collection Jeremy Hylton <jeremy@alum.mit.edu> parents: diff changeset	996 }
54bffdddc0ef final patches from Neil Schemenauer for garbage collection Jeremy Hylton <jeremy@alum.mit.edu> parents: diff changeset	997
23832 ed1ba37a46b7 Patch #568124: Add doc string macros. Martin v. Löwis <martin@v.loewis.de> parents: 23721 diff changeset	998 PyDoc_STRVAR(gc_set_thresh__doc__,
21833 070d392042e3 Fix spelling mistakes. Bugfix candidates. Neal Norwitz <nnorwitz@gmail.com> parents: 21139 diff changeset	999 "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	1000 "\n"
54bffdddc0ef final patches from Neil Schemenauer for garbage collection Jeremy Hylton <jeremy@alum.mit.edu> parents: diff changeset	1001 "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	1002 "collection.\n");
13183 54bffdddc0ef final patches from Neil Schemenauer for garbage collection Jeremy Hylton <jeremy@alum.mit.edu> parents: diff changeset	1003
54bffdddc0ef final patches from Neil Schemenauer for garbage collection Jeremy Hylton <jeremy@alum.mit.edu> parents: diff changeset	1004 static PyObject *
13878 abfa4e4b2f3e Neil Schemenauer: GC enable(), disable(), isenabled() interface. Vladimir Marangozov <vladimir.marangozov@t-online.de> parents: 13570 diff changeset	1005 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	1006 {
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	1007 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	1008 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	1009 &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	1010 &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	1011 &generations[2].threshold))
13183 54bffdddc0ef final patches from Neil Schemenauer for garbage collection Jeremy Hylton <jeremy@alum.mit.edu> parents: diff changeset	1012 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	1013 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	1014 /* 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	1015 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	1016 }
13183 54bffdddc0ef final patches from Neil Schemenauer for garbage collection Jeremy Hylton <jeremy@alum.mit.edu> parents: diff changeset	1017
54bffdddc0ef final patches from Neil Schemenauer for garbage collection Jeremy Hylton <jeremy@alum.mit.edu> parents: diff changeset	1018 Py_INCREF(Py_None);
54bffdddc0ef final patches from Neil Schemenauer for garbage collection Jeremy Hylton <jeremy@alum.mit.edu> parents: diff changeset	1019 return Py_None;
54bffdddc0ef final patches from Neil Schemenauer for garbage collection Jeremy Hylton <jeremy@alum.mit.edu> parents: diff changeset	1020 }
54bffdddc0ef final patches from Neil Schemenauer for garbage collection Jeremy Hylton <jeremy@alum.mit.edu> parents: diff changeset	1021
23832 ed1ba37a46b7 Patch #568124: Add doc string macros. Martin v. Löwis <martin@v.loewis.de> parents: 23721 diff changeset	1022 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	1023 "get_threshold() -> (threshold0, threshold1, threshold2)\n"
54bffdddc0ef final patches from Neil Schemenauer for garbage collection Jeremy Hylton <jeremy@alum.mit.edu> parents: diff changeset	1024 "\n"
23832 ed1ba37a46b7 Patch #568124: Add doc string macros. Martin v. Löwis <martin@v.loewis.de> parents: 23721 diff changeset	1025 "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	1026
54bffdddc0ef final patches from Neil Schemenauer for garbage collection Jeremy Hylton <jeremy@alum.mit.edu> parents: diff changeset	1027 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	1028 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	1029 {
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	1030 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	1031 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	1032 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	1033 generations[2].threshold);
13183 54bffdddc0ef final patches from Neil Schemenauer for garbage collection Jeremy Hylton <jeremy@alum.mit.edu> parents: diff changeset	1034 }
54bffdddc0ef final patches from Neil Schemenauer for garbage collection Jeremy Hylton <jeremy@alum.mit.edu> parents: diff changeset	1035
36863 2d24f3a37a1b SF patch #1443865; gc.get_count() added and optional argument 'generation' Barry Warsaw <barry@python.org> parents: 36860 diff changeset	1036 PyDoc_STRVAR(gc_get_count__doc__,
2d24f3a37a1b SF patch #1443865; gc.get_count() added and optional argument 'generation' Barry Warsaw <barry@python.org> parents: 36860 diff changeset	1037 "get_count() -> (count0, count1, count2)\n"
2d24f3a37a1b SF patch #1443865; gc.get_count() added and optional argument 'generation' Barry Warsaw <barry@python.org> parents: 36860 diff changeset	1038 "\n"
2d24f3a37a1b SF patch #1443865; gc.get_count() added and optional argument 'generation' Barry Warsaw <barry@python.org> parents: 36860 diff changeset	1039 "Return the current collection counts\n");
2d24f3a37a1b SF patch #1443865; gc.get_count() added and optional argument 'generation' Barry Warsaw <barry@python.org> parents: 36860 diff changeset	1040
2d24f3a37a1b SF patch #1443865; gc.get_count() added and optional argument 'generation' Barry Warsaw <barry@python.org> parents: 36860 diff changeset	1041 static PyObject *
2d24f3a37a1b SF patch #1443865; gc.get_count() added and optional argument 'generation' Barry Warsaw <barry@python.org> parents: 36860 diff changeset	1042 gc_get_count(PyObject self, PyObject noargs)
2d24f3a37a1b SF patch #1443865; gc.get_count() added and optional argument 'generation' Barry Warsaw <barry@python.org> parents: 36860 diff changeset	1043 {
2d24f3a37a1b SF patch #1443865; gc.get_count() added and optional argument 'generation' Barry Warsaw <barry@python.org> parents: 36860 diff changeset	1044 return Py_BuildValue("(iii)",
2d24f3a37a1b SF patch #1443865; gc.get_count() added and optional argument 'generation' Barry Warsaw <barry@python.org> parents: 36860 diff changeset	1045 generations[0].count,
2d24f3a37a1b SF patch #1443865; gc.get_count() added and optional argument 'generation' Barry Warsaw <barry@python.org> parents: 36860 diff changeset	1046 generations[1].count,
2d24f3a37a1b SF patch #1443865; gc.get_count() added and optional argument 'generation' Barry Warsaw <barry@python.org> parents: 36860 diff changeset	1047 generations[2].count);
2d24f3a37a1b SF patch #1443865; gc.get_count() added and optional argument 'generation' Barry Warsaw <barry@python.org> parents: 36860 diff changeset	1048 }
2d24f3a37a1b SF patch #1443865; gc.get_count() added and optional argument 'generation' Barry Warsaw <barry@python.org> parents: 36860 diff changeset	1049
19096 45ccf3b889b5 Add get_referents function. Closes SF patch #402925. Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15013 diff changeset	1050 static int
21038 afb789aada16 Rename get_referents to get_referrers. Fixes #483815. Martin v. Löwis <martin@v.loewis.de> parents: 20820 diff changeset	1051 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	1052 {
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	1053 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	1054 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	1055 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	1056 return 1;
19096 45ccf3b889b5 Add get_referents function. Closes SF patch #402925. Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15013 diff changeset	1057 return 0;
45ccf3b889b5 Add get_referents function. Closes SF patch #402925. Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15013 diff changeset	1058 }
45ccf3b889b5 Add get_referents function. Closes SF patch #402925. Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15013 diff changeset	1059
19128 4901a935490d Remove "referents" structure (it's not needed). Check return value Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 19097 diff changeset	1060 static int
21038 afb789aada16 Rename get_referents to get_referrers. Fixes #483815. Martin v. Löwis <martin@v.loewis.de> parents: 20820 diff changeset	1061 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	1062 {
45ccf3b889b5 Add get_referents function. Closes SF patch #402925. Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15013 diff changeset	1063 PyGC_Head *gc;
45ccf3b889b5 Add get_referents function. Closes SF patch #402925. Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15013 diff changeset	1064 PyObject *obj;
45ccf3b889b5 Add get_referents function. Closes SF patch #402925. Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15013 diff changeset	1065 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	1066 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	1067 obj = FROM_GC(gc);
19096 45ccf3b889b5 Add get_referents function. Closes SF patch #402925. Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15013 diff changeset	1068 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	1069 if (obj == objs \|\| obj == resultlist)
45ccf3b889b5 Add get_referents function. Closes SF patch #402925. Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15013 diff changeset	1070 continue;
21038 afb789aada16 Rename get_referents to get_referrers. Fixes #483815. Martin v. Löwis <martin@v.loewis.de> parents: 20820 diff changeset	1071 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	1072 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	1073 return 0; /* error */
19096 45ccf3b889b5 Add get_referents function. Closes SF patch #402925. Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15013 diff changeset	1074 }
45ccf3b889b5 Add get_referents function. Closes SF patch #402925. Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15013 diff changeset	1075 }
19128 4901a935490d Remove "referents" structure (it's not needed). Check return value Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 19097 diff changeset	1076 return 1; /* no error */
19096 45ccf3b889b5 Add get_referents function. Closes SF patch #402925. Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15013 diff changeset	1077 }
45ccf3b889b5 Add get_referents function. Closes SF patch #402925. Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15013 diff changeset	1078
23832 ed1ba37a46b7 Patch #568124: Add doc string macros. Martin v. Löwis <martin@v.loewis.de> parents: 23721 diff changeset	1079 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	1080 "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	1081 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	1082
19128 4901a935490d Remove "referents" structure (it's not needed). Check return value Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 19097 diff changeset	1083 static PyObject *
21038 afb789aada16 Rename get_referents to get_referrers. Fixes #483815. Martin v. Löwis <martin@v.loewis.de> parents: 20820 diff changeset	1084 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	1085 {
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	1086 int i;
19096 45ccf3b889b5 Add get_referents function. Closes SF patch #402925. Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15013 diff changeset	1087 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	1088 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	1089 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	1090 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	1091 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	1092 }
19128 4901a935490d Remove "referents" structure (it's not needed). Check return value Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 19097 diff changeset	1093 }
19096 45ccf3b889b5 Add get_referents function. Closes SF patch #402925. Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15013 diff changeset	1094 return result;
45ccf3b889b5 Add get_referents function. Closes SF patch #402925. Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 15013 diff changeset	1095 }
13183 54bffdddc0ef final patches from Neil Schemenauer for garbage collection Jeremy Hylton <jeremy@alum.mit.edu> parents: diff changeset	1096
28522 487df294d328 Finished implementing gc.get_referrents(): dealt with error and end Tim Peters <tim.peters@gmail.com> parents: 28521 diff changeset	1097 /* 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	1098 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	1099 referentsvisit(PyObject obj, PyObject list)
28497 40d9659b56c9 Add get_referrents() helper function. Jeremy Hylton <jeremy@alum.mit.edu> parents: 26138 diff changeset	1100 {
28522 487df294d328 Finished implementing gc.get_referrents(): dealt with error and end Tim Peters <tim.peters@gmail.com> parents: 28521 diff changeset	1101 return PyList_Append(list, obj) < 0;
28497 40d9659b56c9 Add get_referrents() helper function. Jeremy Hylton <jeremy@alum.mit.edu> parents: 26138 diff changeset	1102 }
40d9659b56c9 Add get_referrents() helper function. Jeremy Hylton <jeremy@alum.mit.edu> parents: 26138 diff changeset	1103
28523 c01fdc3a9180 s/referrents/referents/g. Gotta love that referrers remains rife with rs. Tim Peters <tim.peters@gmail.com> parents: 28522 diff changeset	1104 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	1105 "get_referents(*objs) -> list\n\
28498 3e399a8618db Add get_referrents() helper function. Jeremy Hylton <jeremy@alum.mit.edu> parents: 28497 diff changeset	1106 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	1107
40d9659b56c9 Add get_referrents() helper function. Jeremy Hylton <jeremy@alum.mit.edu> parents: 26138 diff changeset	1108 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	1109 gc_get_referents(PyObject self, PyObject args)
28497 40d9659b56c9 Add get_referrents() helper function. Jeremy Hylton <jeremy@alum.mit.edu> parents: 26138 diff changeset	1110 {
40d9659b56c9 Add get_referrents() helper function. Jeremy Hylton <jeremy@alum.mit.edu> parents: 26138 diff changeset	1111 int i;
40d9659b56c9 Add get_referrents() helper function. Jeremy Hylton <jeremy@alum.mit.edu> parents: 26138 diff changeset	1112 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	1113
487df294d328 Finished implementing gc.get_referrents(): dealt with error and end Tim Peters <tim.peters@gmail.com> parents: 28521 diff changeset	1114 if (result == NULL)
487df294d328 Finished implementing gc.get_referrents(): dealt with error and end Tim Peters <tim.peters@gmail.com> parents: 28521 diff changeset	1115 return NULL;
487df294d328 Finished implementing gc.get_referrents(): dealt with error and end Tim Peters <tim.peters@gmail.com> parents: 28521 diff changeset	1116
28497 40d9659b56c9 Add get_referrents() helper function. Jeremy Hylton <jeremy@alum.mit.edu> parents: 26138 diff changeset	1117 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	1118 traverseproc traverse;
28507 a0503bdb0c24 Fixed new seemingly random segfaults, by moving the initialization of Tim Peters <tim.peters@gmail.com> parents: 28504 diff changeset	1119 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	1120
487df294d328 Finished implementing gc.get_referrents(): dealt with error and end Tim Peters <tim.peters@gmail.com> parents: 28521 diff changeset	1121 if (! PyObject_IS_GC(obj))
28497 40d9659b56c9 Add get_referrents() helper function. Jeremy Hylton <jeremy@alum.mit.edu> parents: 26138 diff changeset	1122 continue;
28522 487df294d328 Finished implementing gc.get_referrents(): dealt with error and end Tim Peters <tim.peters@gmail.com> parents: 28521 diff changeset	1123 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	1124 if (! traverse)
487df294d328 Finished implementing gc.get_referrents(): dealt with error and end Tim Peters <tim.peters@gmail.com> parents: 28521 diff changeset	1125 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	1126 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	1127 Py_DECREF(result);
28497 40d9659b56c9 Add get_referrents() helper function. Jeremy Hylton <jeremy@alum.mit.edu> parents: 26138 diff changeset	1128 return NULL;
28522 487df294d328 Finished implementing gc.get_referrents(): dealt with error and end Tim Peters <tim.peters@gmail.com> parents: 28521 diff changeset	1129 }
28497 40d9659b56c9 Add get_referrents() helper function. Jeremy Hylton <jeremy@alum.mit.edu> parents: 26138 diff changeset	1130 }
40d9659b56c9 Add get_referrents() helper function. Jeremy Hylton <jeremy@alum.mit.edu> parents: 26138 diff changeset	1131 return result;
40d9659b56c9 Add get_referrents() helper function. Jeremy Hylton <jeremy@alum.mit.edu> parents: 26138 diff changeset	1132 }
40d9659b56c9 Add get_referrents() helper function. Jeremy Hylton <jeremy@alum.mit.edu> parents: 26138 diff changeset	1133
23832 ed1ba37a46b7 Patch #568124: Add doc string macros. Martin v. Löwis <martin@v.loewis.de> parents: 23721 diff changeset	1134 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	1135 "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	1136 "\n"
9e6f7804ef14 Add get_objects function. This is a low level function (like Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 19096 diff changeset	1137 "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	1138 "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	1139
9e6f7804ef14 Add get_objects function. This is a low level function (like Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 19096 diff changeset	1140 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	1141 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	1142 {
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	1143 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	1144 PyObject* result;
9e6f7804ef14 Add get_objects function. This is a low level function (like Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 19096 diff changeset	1145
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	1146 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	1147 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	1148 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	1149 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	1150 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	1151 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	1152 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	1153 }
21130 6e34151aefe6 Patch #486743: remove bad INCREF, propagate exception in append_objects. Martin v. Löwis <martin@v.loewis.de> parents: 21105 diff changeset	1154 }
19097 9e6f7804ef14 Add get_objects function. This is a low level function (like Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 19096 diff changeset	1155 return result;
9e6f7804ef14 Add get_objects function. This is a low level function (like Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 19096 diff changeset	1156 }
9e6f7804ef14 Add get_objects function. This is a low level function (like Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 19096 diff changeset	1157
9e6f7804ef14 Add get_objects function. This is a low level function (like Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 19096 diff changeset	1158
23832 ed1ba37a46b7 Patch #568124: Add doc string macros. Martin v. Löwis <martin@v.loewis.de> parents: 23721 diff changeset	1159 PyDoc_STRVAR(gc__doc__,
13183 54bffdddc0ef final patches from Neil Schemenauer for garbage collection Jeremy Hylton <jeremy@alum.mit.edu> parents: diff changeset	1160 "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	1161 "\n"
13878 abfa4e4b2f3e Neil Schemenauer: GC enable(), disable(), isenabled() interface. Vladimir Marangozov <vladimir.marangozov@t-online.de> parents: 13570 diff changeset	1162 "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	1163 "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	1164 "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	1165 "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	1166 "set_debug() -- Set debugging flags.\n"
54bffdddc0ef final patches from Neil Schemenauer for garbage collection Jeremy Hylton <jeremy@alum.mit.edu> parents: diff changeset	1167 "get_debug() -- Get debugging flags.\n"
54bffdddc0ef final patches from Neil Schemenauer for garbage collection Jeremy Hylton <jeremy@alum.mit.edu> parents: diff changeset	1168 "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	1169 "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	1170 "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	1171 "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	1172 "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	1173
54bffdddc0ef final patches from Neil Schemenauer for garbage collection Jeremy Hylton <jeremy@alum.mit.edu> parents: diff changeset	1174 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	1175 {"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	1176 {"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	1177 {"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	1178 {"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	1179 {"get_debug", gc_get_debug, METH_NOARGS, gc_get_debug__doc__},
36863 2d24f3a37a1b SF patch #1443865; gc.get_count() added and optional argument 'generation' Barry Warsaw <barry@python.org> parents: 36860 diff changeset	1180 {"get_count", gc_get_count, METH_NOARGS, gc_get_count__doc__},
13878 abfa4e4b2f3e Neil Schemenauer: GC enable(), disable(), isenabled() interface. Vladimir Marangozov <vladimir.marangozov@t-online.de> parents: 13570 diff changeset	1181 {"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	1182 {"get_threshold", gc_get_thresh, METH_NOARGS, gc_get_thresh__doc__},
36863 2d24f3a37a1b SF patch #1443865; gc.get_count() added and optional argument 'generation' Barry Warsaw <barry@python.org> parents: 36860 diff changeset	1183 {"collect", (PyCFunction)gc_collect,
2d24f3a37a1b SF patch #1443865; gc.get_count() added and optional argument 'generation' Barry Warsaw <barry@python.org> parents: 36860 diff changeset	1184 METH_VARARGS \| METH_KEYWORDS, gc_collect__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	1185 {"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	1186 {"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	1187 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	1188 {"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	1189 gc_get_referents__doc__},
13183 54bffdddc0ef final patches from Neil Schemenauer for garbage collection Jeremy Hylton <jeremy@alum.mit.edu> parents: diff changeset	1190 {NULL, NULL} /* Sentinel */
54bffdddc0ef final patches from Neil Schemenauer for garbage collection Jeremy Hylton <jeremy@alum.mit.edu> parents: diff changeset	1191 };
54bffdddc0ef final patches from Neil Schemenauer for garbage collection Jeremy Hylton <jeremy@alum.mit.edu> parents: diff changeset	1192
30311 f003e48f562d Bug #794140: cygwin builds do not embed Jason Tishler <jason@tishler.net> parents: 28651 diff changeset	1193 PyMODINIT_FUNC
13183 54bffdddc0ef final patches from Neil Schemenauer for garbage collection Jeremy Hylton <jeremy@alum.mit.edu> parents: diff changeset	1194 initgc(void)
54bffdddc0ef final patches from Neil Schemenauer for garbage collection Jeremy Hylton <jeremy@alum.mit.edu> parents: diff changeset	1195 {
54bffdddc0ef final patches from Neil Schemenauer for garbage collection Jeremy Hylton <jeremy@alum.mit.edu> parents: diff changeset	1196 PyObject *m;
54bffdddc0ef final patches from Neil Schemenauer for garbage collection Jeremy Hylton <jeremy@alum.mit.edu> parents: diff changeset	1197
54bffdddc0ef final patches from Neil Schemenauer for garbage collection Jeremy Hylton <jeremy@alum.mit.edu> parents: diff changeset	1198 m = Py_InitModule4("gc",
54bffdddc0ef final patches from Neil Schemenauer for garbage collection Jeremy Hylton <jeremy@alum.mit.edu> parents: diff changeset	1199 GcMethods,
54bffdddc0ef final patches from Neil Schemenauer for garbage collection Jeremy Hylton <jeremy@alum.mit.edu> parents: diff changeset	1200 gc__doc__,
54bffdddc0ef final patches from Neil Schemenauer for garbage collection Jeremy Hylton <jeremy@alum.mit.edu> parents: diff changeset	1201 NULL,
54bffdddc0ef final patches from Neil Schemenauer for garbage collection Jeremy Hylton <jeremy@alum.mit.edu> parents: diff changeset	1202 PYTHON_API_VERSION);
36324 1af7f719ed28 Check return result from Py_InitModule(). This API can fail. Neal Norwitz <nnorwitz@gmail.com>* parents: 35298 diff changeset	1203 if (m == NULL)
1af7f719ed28 Check return result from Py_InitModule(). This API can fail. Neal Norwitz <nnorwitz@gmail.com>* parents: 35298 diff changeset	1204 return;
28516 78f846fb570a initgc(): Rewrote to use the PyModule_AddXYZ API; cuts code size. Tim Peters <tim.peters@gmail.com> parents: 28515 diff changeset	1205
13183 54bffdddc0ef final patches from Neil Schemenauer for garbage collection Jeremy Hylton <jeremy@alum.mit.edu> parents: diff changeset	1206 if (garbage == NULL) {
54bffdddc0ef final patches from Neil Schemenauer for garbage collection Jeremy Hylton <jeremy@alum.mit.edu> parents: diff changeset	1207 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	1208 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	1209 return;
13183 54bffdddc0ef final patches from Neil Schemenauer for garbage collection Jeremy Hylton <jeremy@alum.mit.edu> parents: diff changeset	1210 }
35103 234b22a2acf3 Add missing INCREF. Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 33876 diff changeset	1211 Py_INCREF(garbage);
28516 78f846fb570a initgc(): Rewrote to use the PyModule_AddXYZ API; cuts code size. Tim Peters <tim.peters@gmail.com> parents: 28515 diff changeset	1212 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	1213 return;
78f846fb570a initgc(): Rewrote to use the PyModule_AddXYZ API; cuts code size. Tim Peters <tim.peters@gmail.com> parents: 28515 diff changeset	1214 #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	1215 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	1216 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	1217 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	1218 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	1219 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	1220 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	1221 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	1222 #undef ADD_INT
13183 54bffdddc0ef final patches from Neil Schemenauer for garbage collection Jeremy Hylton <jeremy@alum.mit.edu> parents: diff changeset	1223 }
54bffdddc0ef final patches from Neil Schemenauer for garbage collection Jeremy Hylton <jeremy@alum.mit.edu> parents: diff changeset	1224
28651 7fda09f751ad - New C API PyGC_Collect(), same as calling gc.collect(). Guido van Rossum <guido@python.org> parents: 28523 diff changeset	1225 /* API to invoke gc.collect() from C */
36839 7c1aca8e3d7d Make PyGC_Collect() use Py_ssize_t. Neal Norwitz <nnorwitz@gmail.com> parents: 36769 diff changeset	1226 Py_ssize_t
28651 7fda09f751ad - New C API PyGC_Collect(), same as calling gc.collect(). Guido van Rossum <guido@python.org> parents: 28523 diff changeset	1227 PyGC_Collect(void)
7fda09f751ad - New C API PyGC_Collect(), same as calling gc.collect(). Guido van Rossum <guido@python.org> parents: 28523 diff changeset	1228 {
36839 7c1aca8e3d7d Make PyGC_Collect() use Py_ssize_t. Neal Norwitz <nnorwitz@gmail.com> parents: 36769 diff changeset	1229 Py_ssize_t n;
28651 7fda09f751ad - New C API PyGC_Collect(), same as calling gc.collect(). Guido van Rossum <guido@python.org> parents: 28523 diff changeset	1230
7fda09f751ad - New C API PyGC_Collect(), same as calling gc.collect(). Guido van Rossum <guido@python.org> parents: 28523 diff changeset	1231 if (collecting)
7fda09f751ad - New C API PyGC_Collect(), same as calling gc.collect(). Guido van Rossum <guido@python.org> parents: 28523 diff changeset	1232 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	1233 else {
7fda09f751ad - New C API PyGC_Collect(), same as calling gc.collect(). Guido van Rossum <guido@python.org> parents: 28523 diff changeset	1234 collecting = 1;
7fda09f751ad - New C API PyGC_Collect(), same as calling gc.collect(). Guido van Rossum <guido@python.org> parents: 28523 diff changeset	1235 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	1236 collecting = 0;
7fda09f751ad - New C API PyGC_Collect(), same as calling gc.collect(). Guido van Rossum <guido@python.org> parents: 28523 diff changeset	1237 }
7fda09f751ad - New C API PyGC_Collect(), same as calling gc.collect(). Guido van Rossum <guido@python.org> parents: 28523 diff changeset	1238
7fda09f751ad - New C API PyGC_Collect(), same as calling gc.collect(). Guido van Rossum <guido@python.org> parents: 28523 diff changeset	1239 return n;
7fda09f751ad - New C API PyGC_Collect(), same as calling gc.collect(). Guido van Rossum <guido@python.org> parents: 28523 diff changeset	1240 }
7fda09f751ad - New C API PyGC_Collect(), same as calling gc.collect(). Guido van Rossum <guido@python.org> parents: 28523 diff changeset	1241
19585 c43d7a8f00a4 Make more things internal to this file. Remove Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 19128 diff changeset	1242 /* for debugging */
28651 7fda09f751ad - New C API PyGC_Collect(), same as calling gc.collect(). Guido van Rossum <guido@python.org> parents: 28523 diff changeset	1243 void
7fda09f751ad - New C API PyGC_Collect(), same as calling gc.collect(). Guido van Rossum <guido@python.org> parents: 28523 diff changeset	1244 _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	1245 {
c43d7a8f00a4 Make more things internal to this file. Remove Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 19128 diff changeset	1246 _PyObject_Dump(FROM_GC(g));
c43d7a8f00a4 Make more things internal to this file. Remove Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 19128 diff changeset	1247 }
c43d7a8f00a4 Make more things internal to this file. Remove Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 19128 diff changeset	1248
c43d7a8f00a4 Make more things internal to this file. Remove Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 19128 diff changeset	1249 /* 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	1250 functions must always be available */
c43d7a8f00a4 Make more things internal to this file. Remove Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 19128 diff changeset	1251
22972 95819f7f0bcd Allow PyObject_Del to be used as a function designator. Provide binary Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 22648 diff changeset	1252 #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	1253 #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	1254 #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	1255 #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	1256
19585 c43d7a8f00a4 Make more things internal to this file. Remove Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 19128 diff changeset	1257 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	1258 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	1259 {
c43d7a8f00a4 Make more things internal to this file. Remove Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 19128 diff changeset	1260 _PyObject_GC_TRACK(op);
c43d7a8f00a4 Make more things internal to this file. Remove Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 19128 diff changeset	1261 }
c43d7a8f00a4 Make more things internal to this file. Remove Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 19128 diff changeset	1262
22972 95819f7f0bcd Allow PyObject_Del to be used as a function designator. Provide binary Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 22648 diff changeset	1263 /* 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	1264 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	1265 _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	1266 {
95819f7f0bcd Allow PyObject_Del to be used as a function designator. Provide binary Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 22648 diff changeset	1267 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	1268 }
95819f7f0bcd Allow PyObject_Del to be used as a function designator. Provide binary Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 22648 diff changeset	1269
95819f7f0bcd Allow PyObject_Del to be used as a function designator. Provide binary Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 22648 diff changeset	1270 void
95819f7f0bcd Allow PyObject_Del to be used as a function designator. Provide binary Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 22648 diff changeset	1271 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	1272 {
24122 d332484e394a Trashcan cleanup: Now that cyclic gc is always there, the trashcan Tim Peters <tim.peters@gmail.com> parents: 24121 diff changeset	1273 /* 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	1274 * 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	1275 */
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	1276 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	1277 _PyObject_GC_UNTRACK(op);
19585 c43d7a8f00a4 Make more things internal to this file. Remove Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 19128 diff changeset	1278 }
c43d7a8f00a4 Make more things internal to this file. Remove Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 19128 diff changeset	1279
22972 95819f7f0bcd Allow PyObject_Del to be used as a function designator. Provide binary Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 22648 diff changeset	1280 /* 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	1281 void
95819f7f0bcd Allow PyObject_Del to be used as a function designator. Provide binary Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 22648 diff changeset	1282 _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	1283 {
95819f7f0bcd Allow PyObject_Del to be used as a function designator. Provide binary Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 22648 diff changeset	1284 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	1285 }
95819f7f0bcd Allow PyObject_Del to be used as a function designator. Provide binary Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 22648 diff changeset	1286
19585 c43d7a8f00a4 Make more things internal to this file. Remove Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 19128 diff changeset	1287 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	1288 _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	1289 {
c43d7a8f00a4 Make more things internal to this file. Remove Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 19128 diff changeset	1290 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	1291 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	1292 if (g == NULL)
23721 48e937e1b3fe Remove casts to PyObject * when declaration is for PyObject * Jeremy Hylton <jeremy@alum.mit.edu> parents: 23495 diff changeset	1293 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	1294 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	1295 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	1296 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	1297 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	1298 generations[0].threshold &&
19585 c43d7a8f00a4 Make more things internal to this file. Remove Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 19128 diff changeset	1299 !collecting &&
c43d7a8f00a4 Make more things internal to this file. Remove Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 19128 diff changeset	1300 !PyErr_Occurred()) {
c43d7a8f00a4 Make more things internal to this file. Remove Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 19128 diff changeset	1301 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	1302 collect_generations();
19585 c43d7a8f00a4 Make more things internal to this file. Remove Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 19128 diff changeset	1303 collecting = 0;
c43d7a8f00a4 Make more things internal to this file. Remove Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 19128 diff changeset	1304 }
c43d7a8f00a4 Make more things internal to this file. Remove Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 19128 diff changeset	1305 op = FROM_GC(g);
c43d7a8f00a4 Make more things internal to this file. Remove Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 19128 diff changeset	1306 return op;
c43d7a8f00a4 Make more things internal to this file. Remove Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 19128 diff changeset	1307 }
c43d7a8f00a4 Make more things internal to this file. Remove Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 19128 diff changeset	1308
c43d7a8f00a4 Make more things internal to this file. Remove Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 19128 diff changeset	1309 PyObject *
c43d7a8f00a4 Make more things internal to this file. Remove Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 19128 diff changeset	1310 _PyObject_GC_New(PyTypeObject *tp)
c43d7a8f00a4 Make more things internal to this file. Remove Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 19128 diff changeset	1311 {
22972 95819f7f0bcd Allow PyObject_Del to be used as a function designator. Provide binary Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 22648 diff changeset	1312 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	1313 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	1314 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	1315 return op;
19585 c43d7a8f00a4 Make more things internal to this file. Remove Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 19128 diff changeset	1316 }
c43d7a8f00a4 Make more things internal to this file. Remove Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 19128 diff changeset	1317
c43d7a8f00a4 Make more things internal to this file. Remove Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 19128 diff changeset	1318 PyVarObject *
36501 7fdc639bc5b4 Merge ssize_t branch. Martin v. Löwis <martin@v.loewis.de> parents: 36324 diff changeset	1319 _PyObject_GC_NewVar(PyTypeObject *tp, Py_ssize_t nitems)
19585 c43d7a8f00a4 Make more things internal to this file. Remove Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 19128 diff changeset	1320 {
22972 95819f7f0bcd Allow PyObject_Del to be used as a function designator. Provide binary Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 22648 diff changeset	1321 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	1322 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	1323 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	1324 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	1325 return op;
19585 c43d7a8f00a4 Make more things internal to this file. Remove Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 19128 diff changeset	1326 }
c43d7a8f00a4 Make more things internal to this file. Remove Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 19128 diff changeset	1327
c43d7a8f00a4 Make more things internal to this file. Remove Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 19128 diff changeset	1328 PyVarObject *
36524 4c8606191c0c Change _PyObject_GC_Resize to expect Py_ssize_t. Martin v. Löwis <martin@v.loewis.de> parents: 36501 diff changeset	1329 _PyObject_GC_Resize(PyVarObject *op, Py_ssize_t nitems)
19585 c43d7a8f00a4 Make more things internal to this file. Remove Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 19128 diff changeset	1330 {
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	1331 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	1332 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	1333 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	1334 if (g == NULL)
c43d7a8f00a4 Make more things internal to this file. Remove Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 19128 diff changeset	1335 return (PyVarObject *)PyErr_NoMemory();
c43d7a8f00a4 Make more things internal to this file. Remove Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 19128 diff changeset	1336 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	1337 op->ob_size = nitems;
19585 c43d7a8f00a4 Make more things internal to this file. Remove Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 19128 diff changeset	1338 return op;
c43d7a8f00a4 Make more things internal to this file. Remove Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 19128 diff changeset	1339 }
c43d7a8f00a4 Make more things internal to this file. Remove Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 19128 diff changeset	1340
c43d7a8f00a4 Make more things internal to this file. Remove Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 19128 diff changeset	1341 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	1342 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	1343 {
c43d7a8f00a4 Make more things internal to this file. Remove Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 19128 diff changeset	1344 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	1345 if (IS_TRACKED(op))
19585 c43d7a8f00a4 Make more things internal to this file. Remove Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 19128 diff changeset	1346 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	1347 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	1348 generations[0].count--;
19585 c43d7a8f00a4 Make more things internal to this file. Remove Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 19128 diff changeset	1349 }
22972 95819f7f0bcd Allow PyObject_Del to be used as a function designator. Provide binary Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 22648 diff changeset	1350 PyObject_FREE(g);
19585 c43d7a8f00a4 Make more things internal to this file. Remove Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 19128 diff changeset	1351 }
c43d7a8f00a4 Make more things internal to this file. Remove Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 19128 diff changeset	1352
22972 95819f7f0bcd Allow PyObject_Del to be used as a function designator. Provide binary Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 22648 diff changeset	1353 /* 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	1354 #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	1355 void
95819f7f0bcd Allow PyObject_Del to be used as a function designator. Provide binary Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 22648 diff changeset	1356 _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	1357 {
95819f7f0bcd Allow PyObject_Del to be used as a function designator. Provide binary Neil Schemenauer <nascheme@enme.ucalgary.ca> parents: 22648 diff changeset	1358 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	1359 }

Mercurial > cpython-lru_cache-weakref

annotate Modules/gcmodule.c @ 37850:ebe59cd18273