Back to index

python3.2  3.2.2
Classes | Defines | Functions | Variables
gcmodule.c File Reference
#include "Python.h"
#include "frameobject.h"

Go to the source code of this file.

Classes

struct  gc_generation

Defines

#define AS_GC(o)   ((PyGC_Head *)(o)-1)
#define FROM_GC(g)   ((PyObject *)(((PyGC_Head *)g)+1))
#define NUM_GENERATIONS   3
#define GEN_HEAD(n)   (&generations[n].head)
#define DEBUG_STATS   (1<<0) /* print collection statistics */
#define DEBUG_COLLECTABLE   (1<<1) /* print collectable objects */
#define DEBUG_UNCOLLECTABLE   (1<<2) /* print uncollectable objects */
#define DEBUG_SAVEALL   (1<<5) /* save all garbage in gc.garbage */
#define DEBUG_LEAK
#define GC_UNTRACKED   _PyGC_REFS_UNTRACKED
#define GC_REACHABLE   _PyGC_REFS_REACHABLE
#define GC_TENTATIVELY_UNREACHABLE   _PyGC_REFS_TENTATIVELY_UNREACHABLE
#define IS_TRACKED(o)   ((AS_GC(o))->gc.gc_refs != GC_UNTRACKED)
#define IS_REACHABLE(o)   ((AS_GC(o))->gc.gc_refs == GC_REACHABLE)
#define IS_TENTATIVELY_UNREACHABLE(o)
#define ADD_INT(NAME)   if (PyModule_AddIntConstant(m, #NAME, NAME) < 0) return NULL

Functions

static void gc_list_init (PyGC_Head *list)
static int gc_list_is_empty (PyGC_Head *list)
static void gc_list_remove (PyGC_Head *node)
static void gc_list_move (PyGC_Head *node, PyGC_Head *list)
static void gc_list_merge (PyGC_Head *from, PyGC_Head *to)
static Py_ssize_t gc_list_size (PyGC_Head *list)
static int append_objects (PyObject *py_list, PyGC_Head *gc_list)
static void update_refs (PyGC_Head *containers)
static int visit_decref (PyObject *op, void *data)
static void subtract_refs (PyGC_Head *containers)
static int visit_reachable (PyObject *op, PyGC_Head *reachable)
static void move_unreachable (PyGC_Head *young, PyGC_Head *unreachable)
static int has_finalizer (PyObject *op)
static void move_finalizers (PyGC_Head *unreachable, PyGC_Head *finalizers)
static int visit_move (PyObject *op, PyGC_Head *tolist)
static void move_finalizer_reachable (PyGC_Head *finalizers)
static int handle_weakrefs (PyGC_Head *unreachable, PyGC_Head *old)
static void debug_cycle (char *msg, PyObject *op)
static int handle_finalizers (PyGC_Head *finalizers, PyGC_Head *old)
static void delete_garbage (PyGC_Head *collectable, PyGC_Head *old)
static void clear_freelists (void)
static double get_time (void)
static Py_ssize_t collect (int generation)
static Py_ssize_t collect_generations (void)
 PyDoc_STRVAR (gc_enable__doc__,"enable() -> None\n""\n""Enable automatic garbage collection.\n")
static PyObjectgc_enable (PyObject *self, PyObject *noargs)
 PyDoc_STRVAR (gc_disable__doc__,"disable() -> None\n""\n""Disable automatic garbage collection.\n")
static PyObjectgc_disable (PyObject *self, PyObject *noargs)
 PyDoc_STRVAR (gc_isenabled__doc__,"isenabled() -> status\n""\n""Returns true if automatic garbage collection is enabled.\n")
static PyObjectgc_isenabled (PyObject *self, PyObject *noargs)
 PyDoc_STRVAR (gc_collect__doc__,"collect([generation]) -> n\n""\n""With no arguments, run a full collection. The optional argument\n""may be an integer specifying which generation to collect. A ValueError\n""is raised if the generation number is invalid.\n\n""The number of unreachable objects is returned.\n")
static PyObjectgc_collect (PyObject *self, PyObject *args, PyObject *kws)
 PyDoc_STRVAR (gc_set_debug__doc__,"set_debug(flags) -> None\n""\n""Set the garbage collection debugging flags. Debugging information is\n""written to sys.stderr.\n""\n""flags is an integer and can have the following bits turned on:\n""\n"" DEBUG_STATS - Print statistics during collection.\n"" DEBUG_COLLECTABLE - Print collectable objects found.\n"" DEBUG_UNCOLLECTABLE - Print unreachable but uncollectable objects found.\n"" DEBUG_SAVEALL - Save objects to gc.garbage rather than freeing them.\n"" DEBUG_LEAK - Debug leaking programs (everything but STATS).\n")
static PyObjectgc_set_debug (PyObject *self, PyObject *args)
 PyDoc_STRVAR (gc_get_debug__doc__,"get_debug() -> flags\n""\n""Get the garbage collection debugging flags.\n")
static PyObjectgc_get_debug (PyObject *self, PyObject *noargs)
 PyDoc_STRVAR (gc_set_thresh__doc__,"set_threshold(threshold0, [threshold1, threshold2]) -> None\n""\n""Sets the collection thresholds. Setting threshold0 to zero disables\n""collection.\n")
static PyObjectgc_set_thresh (PyObject *self, PyObject *args)
 PyDoc_STRVAR (gc_get_thresh__doc__,"get_threshold() -> (threshold0, threshold1, threshold2)\n""\n""Return the current collection thresholds\n")
static PyObjectgc_get_thresh (PyObject *self, PyObject *noargs)
 PyDoc_STRVAR (gc_get_count__doc__,"get_count() -> (count0, count1, count2)\n""\n""Return the current collection counts\n")
static PyObjectgc_get_count (PyObject *self, PyObject *noargs)
static int referrersvisit (PyObject *obj, PyObject *objs)
static int gc_referrers_for (PyObject *objs, PyGC_Head *list, PyObject *resultlist)
 PyDoc_STRVAR (gc_get_referrers__doc__,"get_referrers(*objs) -> list\n\ Return the list of objects that directly refer to any of objs.")
static PyObjectgc_get_referrers (PyObject *self, PyObject *args)
static int referentsvisit (PyObject *obj, PyObject *list)
 PyDoc_STRVAR (gc_get_referents__doc__,"get_referents(*objs) -> list\n\ Return the list of objects that are directly referred to by objs.")
static PyObjectgc_get_referents (PyObject *self, PyObject *args)
 PyDoc_STRVAR (gc_get_objects__doc__,"get_objects() -> [...]\n""\n""Return a list of objects tracked by the collector (excluding the list\n""returned).\n")
static PyObjectgc_get_objects (PyObject *self, PyObject *noargs)
 PyDoc_STRVAR (gc_is_tracked__doc__,"is_tracked(obj) -> bool\n""\n""Returns true if the object is tracked by the garbage collector.\n""Simple atomic objects will return false.\n")
