-
-
Notifications
You must be signed in to change notification settings - Fork 34.2k
Expand file tree
/
Copy pathgcmodule.c
More file actions
560 lines (456 loc) · 15.1 KB
/
gcmodule.c
File metadata and controls
560 lines (456 loc) · 15.1 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
/*
* Python interface to the garbage collector.
*
* See Python/gc.c for the implementation of the garbage collector.
*/
#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;
}
/*[clinic input]
module gc
[clinic start generated code]*/
/*[clinic end generated code: output=da39a3ee5e6b4b0d input=b5c9690ecc842d79]*/
#include "clinic/gcmodule.c.h"
/*[clinic input]
gc.enable
Enable automatic garbage collection.
[clinic start generated code]*/
static PyObject *
gc_enable_impl(PyObject *module)
/*[clinic end generated code: output=45a427e9dce9155c input=81ac4940ca579707]*/
{
PyGC_Enable();
Py_RETURN_NONE;
}
/*[clinic input]
gc.disable
Disable automatic garbage collection.
[clinic start generated code]*/
static PyObject *
gc_disable_impl(PyObject *module)
/*[clinic end generated code: output=97d1030f7aa9d279 input=8c2e5a14e800d83b]*/
{
PyGC_Disable();
Py_RETURN_NONE;
}
/*[clinic input]
gc.isenabled -> bool
Returns true if automatic garbage collection is enabled.
[clinic start generated code]*/
static int
gc_isenabled_impl(PyObject *module)
/*[clinic end generated code: output=1874298331c49130 input=30005e0422373b31]*/
{
return PyGC_IsEnabled();
}
/*[clinic input]
gc.collect -> Py_ssize_t
generation: int(c_default="NUM_GENERATIONS - 1") = 2
Run the garbage collector.
With no arguments, run a full collection. The optional argument
may be an integer specifying which generation to collect. A ValueError
is raised if the generation number is invalid.
The number of unreachable objects is returned.
[clinic start generated code]*/
static Py_ssize_t
gc_collect_impl(PyObject *module, int generation)
/*[clinic end generated code: output=b697e633043233c7 input=40720128b682d879]*/
{
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);
}
/*[clinic input]
gc.set_debug
flags: int
An integer that can have the following bits turned on:
DEBUG_STATS - Print statistics during collection.
DEBUG_COLLECTABLE - Print collectable objects found.
DEBUG_UNCOLLECTABLE - Print unreachable but uncollectable objects
found.
DEBUG_SAVEALL - Save objects to gc.garbage rather than freeing them.
DEBUG_LEAK - Debug leaking programs (everything but STATS).
/
Set the garbage collection debugging flags.
Debugging information is written to sys.stderr.
[clinic start generated code]*/
static PyObject *
gc_set_debug_impl(PyObject *module, int flags)
/*[clinic end generated code: output=7c8366575486b228 input=5e5ce15e84fbed15]*/
{
GCState *gcstate = get_gc_state();
gcstate->debug = flags;
Py_RETURN_NONE;
}
/*[clinic input]
gc.get_debug -> int
Get the garbage collection debugging flags.
[clinic start generated code]*/
static int
gc_get_debug_impl(PyObject *module)
/*[clinic end generated code: output=91242f3506cd1e50 input=91a101e1c3b98366]*/
{
GCState *gcstate = get_gc_state();
return gcstate->debug;
}
/*[clinic input]
gc.set_threshold
threshold0: int
[
threshold1: int
[
threshold2: int
]
]
/
Set the collection thresholds (the collection frequency).
Setting 'threshold0' to zero disables collection.
[clinic start generated code]*/
static PyObject *
gc_set_threshold_impl(PyObject *module, int threshold0, int group_right_1,
int threshold1, int group_right_2, int threshold2)
/*[clinic end generated code: output=2e3c7c7dd59060f3 input=0d9612db50984eec]*/
{
GCState *gcstate = get_gc_state();
gcstate->young.threshold = threshold0;
if (group_right_1) {
gcstate->old[0].threshold = threshold1;
}
if (group_right_2) {
gcstate->old[1].threshold = threshold2;
}
Py_RETURN_NONE;
}
/*[clinic input]
gc.get_threshold
Return the current collection thresholds.
[clinic start generated code]*/
static PyObject *
gc_get_threshold_impl(PyObject *module)
/*[clinic end generated code: output=7902bc9f41ecbbd8 input=286d79918034d6e6]*/
{
GCState *gcstate = get_gc_state();
return Py_BuildValue("(iii)",
gcstate->young.threshold,
gcstate->old[0].threshold,
0);
}
/*[clinic input]
gc.get_count
Return a three-tuple of the current collection counts.
[clinic start generated code]*/
static PyObject *
gc_get_count_impl(PyObject *module)
/*[clinic end generated code: output=354012e67b16398f input=a392794a08251751]*/
{
GCState *gcstate = get_gc_state();
#ifdef Py_GIL_DISABLED
_PyThreadStateImpl *tstate = (_PyThreadStateImpl *)_PyThreadState_GET();
struct _gc_thread_state *gc = &tstate->gc;
// Flush the local allocation count to the global count
_Py_atomic_add_int(&gcstate->young.count, (int)gc->alloc_count);
gc->alloc_count = 0;
#endif
return Py_BuildValue("(iii)",
gcstate->young.count,
gcstate->old[gcstate->visited_space].count,
gcstate->old[gcstate->visited_space^1].count);
}
/*[clinic input]
gc.get_referrers
*objs: tuple
Return the list of objects that directly refer to any of 'objs'.
[clinic start generated code]*/
static PyObject *
gc_get_referrers_impl(PyObject *module, PyObject *objs)
/*[clinic end generated code: output=929d6dff26f609b9 input=9102be7ebee69ee3]*/
{
if (PySys_Audit("gc.get_referrers", "(O)", objs) < 0) {
return NULL;
}
PyInterpreterState *interp = _PyInterpreterState_GET();
return _PyGC_GetReferrers(interp, objs);
}
/* Append obj to list; return true if error (out of memory), false if OK. */
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;
}
/*[clinic input]
gc.get_referents
*objs: tuple
Return the list of objects that are directly referred to by 'objs'.
[clinic start generated code]*/
static PyObject *
gc_get_referents_impl(PyObject *module, PyObject *objs)
/*[clinic end generated code: output=6dfde40cd1588e1d input=55c078a6d0248fe0]*/
{
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;
}
/*[clinic input]
@permit_long_summary
gc.get_objects
generation: Py_ssize_t(accept={int, NoneType}, c_default="-1") = None
Generation to extract the objects from.
Return a list of objects tracked by the collector (excluding the list returned).
If generation is not None, return only the objects tracked by the collector
that are in that generation.
[clinic start generated code]*/
static PyObject *
gc_get_objects_impl(PyObject *module, Py_ssize_t generation)
/*[clinic end generated code: output=48b35fea4ba6cb0e input=a887f1d9924be7cf]*/
{
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);
}
/*[clinic input]
gc.get_stats
Return a list of dictionaries containing per-generation statistics.
[clinic start generated code]*/
static PyObject *
gc_get_stats_impl(PyObject *module)
/*[clinic end generated code: output=a8ab1d8a5d26f3ab input=1ef4ed9d17b1a470]*/
{
int i;
struct gc_generation_stats stats[NUM_GENERATIONS], *st;
/* To get consistent values despite allocations while constructing
the result list, we use a snapshot of the running stats. */
GCState *gcstate = get_gc_state();
for (i = 0; i < NUM_GENERATIONS; i++) {
stats[i] = gcstate->generation_stats[i];
}
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;
}
/*[clinic input]
gc.is_tracked -> bool
obj: object
/
Returns true if the object is tracked by the garbage collector.
Simple atomic objects will return false.
[clinic start generated code]*/
static int
gc_is_tracked_impl(PyObject *module, PyObject *obj)
/*[clinic end generated code: output=91c8d086b7f47a33 input=423b98ec680c3126]*/
{
return PyObject_GC_IsTracked(obj);
}
/*[clinic input]
gc.is_finalized -> bool
obj: object
/
Returns true if the object has been already finalized by the GC.
[clinic start generated code]*/
static int
gc_is_finalized_impl(PyObject *module, PyObject *obj)
/*[clinic end generated code: output=401ff5d6fc660429 input=ca4d111c8f8c4e3a]*/
{
return PyObject_GC_IsFinalized(obj);
}
/*[clinic input]
@permit_long_docstring_body
gc.freeze
Freeze all current tracked objects and ignore them for future collections.
This can be used before a POSIX fork() call to make the gc copy-on-write friendly.
Note: collection before a POSIX fork() call may free pages for future allocation
which can cause copy-on-write.
[clinic start generated code]*/
static PyObject *
gc_freeze_impl(PyObject *module)
/*[clinic end generated code: output=502159d9cdc4c139 input=11fb59b0a75dcf3d]*/
{
PyInterpreterState *interp = _PyInterpreterState_GET();
_PyGC_Freeze(interp);
Py_RETURN_NONE;
}
/*[clinic input]
gc.unfreeze
Unfreeze all objects in the permanent generation.
Put all objects in the permanent generation back into oldest generation.
[clinic start generated code]*/
static PyObject *
gc_unfreeze_impl(PyObject *module)
/*[clinic end generated code: output=1c15f2043b25e169 input=2dd52b170f4cef6c]*/
{
PyInterpreterState *interp = _PyInterpreterState_GET();
_PyGC_Unfreeze(interp);
Py_RETURN_NONE;
}
/*[clinic input]
gc.get_freeze_count -> Py_ssize_t
Return the number of objects in the permanent generation.
[clinic start generated code]*/
static Py_ssize_t
gc_get_freeze_count_impl(PyObject *module)
/*[clinic end generated code: output=61cbd9f43aa032e1 input=45ffbc65cfe2a6ed]*/
{
PyInterpreterState *interp = _PyInterpreterState_GET();
return _PyGC_GetFreezeCount(interp);
}
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"
"get_stats() -- Return list of dictionaries containing per-generation stats.\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 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"
"is_finalized() -- Returns true if a given object has been already finalized.\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"
"freeze() -- Freeze all tracked objects and ignore them for future collections.\n"
"unfreeze() -- Unfreeze all objects in the permanent generation.\n"
"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
* interpreter lifecycle. */
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_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
};
PyMODINIT_FUNC
PyInit_gc(void)
{
return PyModuleDef_Init(&gcmodule);
}