gh-130695: add count create/destroy refs to tracemalloc

Author: tom-pytel

Doc/library/tracemalloc.rst

@@ -299,7 +299,8 @@ Functions
 
 .. function:: clear_traces()
 
-   Clear traces of memory blocks allocated by Python.
+   Clear traces of memory blocks allocated and counts of created and destroyed
+   memory blocks by Python.
 
    See also :func:`stop`.
 
@@ -330,6 +331,12 @@ Functions
    :mod:`tracemalloc` module as a tuple: ``(current: int, peak: int)``.
 
 
+.. function:: get_traced_refs()
+
+   Get the current count of created and destroyed memory blocks.
+   :mod:`tracemalloc` module as a tuple: ``(created: int, destroyed: int)``.
+
+
 .. function:: reset_peak()
 
    Set the peak size of memory blocks traced by the :mod:`tracemalloc` module

Include/internal/pycore_tracemalloc.h

@@ -94,6 +94,12 @@ struct _tracemalloc_runtime_state {
     /* domain (unsigned int) => traces (_Py_hashtable_t).
        Protected by TABLES_LOCK(). */
     _Py_hashtable_t *domains;
+    /* Number of references created.
+       Protected by TABLES_LOCK(). */
+    size_t refs_created;
+    /* Number of references destroyed.
+       Protected by TABLES_LOCK() and sometimes modified atomically. */
+    size_t refs_destroyed;
 
     struct tracemalloc_traceback empty_traceback;
 
@@ -155,6 +161,9 @@ extern size_t _PyTraceMalloc_GetMemory(void);
 /* Get the current size and peak size of traced memory blocks as a 2-tuple */
 extern PyObject* _PyTraceMalloc_GetTracedMemory(void);
 
+/* Get the current number of references created and destroyed as a 2-tuple */
+extern PyObject* _PyTraceMalloc_GetTracedRefs(void);
+
 /* Set the peak size of traced memory blocks to the current size */
 extern void _PyTraceMalloc_ResetPeak(void);
 

Lib/test/test_tracemalloc.py

@@ -4,6 +4,7 @@
 import textwrap
 import tracemalloc
 import unittest
+import warnings
 from unittest.mock import patch
 from test.support.script_helper import (assert_python_ok, assert_python_failure,
                                         interpreter_requires_environment)
@@ -1141,6 +1142,37 @@ def __del__(self, untrack=_testcapi.tracemalloc_untrack):
         """)
         assert_python_ok("-c", code)
 
+    def test_trace_refs(self):
+        def f():
+            l = []
+            del l
+
+        def g():
+            l = [], []
+            del l
+
+        tracemalloc.start()
+
+        try:
+            tracemalloc.clear_traces()
+            f()
+            refs = tracemalloc.get_traced_refs()
+            if refs == (1, 0):
+                warnings.warn("ceval Py_DECREF doesn't emit PyRefTracer_DESTROY in this build")
+            else:
+                self.assertEqual(refs, (1, 1))
+
+            tracemalloc.clear_traces()
+            g()
+            refs = tracemalloc.get_traced_refs()
+            if refs == (3, 2):
+                warnings.warn("ceval Py_DECREF doesn't emit PyRefTracer_DESTROY in this build")
+            else:
+                self.assertEqual(refs, (3, 3))
+
+        finally:
+            tracemalloc.stop()
+
 
 if __name__ == "__main__":
     unittest.main()

Modules/_tracemalloc.c

@@ -167,6 +167,23 @@ _tracemalloc_get_traced_memory_impl(PyObject *module)
     return _PyTraceMalloc_GetTracedMemory();
 }
 
+
+/*[clinic input]
+_tracemalloc.get_traced_refs
+
+Get the current count of created and destroyed refs.
+
+Returns a tuple: (created: int, destroyed: int).
+[clinic start generated code]*/
+
+static PyObject *
+_tracemalloc_get_traced_refs_impl(PyObject *module)
+/*[clinic end generated code: output=81d36fdeb3ffc362 input=d0652f2592733b0e]*/
+{
+    return _PyTraceMalloc_GetTracedRefs();
+}
+
+
 /*[clinic input]
 _tracemalloc.reset_peak
 
@@ -195,6 +212,7 @@ static PyMethodDef module_methods[] = {
     _TRACEMALLOC_GET_TRACEBACK_LIMIT_METHODDEF
     _TRACEMALLOC_GET_TRACEMALLOC_MEMORY_METHODDEF
     _TRACEMALLOC_GET_TRACED_MEMORY_METHODDEF
+    _TRACEMALLOC_GET_TRACED_REFS_METHODDEF
     _TRACEMALLOC_RESET_PEAK_METHODDEF
     /* sentinel */
     {NULL, NULL}

Modules/clinic/_tracemalloc.c.h

@@ -76,6 +76,8 @@ typedef struct {
 #define tracemalloc_tracebacks _PyRuntime.tracemalloc.tracebacks
 #define tracemalloc_traces _PyRuntime.tracemalloc.traces
 #define tracemalloc_domains _PyRuntime.tracemalloc.domains
+#define tracemalloc_refs_created _PyRuntime.tracemalloc.refs_created
+#define tracemalloc_refs_destroyed _PyRuntime.tracemalloc.refs_destroyed
 
 
 #ifdef TRACE_DEBUG
@@ -1258,6 +1260,10 @@ _PyTraceMalloc_TraceRef(PyObject *op, PyRefTracerEvent event,
                         void* Py_UNUSED(ignore))
 {
     if (event != PyRefTracer_CREATE) {
+        /* we don't want bother here with the lock for performance reasons */
+        if (_Py_atomic_load_int32_relaxed(&tracemalloc_config.tracing)) {
+            _Py_atomic_add_ssize((Py_ssize_t *)&tracemalloc_refs_destroyed, 1);
+        }
         return 0;
     }
     if (get_reentrant()) {
@@ -1271,6 +1277,8 @@ _PyTraceMalloc_TraceRef(PyObject *op, PyRefTracerEvent event,
         goto done;
     }
 
+    tracemalloc_refs_created += 1;
+
     PyTypeObject *type = Py_TYPE(op);
     const size_t presize = _PyType_PreHeaderSize(type);
     uintptr_t ptr = (uintptr_t)((char *)op - presize);
@@ -1326,6 +1334,8 @@ _PyTraceMalloc_ClearTraces(void)
     TABLES_LOCK();
     if (tracemalloc_config.tracing) {
         tracemalloc_clear_traces_unlocked();
+        tracemalloc_refs_created = 0;
+        tracemalloc_refs_destroyed = 0;
     }
     TABLES_UNLOCK();
 }
@@ -1464,6 +1474,25 @@ _PyTraceMalloc_GetTracedMemory(void)
     return Py_BuildValue("nn", traced, peak);
 }
 
+
+PyObject *
+_PyTraceMalloc_GetTracedRefs(void)
+{
+    TABLES_LOCK();
+    Py_ssize_t created, destroyed;
+    if (tracemalloc_config.tracing) {
+        created = tracemalloc_refs_created;
+        destroyed = tracemalloc_refs_destroyed;
+    }
+    else {
+        created = 0;
+        destroyed = 0;
+    }
+    TABLES_UNLOCK();
+
+    return Py_BuildValue("nn", created, destroyed);
+}
+
 void
 _PyTraceMalloc_ResetPeak(void)
 {