static PyObjectgc_is_tracked (PyObject *self, PyObject *obj)
 PyDoc_STRVAR (gc__doc__,"This module provides access to the garbage collector for reference cycles.\n""\n""enable() -- Enable automatic garbage collection.\n""disable() -- Disable automatic garbage collection.\n""isenabled() -- Returns true if automatic collection is enabled.\n""collect() -- Do a full collection right now.\n""get_count() -- Return the current collection counts.\n""set_debug() -- Set debugging flags.\n""get_debug() -- Get debugging flags.\n""set_threshold() -- Set the collection thresholds.\n""get_threshold() -- Return the current the collection thresholds.\n""get_objects() -- Return a list of all objects tracked by the collector.\n""is_tracked() -- Returns true if a given object is tracked.\n""get_referrers() -- Return the list of objects that refer to an object.\n""get_referents() -- Return the list of objects that an object refers to.\n")
PyMODINIT_FUNC PyInit_gc (void)
Py_ssize_t PyGC_Collect (void)
void _PyGC_Fini (void)
void _PyGC_Dump (PyGC_Head *g)
void PyObject_GC_Track (void *op)
void _PyObject_GC_Track (PyObject *op)
void PyObject_GC_UnTrack (void *op)
void _PyObject_GC_UnTrack (PyObject *op)
PyObject_PyObject_GC_Malloc (size_t basicsize)
PyObject_PyObject_GC_New (PyTypeObject *tp)
PyVarObject_PyObject_GC_NewVar (PyTypeObject *tp, Py_ssize_t nitems)
PyVarObject_PyObject_GC_Resize (PyVarObject *op, Py_ssize_t nitems)
void PyObject_GC_Del (void *op)

Variables

static struct gc_generation [NUM_GENERATIONS]
PyGC_Head_PyGC_generation0 = GEN_HEAD(0)
static int enabled = 1
static int collecting = 0
static PyObjectgarbage = NULL
static PyObjectgc_str = NULL
static PyObjectdelstr = NULL
static Py_ssize_t long_lived_total = 0
static Py_ssize_t long_lived_pending = 0
static int debug
static PyObjecttmod = NULL
static PyMethodDef GcMethods []
static struct PyModuleDef

Class Documentation

struct gc_generation

Definition at line 37 of file gcmodule.c.

Collaboration diagram for gc_generation:
Class Members
int count
PyGC_Head head
int threshold

Define Documentation

#define ADD_INT (   NAME)    if (PyModule_AddIntConstant(m, #NAME, NAME) < 0) return NULL
#define AS_GC (   o)    ((PyGC_Head *)(o)-1)

Definition at line 30 of file gcmodule.c.

#define DEBUG_COLLECTABLE   (1<<1) /* print collectable objects */

Definition at line 122 of file gcmodule.c.

#define DEBUG_LEAK
Value:
DEBUG_COLLECTABLE | \
                DEBUG_UNCOLLECTABLE | \
                DEBUG_SAVEALL

Definition at line 125 of file gcmodule.c.

#define DEBUG_SAVEALL   (1<<5) /* save all garbage in gc.garbage */

Definition at line 124 of file gcmodule.c.

#define DEBUG_STATS   (1<<0) /* print collection statistics */

Definition at line 121 of file gcmodule.c.

#define DEBUG_UNCOLLECTABLE   (1<<2) /* print uncollectable objects */

Definition at line 123 of file gcmodule.c.

#define FROM_GC (   g)    ((PyObject *)(((PyGC_Head *)g)+1))

Definition at line 33 of file gcmodule.c.

Definition at line 171 of file gcmodule.c.

Definition at line 172 of file gcmodule.c.

Definition at line 170 of file gcmodule.c.

#define GEN_HEAD (   n)    (&generations[n].head)

Definition at line 45 of file gcmodule.c.

#define IS_REACHABLE (   o)    ((AS_GC(o))->gc.gc_refs == GC_REACHABLE)

Definition at line 175 of file gcmodule.c.

Value:
( \
    (AS_GC(o))->gc.gc_refs == GC_TENTATIVELY_UNREACHABLE)

Definition at line 176 of file gcmodule.c.

#define IS_TRACKED (   o)    ((AS_GC(o))->gc.gc_refs != GC_UNTRACKED)

Definition at line 174 of file gcmodule.c.

#define NUM_GENERATIONS   3

Definition at line 44 of file gcmodule.c.


Function Documentation

Definition at line 1400 of file gcmodule.c.

Here is the call graph for this function:

Definition at line 1367 of file gcmodule.c.

