#include "Python.h"

#include "pycore_gc.h"

#include "pycore_object.h" // _PyObject_IS_GC()

#include "pycore_pystate.h" // _PyInterpreterState_GET()

typedef struct _gc_runtime_state GCState;

static GCState *

get_gc_state(void)

{

PyInterpreterState *interp = _PyInterpreterState_GET();

return &interp->gc;

}

#include "clinic/gcmodule.c.h"

static PyObject *

gc_enable_impl(PyObject *module)

{

PyGC_Enable();

Py_RETURN_NONE;

}

static PyObject *

gc_disable_impl(PyObject *module)

{

PyGC_Disable();

Py_RETURN_NONE;

}

static int

gc_isenabled_impl(PyObject *module)

{

return PyGC_IsEnabled();

}

static Py_ssize_t

gc_collect_impl(PyObject *module, int generation)

{

PyThreadState *tstate = _PyThreadState_GET();

if (generation < 0 || generation >= NUM_GENERATIONS) {

_PyErr_SetString(tstate, PyExc_ValueError, "invalid generation");

return -1;

}

return _PyGC_Collect(tstate, generation, _Py_GC_REASON_MANUAL);

}

static PyObject *

gc_set_debug_impl(PyObject *module, int flags)

{

GCState *gcstate = get_gc_state();

gcstate->debug = flags;

Py_RETURN_NONE;

}

static int

gc_get_debug_impl(PyObject *module)

{

GCState *gcstate = get_gc_state();

return gcstate->debug;

}

static PyObject *

gc_set_threshold_impl(PyObject *module, int threshold0, int group_right_1,

int threshold1, int group_right_2, int threshold2)

{

GCState *gcstate = get_gc_state();

#ifndef Py_GIL_DISABLED

gcstate->generations[0].threshold = threshold0;

if (group_right_1) {

gcstate->generations[1].threshold = threshold1;

}

if (group_right_2) {

gcstate->generations[2].threshold = threshold2;

}

PyInterpreterState *interp = _PyInterpreterState_GET();

_PyEval_StopTheWorld(interp);

gcstate->young.threshold = threshold0;

if (group_right_1) {

gcstate->old[0].threshold = threshold1;

}

if (group_right_2) {

gcstate->old[1].threshold = threshold2;

}

_PyEval_StartTheWorld(interp);

Py_RETURN_NONE;

}

static PyObject *

gc_get_threshold_impl(PyObject *module)

{

GCState *gcstate = get_gc_state();

#ifndef Py_GIL_DISABLED

return Py_BuildValue("(iii)",

gcstate->generations[0].threshold,

gcstate->generations[1].threshold,

gcstate->generations[2].threshold);

return Py_BuildValue("(iii)",

gcstate->young.threshold,

gcstate->old[0].threshold,

gcstate->old[1].threshold);

}

static PyObject *

gc_get_count_impl(PyObject *module)

{

GCState *gcstate = get_gc_state();

#ifdef Py_GIL_DISABLED

_PyThreadStateImpl *tstate = (_PyThreadStateImpl *)_PyThreadState_GET();

struct _gc_thread_state *gc = &tstate->gc;

// Don't flush: record_allocation() checks the threshold only when it fills.

int young = _Py_atomic_load_int_relaxed(&gcstate->young.count);

young += (int)gc->alloc_count;

if (young < 0) {

young = 0;

}

#ifndef Py_GIL_DISABLED

return Py_BuildValue("(iii)",

gcstate->generations[0].count,

gcstate->generations[1].count,

gcstate->generations[2].count);

return Py_BuildValue("(iii)",

young,

gcstate->old[0].count,

gcstate->old[1].count);

}

static PyObject *

gc_get_referrers_impl(PyObject *module, PyObject *objs)

{

if (PySys_Audit("gc.get_referrers", "(O)", objs) < 0) {

return NULL;

}

PyInterpreterState *interp = _PyInterpreterState_GET();

return _PyGC_GetReferrers(interp, objs);

}

static int

referentsvisit(PyObject *obj, void *arg)

{

PyObject *list = arg;

return PyList_Append(list, obj) < 0;

}

static int

append_referrents(PyObject *result, PyObject *args)

{

for (Py_ssize_t i = 0; i < PyTuple_GET_SIZE(args); i++) {

PyObject *obj = PyTuple_GET_ITEM(args, i);

if (!_PyObject_IS_GC(obj)) {

continue;

}

traverseproc traverse = Py_TYPE(obj)->tp_traverse;

if (!traverse) {

continue;

}

if (traverse(obj, referentsvisit, result)) {

return -1;

}

}

return 0;

}

static PyObject *

gc_get_referents_impl(PyObject *module, PyObject *objs)

{

if (PySys_Audit("gc.get_referents", "(O)", objs) < 0) {

return NULL;

}

PyInterpreterState *interp = _PyInterpreterState_GET();

PyObject *result = PyList_New(0);

if (result == NULL) {

return NULL;

}

// NOTE: stop the world is a no-op in default build

_PyEval_StopTheWorld(interp);

int err = append_referrents(result, objs);

_PyEval_StartTheWorld(interp);

if (err < 0) {

Py_CLEAR(result);

}

return result;

}

static PyObject *

gc_get_objects_impl(PyObject *module, Py_ssize_t generation)