{
    if (!(debug & DEBUG_SAVEALL)
        && garbage != NULL && PyList_GET_SIZE(garbage) > 0) {
        char *message;
        if (debug & DEBUG_UNCOLLECTABLE)
            message = "gc: %zd uncollectable objects at " \
                "shutdown";
        else
            message = "gc: %zd uncollectable objects at " \
                "shutdown; use gc.set_debug(gc.DEBUG_UNCOLLECTABLE) to list them";
        if (PyErr_WarnFormat(PyExc_ResourceWarning, 0, message,
                             PyList_GET_SIZE(garbage)) < 0)
            PyErr_WriteUnraisable(NULL);
        if (debug & DEBUG_UNCOLLECTABLE) {
            PyObject *repr = NULL, *bytes = NULL;
            repr = PyObject_Repr(garbage);
            if (!repr || !(bytes = PyUnicode_EncodeFSDefault(repr)))
                PyErr_WriteUnraisable(garbage);
            else {
                PySys_WriteStderr(
                    "    %s\n",
                    PyBytes_AS_STRING(bytes)
                    );
            }
            Py_XDECREF(repr);
            Py_XDECREF(bytes);
        }
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

Definition at line 1444 of file gcmodule.c.

{
    PyObject *op;
    PyGC_Head *g;
    if (basicsize > PY_SSIZE_T_MAX - sizeof(PyGC_Head))
        return PyErr_NoMemory();
    g = (PyGC_Head *)PyObject_MALLOC(
        sizeof(PyGC_Head) + basicsize);
    if (g == NULL)
        return PyErr_NoMemory();
    g->gc.gc_refs = GC_UNTRACKED;
    generations[0].count++; /* number of allocated GC objects */
    if (generations[0].count > generations[0].threshold &&
        enabled &&
        generations[0].threshold &&
        !collecting &&
        !PyErr_Occurred()) {
        collecting = 1;
        collect_generations();
        collecting = 0;
    }
    op = FROM_GC(g);
    return op;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Definition at line 1470 of file gcmodule.c.

{
    PyObject *op = _PyObject_GC_Malloc(_PyObject_SIZE(tp));
    if (op != NULL)
        op = PyObject_INIT(op, tp);
    return op;
}

Here is the call graph for this function:

Definition at line 1479 of file gcmodule.c.

{
    const size_t size = _PyObject_VAR_SIZE(tp, nitems);
    PyVarObject *op = (PyVarObject *) _PyObject_GC_Malloc(size);
    if (op != NULL)
        op = PyObject_INIT_VAR(op, tp, nitems);
    return op;
}

Here is the call graph for this function:

Definition at line 1489 of file gcmodule.c.

{
    const size_t basicsize = _PyObject_VAR_SIZE(Py_TYPE(op), nitems);
    PyGC_Head *g = AS_GC(op);
    if (basicsize > PY_SSIZE_T_MAX - sizeof(PyGC_Head))
        return (PyVarObject *)PyErr_NoMemory();
    g = (PyGC_Head *)PyObject_REALLOC(g,  sizeof(PyGC_Head) + basicsize);
    if (g == NULL)
        return (PyVarObject *)PyErr_NoMemory();
    op = (PyVarObject *) FROM_GC(g);
    Py_SIZE(op) = nitems;
    return op;
}

Here is the call graph for this function:

Definition at line 1421 of file gcmodule.c.

Here is the call graph for this function:

Definition at line 1438 of file gcmodule.c.

Here is the call graph for this function:

static int append_objects ( PyObject py_list,
PyGC_Head gc_list 
) [static]

Definition at line 266 of file gcmodule.c.

{
    PyGC_Head *gc;
    for (gc = gc_list->gc.gc_next; gc != gc_list; gc = gc->gc.gc_next) {
        PyObject *op = FROM_GC(gc);
        if (op != py_list) {
            if (PyList_Append(py_list, op)) {
                return -1; /* exception */
            }
        }
    }
    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void clear_freelists ( void  ) [static]

Definition at line 757 of file gcmodule.c.

Here is the call graph for this function:

Here is the caller graph for this function:

static Py_ssize_t collect ( int  generation) [static]

Definition at line 788 of file gcmodule.c.

{
    int i;
    Py_ssize_t m = 0; /* # objects collected */
    Py_ssize_t n = 0; /* # unreachable objects that couldn't be collected */
    PyGC_Head *young; /* the generation we are examining */
    PyGC_Head *old; /* next older generation */
    PyGC_Head unreachable; /* non-problematic unreachable trash */
    PyGC_Head finalizers;  /* objects with, & reachable from, __del__ */
    PyGC_Head *gc;
    double t1 = 0.0;

    if (delstr == NULL) {
        delstr = PyUnicode_InternFromString("__del__");
        if (delstr == NULL)
            Py_FatalError("gc couldn't allocate \"__del__\"");
    }

    if (debug & DEBUG_STATS) {
        PySys_WriteStderr("gc: collecting generation %d...\n",
                          generation);
        PySys_WriteStderr("gc: objects in each generation:");
        for (i = 0; i < NUM_GENERATIONS; i++)
            PySys_WriteStderr(" %" PY_FORMAT_SIZE_T "d",
                              gc_list_size(GEN_HEAD(i)));
        t1 = get_time();
        PySys_WriteStderr("\n");
    }

    /* update collection and allocation counters */
    if (generation+1 < NUM_GENERATIONS)
        generations[generation+1].count += 1;
    for (i = 0; i <= generation; i++)
        generations[i].count = 0;

    /* merge younger generations with one we are currently collecting */
    for (i = 0; i < generation; i++) {
        gc_list_merge(GEN_HEAD(i), GEN_HEAD(generation));
    }

    /* handy references */
    young = GEN_HEAD(generation);
    if (generation < NUM_GENERATIONS-1)
        old = GEN_HEAD(generation+1);
    else
        old = young;

    /* Using ob_refcnt and gc_refs, calculate which objects in the
     * container set are reachable from outside the set (i.e., have a
     * refcount greater than 0 when all the references within the
     * set are taken into account).
     */
    update_refs(young);
    subtract_refs(young);

    /* Leave everything reachable from outside young in young, and move
     * everything else (in young) to unreachable.
     * NOTE:  This used to move the reachable objects into a reachable
     * set instead.  But most things usually turn out to be reachable,
     * so it's more efficient to move the unreachable things.
     */
    gc_list_init(&unreachable);
    move_unreachable(young, &unreachable);

    /* Move reachable objects to next generation. */
    if (young != old) {
        if (generation == NUM_GENERATIONS - 2) {
            long_lived_pending += gc_list_size(young);
        }
        gc_list_merge(young, old);
    }
    else {
        long_lived_pending = 0;
        long_lived_total = gc_list_size(young);
    }

    /* All objects in unreachable are trash, but objects reachable from
     * finalizers can't safely be deleted.  Python programmers should take
     * care not to create such things.  For Python, finalizers means
     * instance objects with __del__ methods.  Weakrefs with callbacks
     * can also call arbitrary Python code but they will be dealt with by
     * handle_weakrefs().
     */
    gc_list_init(&finalizers);
    move_finalizers(&unreachable, &finalizers);
    /* finalizers contains the unreachable objects with a finalizer;
     * unreachable objects reachable *from* those are also uncollectable,
     * and we move those into the finalizers list too.
     */
    move_finalizer_reachable(&finalizers);

    /* Collect statistics on collectable objects found and print
     * debugging information.
     */
    for (gc = unreachable.gc.gc_next; gc != &unreachable;
                    gc = gc->gc.gc_next) {
        m++;
        if (debug & DEBUG_COLLECTABLE) {
            debug_cycle("collectable", FROM_GC(gc));
        }
    }

    /* Clear weakrefs and invoke callbacks as necessary. */
    m += handle_weakrefs(&unreachable, old);

    /* Call tp_clear on objects in the unreachable set.  This will cause
     * the reference cycles to be broken.  It may also cause some objects
     * in finalizers to be freed.
     */
    delete_garbage(&unreachable, old);

    /* Collect statistics on uncollectable objects found and print
     * debugging information. */
    for (gc = finalizers.gc.gc_next;
         gc != &finalizers;
         gc = gc->gc.gc_next) {
        n++;
        if (debug & DEBUG_UNCOLLECTABLE)
            debug_cycle("uncollectable", FROM_GC(gc));
    }
    if (debug & DEBUG_STATS) {
        double t2 = get_time();
        if (m == 0 && n == 0)
            PySys_WriteStderr("gc: done");
        else
            PySys_WriteStderr(
                "gc: done, "
                "%" PY_FORMAT_SIZE_T "d unreachable, "
                "%" PY_FORMAT_SIZE_T "d uncollectable",
                n+m, n);
        if (t1 && t2) {
            PySys_WriteStderr(", %.4fs elapsed", t2-t1);
        }
        PySys_WriteStderr(".\n");
    }

    /* Append instances in the uncollectable set to a Python
     * reachable list of garbage.  The programmer has to deal with
     * this if they insist on creating this type of structure.
     */
    (void)handle_finalizers(&finalizers, old);

    /* Clear free list only during the collection of the highest
     * generation */
    if (generation == NUM_GENERATIONS-1) {
        clear_freelists();
    }

    if (PyErr_Occurred()) {
        if (gc_str == NULL)
            gc_str = PyUnicode_FromString("garbage collection");
        PyErr_WriteUnraisable(gc_str);
        Py_FatalError("unexpected exception during garbage collection");
    }
    return n+m;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static Py_ssize_t collect_generations ( void  ) [static]

Definition at line 946 of file gcmodule.c.

{
    int i;
    Py_ssize_t n = 0;

    /* Find the oldest generation (highest numbered) where the count
     * exceeds the threshold.  Objects in the that generation and
     * generations younger than it will be collected. */
    for (i = NUM_GENERATIONS-1; i >= 0; i--) {
        if (generations[i].count > generations[i].threshold) {
            /* Avoid quadratic performance degradation in number
               of tracked objects. See comments at the beginning
               of this file, and issue #4074.
            */
            if (i == NUM_GENERATIONS - 1
                && long_lived_pending < long_lived_total / 4)
                continue;
            n = collect(i);
            break;
        }
    }
    return n;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void debug_cycle ( char *  msg,
PyObject op 
) [static]

Definition at line 681 of file gcmodule.c.

{
    PySys_WriteStderr("gc: %.100s <%.100s %p>\n",
                      msg, Py_TYPE(op)->tp_name, op);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void delete_garbage ( PyGC_Head collectable,
PyGC_Head old 
) [static]

Definition at line 724 of file gcmodule.c.

{
    inquiry clear;

    while (!gc_list_is_empty(collectable)) {
        PyGC_Head *gc = collectable->gc.gc_next;
        PyObject *op = FROM_GC(gc);

        assert(IS_TENTATIVELY_UNREACHABLE(op));
        if (debug & DEBUG_SAVEALL) {
            PyList_Append(garbage, op);
        }
        else {
            if ((clear = Py_TYPE(op)->tp_clear) != NULL) {
                Py_INCREF(op);
                clear(op);
                Py_DECREF(op);
            }
        }
        if (collectable->gc.gc_next == gc) {
            /* object is still alive, move it, it may die later */
            gc_list_move(gc, old);
            gc->gc.gc_refs = GC_REACHABLE;
        }
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

static PyObject* gc_collect ( PyObject self,
PyObject args,
PyObject kws 
) [static]

Definition at line 1016 of file gcmodule.c.

{
    static char *keywords[] = {"generation", NULL};
    int genarg = NUM_GENERATIONS - 1;
    Py_ssize_t n;

    if (!PyArg_ParseTupleAndKeywords(args, kws, "|i", keywords, &genarg))
        return NULL;

    else if (genarg < 0 || genarg >= NUM_GENERATIONS) {
        PyErr_SetString(PyExc_ValueError, "invalid generation");
        return NULL;
    }

    if (collecting)
        n = 0; /* already collecting, don't do anything */
    else {
        collecting = 1;
        n = collect(genarg);
        collecting = 0;
    }

    return PyLong_FromSsize_t(n);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static PyObject* gc_disable ( PyObject self,
PyObject noargs 
) [static]

Definition at line 989 of file gcmodule.c.

{
    enabled = 0;
    Py_INCREF(Py_None);
    return Py_None;
}
static PyObject* gc_enable ( PyObject self,
PyObject noargs 
) [static]

Definition at line 976 of file gcmodule.c.

{
    enabled = 1;
    Py_INCREF(Py_None);
    return Py_None;
}
static PyObject* gc_get_count ( PyObject self,
PyObject noargs 
) [static]

Definition at line 1120 of file gcmodule.c.

{
    return Py_BuildValue("(iii)",
                         generations[0].count,
                         generations[1].count,
                         generations[2].count);
}

Here is the call graph for this function:

static PyObject* gc_get_debug ( PyObject self,
PyObject noargs 
) [static]

Definition at line 1071 of file gcmodule.c.

{
    return Py_BuildValue("i", debug);
}

Here is the call graph for this function:

static PyObject* gc_get_objects ( PyObject self,
PyObject noargs 
) [static]

Definition at line 1221 of file gcmodule.c.

{
    int i;
    PyObject* result;

    result = PyList_New(0);
    if (result == NULL)
        return NULL;
    for (i = 0; i < NUM_GENERATIONS; i++) {
        if (append_objects(result, GEN_HEAD(i))) {
            Py_DECREF(result);
            return NULL;
        }
    }
    return result;
}

Here is the call graph for this function:

static PyObject* gc_get_referents ( PyObject self,
PyObject args 
) [static]

Definition at line 1189 of file gcmodule.c.

{
    Py_ssize_t i;
    PyObject *result = PyList_New(0);

    if (result == NULL)
        return NULL;

    for (i = 0; i < PyTuple_GET_SIZE(args); i++) {
        traverseproc traverse;
        PyObject *obj = PyTuple_GET_ITEM(args, i);

        if (! PyObject_IS_GC(obj))
            continue;
        traverse = Py_TYPE(obj)->tp_traverse;
        if (! traverse)
            continue;
        if (traverse(obj, (visitproc)referentsvisit, result)) {
            Py_DECREF(result);
            return NULL;
        }
    }
    return result;
}

Here is the call graph for this function:

static PyObject* gc_get_referrers ( PyObject self,
PyObject args 
) [static]

Definition at line 1162 of file gcmodule.c.

{
    int i;
    PyObject *result = PyList_New(0);
    if (!result) return NULL;

    for (i = 0; i < NUM_GENERATIONS; i++) {
        if (!(gc_referrers_for(args, GEN_HEAD(i), result))) {
            Py_DECREF(result);
            return NULL;
        }
    }
    return result;
}

Here is the call graph for this function:

static PyObject* gc_get_thresh ( PyObject self,
PyObject noargs 
) [static]

Definition at line 1106 of file gcmodule.c.

{
    return Py_BuildValue("(iii)",
                         generations[0].threshold,
                         generations[1].threshold,
                         generations[2].threshold);
}

Here is the call graph for this function:

static PyObject* gc_is_tracked ( PyObject self,
PyObject obj 
) [static]

Definition at line 1246 of file gcmodule.c.

{
    PyObject *result;

    if (PyObject_IS_GC(obj) && IS_TRACKED(obj))
        result = Py_True;
    else
        result = Py_False;
    Py_INCREF(result);
    return result;
}
static PyObject* gc_isenabled ( PyObject self,
PyObject noargs 
) [static]

Definition at line 1002 of file gcmodule.c.

{
    return PyBool_FromLong((long)enabled);
}

Here is the call graph for this function:

static void gc_list_init ( PyGC_Head list) [static]

Definition at line 182 of file gcmodule.c.

{
    list->gc.gc_prev = list;
    list->gc.gc_next = list;
}

Here is the caller graph for this function:

static int gc_list_is_empty ( PyGC_Head list) [static]

Definition at line 189 of file gcmodule.c.

{
    return (list->gc.gc_next == list);
}

Here is the caller graph for this function:

static void gc_list_merge ( PyGC_Head from,
PyGC_Head to 
) [static]

Definition at line 237 of file gcmodule.c.

{
    PyGC_Head *tail;
    assert(from != to);
    if (!gc_list_is_empty(from)) {
        tail = to->gc.gc_prev;
        tail->gc.gc_next = from->gc.gc_next;
        tail->gc.gc_next->gc.gc_prev = tail;
        to->gc.gc_prev = from->gc.gc_prev;
        to->gc.gc_prev->gc.gc_next = to;
    }
    gc_list_init(from);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void gc_list_move ( PyGC_Head node,
PyGC_Head list 
) [static]

Definition at line 221 of file gcmodule.c.

{
    PyGC_Head *new_prev;
    PyGC_Head *current_prev = node->gc.gc_prev;
    PyGC_Head *current_next = node->gc.gc_next;
    /* Unlink from current list. */
    current_prev->gc.gc_next = current_next;
    current_next->gc.gc_prev = current_prev;
    /* Relink at end of new list. */
    new_prev = node->gc.gc_prev = list->gc.gc_prev;
    new_prev->gc.gc_next = list->gc.gc_prev = node;
    node->gc.gc_next = list;
}

Here is the caller graph for this function:

static void gc_list_remove ( PyGC_Head node) [static]

Definition at line 209 of file gcmodule.c.

{
    node->gc.gc_prev->gc.gc_next = node->gc.gc_next;
    node->gc.gc_next->gc.gc_prev = node->gc.gc_prev;
    node->gc.gc_next = NULL; /* object is not currently tracked */
}

Here is the caller graph for this function:

static Py_ssize_t gc_list_size ( PyGC_Head list) [static]

Definition at line 252 of file gcmodule.c.

{
    PyGC_Head *gc;
    Py_ssize_t n = 0;
    for (gc = list->gc.gc_next; gc != list; gc = gc->gc.gc_next) {
        n++;
    }
    return n;
}

Here is the caller graph for this function:

static int gc_referrers_for ( PyObject objs,
PyGC_Head list,
PyObject resultlist 
) [static]

Definition at line 1139 of file gcmodule.c.

{
    PyGC_Head *gc;
    PyObject *obj;
    traverseproc traverse;
    for (gc = list->gc.gc_next; gc != list; gc = gc->gc.gc_next) {
        obj = FROM_GC(gc);
        traverse = Py_TYPE(obj)->tp_traverse;
        if (obj == objs || obj == resultlist)
            continue;
        if (traverse(obj, (visitproc)referrersvisit, objs)) {
            if (PyList_Append(resultlist, obj) < 0)
                return 0; /* error */
        }
    }
    return 1; /* no error */
}

Here is the call graph for this function:

Here is the caller graph for this function:

static PyObject* gc_set_debug ( PyObject self,
PyObject args 
) [static]

Definition at line 1056 of file gcmodule.c.

{
    if (!PyArg_ParseTuple(args, "i:set_debug", &debug))
        return NULL;

    Py_INCREF(Py_None);
    return Py_None;
}

Here is the call graph for this function:

static PyObject* gc_set_thresh ( PyObject self,
PyObject args 
) [static]

Definition at line 1083 of file gcmodule.c.

{
    int i;
    if (!PyArg_ParseTuple(args, "i|ii:set_threshold",
                          &generations[0].threshold,
                          &generations[1].threshold,
                          &generations[2].threshold))
        return NULL;
    for (i = 2; i < NUM_GENERATIONS; i++) {
        /* generations higher than 2 get the same threshold */
        generations[i].threshold = generations[2].threshold;
    }

    Py_INCREF(Py_None);
    return Py_None;
}

Here is the call graph for this function:

static double get_time ( void  ) [static]

Definition at line 768 of file gcmodule.c.

{
    double result = 0;
    if (tmod != NULL) {
        PyObject *f = PyObject_CallMethod(tmod, "time", NULL);
        if (f == NULL) {
            PyErr_Clear();
        }
        else {
            if (PyFloat_Check(f))
                result = PyFloat_AsDouble(f);
            Py_DECREF(f);
        }
    }
    return result;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int handle_finalizers ( PyGC_Head finalizers,
PyGC_Head old 
) [static]

Definition at line 697 of file gcmodule.c.

{
    PyGC_Head *gc = finalizers->gc.gc_next;

    if (garbage == NULL) {
        garbage = PyList_New(0);
        if (garbage == NULL)
            Py_FatalError("gc couldn't create gc.garbage list");
    }
    for (; gc != finalizers; gc = gc->gc.gc_next) {
        PyObject *op = FROM_GC(gc);

        if ((debug & DEBUG_SAVEALL) || has_finalizer(op)) {
            if (PyList_Append(garbage, op) < 0)
                return -1;
        }
    }

    gc_list_merge(finalizers, old);
    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int handle_weakrefs ( PyGC_Head unreachable,
PyGC_Head old 
) [static]

Definition at line 539 of file gcmodule.c.

{
    PyGC_Head *gc;
    PyObject *op;               /* generally FROM_GC(gc) */
    PyWeakReference *wr;        /* generally a cast of op */
    PyGC_Head wrcb_to_call;     /* weakrefs with callbacks to call */
    PyGC_Head *next;
    int num_freed = 0;

    gc_list_init(&wrcb_to_call);

    /* Clear all weakrefs to the objects in unreachable.  If such a weakref
     * also has a callback, move it into `wrcb_to_call` if the callback
     * needs to be invoked.  Note that we cannot invoke any callbacks until
     * all weakrefs to unreachable objects are cleared, lest the callback
     * resurrect an unreachable object via a still-active weakref.  We
     * make another pass over wrcb_to_call, invoking callbacks, after this
     * pass completes.
     */
    for (gc = unreachable->gc.gc_next; gc != unreachable; gc = next) {
        PyWeakReference **wrlist;

        op = FROM_GC(gc);
        assert(IS_TENTATIVELY_UNREACHABLE(op));
        next = gc->gc.gc_next;

        if (! PyType_SUPPORTS_WEAKREFS(Py_TYPE(op)))
            continue;

        /* It supports weakrefs.  Does it have any? */
        wrlist = (PyWeakReference **)
                                PyObject_GET_WEAKREFS_LISTPTR(op);

        /* `op` may have some weakrefs.  March over the list, clear
         * all the weakrefs, and move the weakrefs with callbacks
         * that must be called into wrcb_to_call.
         */
        for (wr = *wrlist; wr != NULL; wr = *wrlist) {
            PyGC_Head *wrasgc;                  /* AS_GC(wr) */

            /* _PyWeakref_ClearRef clears the weakref but leaves
             * the callback pointer intact.  Obscure:  it also
             * changes *wrlist.
             */
            assert(wr->wr_object == op);
            _PyWeakref_ClearRef(wr);
            assert(wr->wr_object == Py_None);
            if (wr->wr_callback == NULL)
                continue;                       /* no callback */

    /* Headache time.  `op` is going away, and is weakly referenced by
     * `wr`, which has a callback.  Should the callback be invoked?  If wr
     * is also trash, no:
     *
     * 1. There's no need to call it.  The object and the weakref are
     *    both going away, so it's legitimate to pretend the weakref is
     *    going away first.  The user has to ensure a weakref outlives its
     *    referent if they want a guarantee that the wr callback will get
     *    invoked.
     *
     * 2. It may be catastrophic to call it.  If the callback is also in
     *    cyclic trash (CT), then although the CT is unreachable from
     *    outside the current generation, CT may be reachable from the
     *    callback.  Then the callback could resurrect insane objects.
     *
     * Since the callback is never needed and may be unsafe in this case,
     * wr is simply left in the unreachable set.  Note that because we
     * already called _PyWeakref_ClearRef(wr), its callback will never
     * trigger.
     *
     * OTOH, if wr isn't part of CT, we should invoke the callback:  the
     * weakref outlived the trash.  Note that since wr isn't CT in this
     * case, its callback can't be CT either -- wr acted as an external
     * root to this generation, and therefore its callback did too.  So
     * nothing in CT is reachable from the callback either, so it's hard
     * to imagine how calling it later could create a problem for us.  wr
     * is moved to wrcb_to_call in this case.
     */
            if (IS_TENTATIVELY_UNREACHABLE(wr))
                continue;
            assert(IS_REACHABLE(wr));

            /* Create a new reference so that wr can't go away
             * before we can process it again.
             */
            Py_INCREF(wr);

            /* Move wr to wrcb_to_call, for the next pass. */
            wrasgc = AS_GC(wr);
            assert(wrasgc != next); /* wrasgc is reachable, but
                                       next isn't, so they can't
                                       be the same */
            gc_list_move(wrasgc, &wrcb_to_call);
        }
    }

    /* Invoke the callbacks we decided to honor.  It's safe to invoke them
     * because they can't reference unreachable objects.
     */
    while (! gc_list_is_empty(&wrcb_to_call)) {
        PyObject *temp;
        PyObject *callback;

        gc = wrcb_to_call.gc.gc_next;
        op = FROM_GC(gc);
        assert(IS_REACHABLE(op));
        assert(PyWeakref_Check(op));
        wr = (PyWeakReference *)op;
        callback = wr->wr_callback;
        assert(callback != NULL);

        /* copy-paste of weakrefobject.c's handle_callback() */
        temp = PyObject_CallFunctionObjArgs(callback, wr, NULL);
        if (temp == NULL)
            PyErr_WriteUnraisable(callback);
        else
            Py_DECREF(temp);

        /* Give up the reference we created in the first pass.  When
         * op's refcount hits 0 (which it may or may not do right now),
         * op's tp_dealloc will decref op->wr_callback too.  Note
         * that the refcount probably will hit 0 now, and because this
         * weakref was reachable to begin with, gc didn't already
         * add it to its count of freed objects.  Example:  a reachable
         * weak value dict maps some key to this reachable weakref.
         * The callback removes this key->weakref mapping from the
         * dict, leaving no other references to the weakref (excepting
         * ours).
         */
        Py_DECREF(op);
        if (wrcb_to_call.gc.gc_next == gc) {
            /* object is still alive -- move it */
            gc_list_move(gc, old);
        }
        else
            ++num_freed;
    }

    return num_freed;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int has_finalizer ( PyObject op) [static]

Definition at line 462 of file gcmodule.c.

{
    if (PyGen_CheckExact(op))
        return PyGen_NeedsFinalizing((PyGenObject *)op);
    else
        return op->ob_type->tp_del != NULL;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void move_finalizer_reachable ( PyGC_Head finalizers) [static]

Definition at line 514 of file gcmodule.c.

{
    traverseproc traverse;
    PyGC_Head *gc = finalizers->gc.gc_next;
    for (; gc != finalizers; gc = gc->gc.gc_next) {
        /* Note that the finalizers list may grow during this. */
        traverse = Py_TYPE(FROM_GC(gc))->tp_traverse;
        (void) traverse(FROM_GC(gc),
                        (visitproc)visit_move,
                        (void *)finalizers);
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void move_finalizers ( PyGC_Head unreachable,
PyGC_Head finalizers 
) [static]

Definition at line 475 of file gcmodule.c.

{
    PyGC_Head *gc;
    PyGC_Head *next;

    /* March over unreachable.  Move objects with finalizers into
     * `finalizers`.
     */
    for (gc = unreachable->gc.gc_next; gc != unreachable; gc = next) {
        PyObject *op = FROM_GC(gc);

        assert(IS_TENTATIVELY_UNREACHABLE(op));
        next = gc->gc.gc_next;

        if (has_finalizer(op)) {
            gc_list_move(gc, finalizers);
            gc->gc.gc_refs = GC_REACHABLE;
        }
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void move_unreachable ( PyGC_Head young,
PyGC_Head unreachable 
) [static]

Definition at line 404 of file gcmodule.c.

{
    PyGC_Head *gc = young->gc.gc_next;

    /* Invariants:  all objects "to the left" of us in young have gc_refs
     * = GC_REACHABLE, and are indeed reachable (directly or indirectly)
     * from outside the young list as it was at entry.  All other objects
     * from the original young "to the left" of us are in unreachable now,
     * and have gc_refs = GC_TENTATIVELY_UNREACHABLE.  All objects to the
     * left of us in 'young' now have been scanned, and no objects here
     * or to the right have been scanned yet.
     */

    while (gc != young) {
        PyGC_Head *next;

        if (gc->gc.gc_refs) {
            /* gc is definitely reachable from outside the
             * original 'young'.  Mark it as such, and traverse
             * its pointers to find any other objects that may
             * be directly reachable from it.  Note that the
             * call to tp_traverse may append objects to young,
             * so we have to wait until it returns to determine
             * the next object to visit.
             */
            PyObject *op = FROM_GC(gc);
            traverseproc traverse = Py_TYPE(op)->tp_traverse;
            assert(gc->gc.gc_refs > 0);
            gc->gc.gc_refs = GC_REACHABLE;
            (void) traverse(op,
                            (visitproc)visit_reachable,
                            (void *)young);
            next = gc->gc.gc_next;
            if (PyTuple_CheckExact(op)) {
                _PyTuple_MaybeUntrack(op);
            }
            else if (PyDict_CheckExact(op)) {
                _PyDict_MaybeUntrack(op);
            }
        }
        else {
            /* This *may* be unreachable.  To make progress,
             * assume it is.  gc isn't directly reachable from
             * any object we've already traversed, but may be
             * reachable from an object we haven't gotten to yet.
             * visit_reachable will eventually move gc back into
             * young if that's so, and we'll see it again.
             */
            next = gc->gc.gc_next;
            gc_list_move(gc, unreachable);
            gc->gc.gc_refs = GC_TENTATIVELY_UNREACHABLE;
        }
        gc = next;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

PyDoc_STRVAR ( gc_enable__doc__  ,
"enable() -> None\n""\n""Enable automatic garbage collection.\n  
)
PyDoc_STRVAR ( gc_disable__doc__  ,
"disable() -> None\n""\n""Disable automatic garbage collection.\n  
)
PyDoc_STRVAR ( gc_isenabled__doc__  ,
"isenabled() -> status\n""\n""Returns true if automatic garbage collection is enabled.\n  
)
PyDoc_STRVAR ( gc_collect__doc__  ,
"collect([generation]) -> n\n""\n""With no  arguments,
run a full collection.The optional argument\n""may be an integer specifying which generation to collect.A ValueError\n""is raised if the generation number is invalid.\n\n""The number of unreachable objects is returned.\n  
)
PyDoc_STRVAR ( gc_set_debug__doc__  ,
"set_debug(flags) -> None\n""\n""Set the garbage collection debugging flags. Debugging information is\n""written to sys.stderr.\n""\n""flags is an integer and can have the following bits turned on:\n""\n"" DEBUG_STATS - Print statistics during collection.\n"" DEBUG_COLLECTABLE - Print collectable objects found.\n"" DEBUG_UNCOLLECTABLE - Print unreachable but uncollectable objects found.\n"" DEBUG_SAVEALL - Save objects to gc.garbage rather than freeing them.\n"" DEBUG_LEAK - Debug leaking programs (everything but STATS).\n  
)
PyDoc_STRVAR ( gc_get_debug__doc__  ,
"get_debug() -> flags\n""\n""Get the garbage collection debugging flags.\n  
)
PyDoc_STRVAR ( gc_set_thresh__doc__  ,
"set_threshold(threshold0, [threshold1, threshold2]) -> None\n""\n""Sets the collection thresholds. Setting threshold0 to zero disables\n""collection.\n  
)
PyDoc_STRVAR ( gc_get_thresh__doc__  ,
"get_threshold() -> (threshold0, threshold1, threshold2)\n""\n""Return the current collection thresholds\n  
)
PyDoc_STRVAR ( gc_get_count__doc__  ,
"get_count() -> (count0, count1, count2)\n""\n""Return the current collection counts\n  
)
PyDoc_STRVAR ( gc_get_referrers__doc__  ,
"get_referrers*objs -> list\n\Return the list of objects that directly refer to any of objs."   
)
PyDoc_STRVAR ( gc_get_referents__doc__  ,
"get_referents*objs -> list\n\Return the list of objects that are directly referred to by objs."   
)
PyDoc_STRVAR ( gc_get_objects__doc__  ,
"get_objects() -> \n""\n""Return a list of objects tracked by the collector (excluding the list\n""returned).\n [...] 
)
PyDoc_STRVAR ( gc_is_tracked__doc__  ,
"is_tracked(obj) -> bool\n""\n""Returns true if the object is tracked by the garbage collector.\n""Simple atomic objects will return false.\n  
)
PyDoc_STRVAR ( gc__doc__  ,
"This module provides access to the garbage collector for reference cycles.\n""\n""enable() -- Enable automatic garbage collection.\n""disable() -- Disable automatic garbage collection.\n""isenabled() -- Returns true if automatic collection is enabled.\n""collect() -- Do a full collection right now.\n""get_count() -- Return the current collection counts.\n""set_debug() -- Set debugging flags.\n""get_debug() -- Get debugging flags.\n""set_threshold() -- Set the collection thresholds.\n""get_threshold() -- Return the current the collection thresholds.\n""get_objects() -- Return a list of all objects tracked by the collector.\n""is_tracked() -- Returns true if a given object is tracked.\n""get_referrers() -- Return the list of objects that refer to an object.\n""get_referents() -- Return the list of objects that an object refers to.\n  
)

Definition at line 1351 of file gcmodule.c.

{
    Py_ssize_t n;

    if (collecting)
        n = 0; /* already collecting, don't do anything */
    else {
        collecting = 1;
        n = collect(NUM_GENERATIONS - 1);
        collecting = 0;
    }

    return n;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Definition at line 1309 of file gcmodule.c.

{
    PyObject *m;

    m = PyModule_Create(&gcmodule);

    if (m == NULL)
        return NULL;

    if (garbage == NULL) {
        garbage = PyList_New(0);
        if (garbage == NULL)
            return NULL;
    }
    Py_INCREF(garbage);
    if (PyModule_AddObject(m, "garbage", garbage) < 0)
        return NULL;

    /* Importing can't be done in collect() because collect()
     * can be called via PyGC_Collect() in Py_Finalize().
     * This wouldn't be a problem, except that <initialized> is
     * reset to 0 before calling collect which trips up
     * the import and triggers an assertion.
     */
    if (tmod == NULL) {
        tmod = PyImport_ImportModuleNoBlock("time");
        if (tmod == NULL)
            PyErr_Clear();
    }

#define ADD_INT(NAME) if (PyModule_AddIntConstant(m, #NAME, NAME) < 0) return NULL
    ADD_INT(DEBUG_STATS);
    ADD_INT(DEBUG_COLLECTABLE);
    ADD_INT(DEBUG_UNCOLLECTABLE);
    ADD_INT(DEBUG_SAVEALL);
    ADD_INT(DEBUG_LEAK);
#undef ADD_INT
    return m;
}

Here is the call graph for this function:

Definition at line 1504 of file gcmodule.c.

{
    PyGC_Head *g = AS_GC(op);
    if (IS_TRACKED(op))
        gc_list_remove(g);
    if (generations[0].count > 0) {
        generations[0].count--;
    }
    PyObject_FREE(g);
}

Here is the call graph for this function:

Definition at line 1414 of file gcmodule.c.

Here is the caller graph for this function:

Definition at line 1427 of file gcmodule.c.

{
    /* Obscure:  the Py_TRASHCAN mechanism requires that we be able to
     * call PyObject_GC_UnTrack twice on an object.
     */
    if (IS_TRACKED(op))
        _PyObject_GC_UNTRACK(op);
}
static int referentsvisit ( PyObject obj,
PyObject list 
) [static]

Definition at line 1179 of file gcmodule.c.

{
    return PyList_Append(list, obj) < 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int referrersvisit ( PyObject obj,
PyObject objs 
) [static]

Definition at line 1129 of file gcmodule.c.

{
    Py_ssize_t i;
    for (i = 0; i < PyTuple_GET_SIZE(objs); i++)
        if (PyTuple_GET_ITEM(objs, i) == obj)
            return 1;
    return 0;
}

Here is the caller graph for this function:

static void subtract_refs ( PyGC_Head containers) [static]

Definition at line 340 of file gcmodule.c.

{
    traverseproc traverse;
    PyGC_Head *gc = containers->gc.gc_next;
    for (; gc != containers; gc=gc->gc.gc_next) {
        traverse = Py_TYPE(FROM_GC(gc))->tp_traverse;
        (void) traverse(FROM_GC(gc),
                       (visitproc)visit_decref,
                       NULL);
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void update_refs ( PyGC_Head containers) [static]

Definition at line 288 of file gcmodule.c.

{
    PyGC_Head *gc = containers->gc.gc_next;
    for (; gc != containers; gc = gc->gc.gc_next) {
        assert(gc->gc.gc_refs == GC_REACHABLE);
        gc->gc.gc_refs = Py_REFCNT(FROM_GC(gc));
        /* Python's cyclic gc should never see an incoming refcount
         * of 0:  if something decref'ed to 0, it should have been
         * deallocated immediately at that time.
         * Possible cause (if the assert triggers):  a tp_dealloc
         * routine left a gc-aware object tracked during its teardown
         * phase, and did something-- or allowed something to happen --
         * that called back into Python.  gc can trigger then, and may
         * see the still-tracked dying object.  Before this assert
         * was added, such mistakes went on to allow gc to try to
         * delete the object again.  In a debug build, that caused
         * a mysterious segfault, when _Py_ForgetReference tried
         * to remove the object from the doubly-linked list of all
         * objects a second time.  In a release build, an actual
         * double deallocation occurred, which leads to corruption
         * of the allocator's internal bookkeeping pointers.  That's
         * so serious that maybe this should be a release-build
         * check instead of an assert?
         */
        assert(gc->gc.gc_refs != 0);
    }
}

Here is the caller graph for this function:

static int visit_decref ( PyObject op,
void data 
) [static]

Definition at line 318 of file gcmodule.c.

{
    assert(op != NULL);
    if (PyObject_IS_GC(op)) {
        PyGC_Head *gc = AS_GC(op);
        /* We're only interested in gc_refs for objects in the
         * generation being collected, which can be recognized
         * because only they have positive gc_refs.
         */
        assert(gc->gc.gc_refs != 0); /* else refcount was too small */
        if (gc->gc.gc_refs > 0)
            gc->gc.gc_refs--;
    }
    return 0;
}

Here is the caller graph for this function:

static int visit_move ( PyObject op,
PyGC_Head tolist 
) [static]

Definition at line 498 of file gcmodule.c.

{
    if (PyObject_IS_GC(op)) {
        if (IS_TENTATIVELY_UNREACHABLE(op)) {
            PyGC_Head *gc = AS_GC(op);
            gc_list_move(gc, tolist);
            gc->gc.gc_refs = GC_REACHABLE;
        }
    }
    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int visit_reachable ( PyObject op,
PyGC_Head reachable 
) [static]

Definition at line 354 of file gcmodule.c.

{
    if (PyObject_IS_GC(op)) {
        PyGC_Head *gc = AS_GC(op);
        const Py_ssize_t gc_refs = gc->gc.gc_refs;

        if (gc_refs == 0) {
            /* This is in move_unreachable's 'young' list, but
             * the traversal hasn't yet gotten to it.  All
             * we need to do is tell move_unreachable that it's
             * reachable.
             */
            gc->gc.gc_refs = 1;
        }
        else if (gc_refs == GC_TENTATIVELY_UNREACHABLE) {
            /* This had gc_refs = 0 when move_unreachable got
             * to it, but turns out it's reachable after all.
             * Move it back to move_unreachable's 'young' list,
             * and move_unreachable will eventually get to it
             * again.
             */
            gc_list_move(gc, reachable);
            gc->gc.gc_refs = 1;
        }
        /* Else there's nothing to do.
         * If gc_refs > 0, it must be in move_unreachable's 'young'
         * list, and move_unreachable will eventually get to it.
         * If gc_refs == GC_REACHABLE, it's either in some other
         * generation so we don't care about it, or move_unreachable
         * already dealt with it.
         * If gc_refs == GC_UNTRACKED, it must be ignored.
         */
         else {
            assert(gc_refs > 0
                   || gc_refs == GC_REACHABLE
                   || gc_refs == GC_UNTRACKED);
         }
    }
    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:


Variable Documentation

Definition at line 55 of file gcmodule.c.

int collecting = 0 [static]

Definition at line 60 of file gcmodule.c.

int debug [static]

Definition at line 128 of file gcmodule.c.

PyObject* delstr = NULL [static]

Definition at line 69 of file gcmodule.c.

int enabled = 1 [static]

Definition at line 57 of file gcmodule.c.

PyObject* garbage = NULL [static]

Definition at line 63 of file gcmodule.c.

struct gc_generation[NUM_GENERATIONS] [static]
Initial value:
 {
    
    {{{GEN_HEAD(0), GEN_HEAD(0), 0}},           700,            0},
    {{{GEN_HEAD(1), GEN_HEAD(1), 0}},           10,             0},
    {{{GEN_HEAD(2), GEN_HEAD(2), 0}},           10,             0},
}

Definition at line 48 of file gcmodule.c.

PyObject* gc_str = NULL [static]

Definition at line 66 of file gcmodule.c.

PyMethodDef GcMethods[] [static]
Initial value:
 {
    {"enable",             gc_enable,     METH_NOARGS,  gc_enable__doc__},
    {"disable",            gc_disable,    METH_NOARGS,  gc_disable__doc__},
    {"isenabled",          gc_isenabled,  METH_NOARGS,  gc_isenabled__doc__},
    {"set_debug",          gc_set_debug,  METH_VARARGS, gc_set_debug__doc__},
    {"get_debug",          gc_get_debug,  METH_NOARGS,  gc_get_debug__doc__},
    {"get_count",          gc_get_count,  METH_NOARGS,  gc_get_count__doc__},
    {"set_threshold",  gc_set_thresh, METH_VARARGS, gc_set_thresh__doc__},
    {"get_threshold",  gc_get_thresh, METH_NOARGS,  gc_get_thresh__doc__},
    {"collect",            (PyCFunction)gc_collect,
        METH_VARARGS | METH_KEYWORDS,           gc_collect__doc__},
    {"get_objects",    gc_get_objects,METH_NOARGS,  gc_get_objects__doc__},
    {"is_tracked",     gc_is_tracked, METH_O,       gc_is_tracked__doc__},
    {"get_referrers",  gc_get_referrers, METH_VARARGS,
        gc_get_referrers__doc__},
    {"get_referents",  gc_get_referents, METH_VARARGS,
        gc_get_referents__doc__},
    {NULL,      NULL}           
}

Definition at line 1276 of file gcmodule.c.

Definition at line 82 of file gcmodule.c.

Definition at line 76 of file gcmodule.c.

struct PyModuleDef [static]
Initial value:
 {
    PyModuleDef_HEAD_INIT,
    "gc",              
    gc__doc__,         
    -1,                
    GcMethods,         
    NULL,              
    NULL,              
    NULL,              
    NULL               
}

Definition at line 1296 of file gcmodule.c.

PyObject* tmod = NULL [static]

Definition at line 129 of file gcmodule.c.