{

if (PySys_Audit("gc.get_objects", "n", generation) < 0) {

return NULL;

}

if (generation >= NUM_GENERATIONS) {

return PyErr_Format(PyExc_ValueError,

"generation parameter must be less than the number of "

"available generations (%i)",

NUM_GENERATIONS);

}

if (generation < -1) {

PyErr_SetString(PyExc_ValueError,

"generation parameter cannot be negative");

return NULL;

}

PyInterpreterState *interp = _PyInterpreterState_GET();

return _PyGC_GetObjects(interp, (int)generation);

}

static PyObject *

gc_get_stats_impl(PyObject *module)

{

int i;

struct gc_generation_stats stats[NUM_GENERATIONS], *st;

/* To get consistent values despite allocations while constructing

GCState *gcstate = get_gc_state();

#ifdef Py_GIL_DISABLED

PyMutex_Lock(&gcstate->stats_mutex);

stats[0] = gcstate->generation_stats->young.items[gcstate->generation_stats->young.index];

stats[1] = gcstate->generation_stats->old[0].items[gcstate->generation_stats->old[0].index];

stats[2] = gcstate->generation_stats->old[1].items[gcstate->generation_stats->old[1].index];

#ifdef Py_GIL_DISABLED

PyMutex_Unlock(&gcstate->stats_mutex);

PyObject *result = PyList_New(0);

if (result == NULL)

return NULL;

for (i = 0; i < NUM_GENERATIONS; i++) {

PyObject *dict;

st = &stats[i];

dict = Py_BuildValue("{snsnsnsnsd}",

"collections", st->collections,

"collected", st->collected,

"uncollectable", st->uncollectable,

"candidates", st->candidates,

"duration", st->duration

);

if (dict == NULL)

goto error;

if (PyList_Append(result, dict)) {

Py_DECREF(dict);

goto error;

}

Py_DECREF(dict);

}

return result;

error:

Py_XDECREF(result);

return NULL;

}

static int

gc_is_tracked_impl(PyObject *module, PyObject *obj)

{

return PyObject_GC_IsTracked(obj);

}

static int

gc_is_finalized_impl(PyObject *module, PyObject *obj)

{

return PyObject_GC_IsFinalized(obj);

}

static PyObject *

gc_freeze_impl(PyObject *module)

{

PyInterpreterState *interp = _PyInterpreterState_GET();

_PyGC_Freeze(interp);

Py_RETURN_NONE;

}

static PyObject *

gc_unfreeze_impl(PyObject *module)

{

PyInterpreterState *interp = _PyInterpreterState_GET();

_PyGC_Unfreeze(interp);

Py_RETURN_NONE;

}

static Py_ssize_t

gc_get_freeze_count_impl(PyObject *module)

{

PyInterpreterState *interp = _PyInterpreterState_GET();

return _PyGC_GetFreezeCount(interp);

}

PyDoc_STRVAR(gc__doc__,

"get_freeze_count() -- Return the number of objects in the permanent generation.\n");

static PyMethodDef GcMethods[] = {

GC_ENABLE_METHODDEF

GC_DISABLE_METHODDEF

GC_ISENABLED_METHODDEF

GC_SET_DEBUG_METHODDEF

GC_GET_DEBUG_METHODDEF

GC_GET_COUNT_METHODDEF

GC_SET_THRESHOLD_METHODDEF

GC_GET_THRESHOLD_METHODDEF

GC_COLLECT_METHODDEF

GC_GET_OBJECTS_METHODDEF

GC_GET_STATS_METHODDEF

GC_IS_TRACKED_METHODDEF

GC_IS_FINALIZED_METHODDEF

GC_GET_REFERRERS_METHODDEF

GC_GET_REFERENTS_METHODDEF

GC_FREEZE_METHODDEF

GC_UNFREEZE_METHODDEF

GC_GET_FREEZE_COUNT_METHODDEF

{NULL, NULL} /* Sentinel */

};

static int

gcmodule_exec(PyObject *module)

{

GCState *gcstate = get_gc_state();

/* garbage and callbacks are initialized by _PyGC_Init() early in

assert(gcstate->garbage != NULL);

if (PyModule_AddObjectRef(module, "garbage", gcstate->garbage) < 0) {

return -1;

}

assert(gcstate->callbacks != NULL);

if (PyModule_AddObjectRef(module, "callbacks", gcstate->callbacks) < 0) {

return -1;

}

#define ADD_INT(NAME) if (PyModule_AddIntConstant(module, #NAME, _PyGC_ ## NAME) < 0) { return -1; }

ADD_INT(DEBUG_STATS);

ADD_INT(DEBUG_COLLECTABLE);

ADD_INT(DEBUG_UNCOLLECTABLE);

ADD_INT(DEBUG_SAVEALL);

ADD_INT(DEBUG_LEAK);

#undef ADD_INT

return 0;

}

static PyModuleDef_Slot gcmodule_slots[] = {

_Py_ABI_SLOT,

{Py_mod_exec, gcmodule_exec},

{Py_mod_multiple_interpreters, Py_MOD_PER_INTERPRETER_GIL_SUPPORTED},

{Py_mod_gil, Py_MOD_GIL_NOT_USED},

{0, NULL}

};

static struct PyModuleDef gcmodule = {

PyModuleDef_HEAD_INIT,

.m_name = "gc",

.m_doc = gc__doc__,

.m_size = 0, // per interpreter state, see: get_gc_state()

.m_methods = GcMethods,

.m_slots = gcmodule_slots

};

PyInit_gc(void)

{

return PyModuleDef_Init(&gcmodule);

}