revert to refs_created/_destroyed, other tweaks

Author: tom-pytel

Doc/library/tracemalloc.rst

@@ -331,10 +331,12 @@ Functions
    :mod:`tracemalloc` module as a tuple: ``(current: int, peak: int)``.
 
 
-.. function:: get_traced_allocs()
+.. function:: get_traced_refs()
 
-   Get the current unit counts of allocated and deallocated memory blocks.
-   :mod:`tracemalloc` module as a tuple: ``(allocs: int, deallocs: int)``.
+   Get the current count of created and destroyed traced references.
+   :mod:`tracemalloc` module as a tuple: ``(created: int, destroyed: int)``.
+
+   .. versionadded:: next
 
 
 .. function:: reset_peak()

Include/internal/pycore_tracemalloc.h

@@ -94,12 +94,12 @@ struct _tracemalloc_runtime_state {
     /* domain (unsigned int) => traces (_Py_hashtable_t).
        Protected by TABLES_LOCK(). */
     _Py_hashtable_t *domains;
-    /* Number of allocations.
+    /* Number of references created.
        Protected by TABLES_LOCK(). */
-    Py_ssize_t allocations;
-    /* Number of deallocations.
+    Py_ssize_t refs_created;
+    /* Number of references destroyed.
        Protected by TABLES_LOCK() and sometimes modified atomically. */
-    Py_ssize_t deallocations;
+    Py_ssize_t refs_destroyed;
 
     struct tracemalloc_traceback empty_traceback;
 
@@ -162,7 +162,7 @@ extern size_t _PyTraceMalloc_GetMemory(void);
 extern PyObject* _PyTraceMalloc_GetTracedMemory(void);
 
 /* Get the current number of references created and destroyed as a 2-tuple */
-extern PyObject* _PyTraceMalloc_GetTracedAllocs(void);
+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

@@ -1156,15 +1156,15 @@ def g():
         try:
             tracemalloc.clear_traces()
             f()
-            refs = tracemalloc.get_traced_allocs()
+            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_allocs()
+            refs = tracemalloc.get_traced_refs()
             if refs == (3, 2):
                 warnings.warn("ceval Py_DECREF doesn't emit PyRefTracer_DESTROY in this build")
             else:

Modules/_tracemalloc.c

@@ -169,18 +169,18 @@ _tracemalloc_get_traced_memory_impl(PyObject *module)
 
 
 /*[clinic input]
-_tracemalloc.get_traced_allocs
+_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_allocs_impl(PyObject *module)
-/*[clinic end generated code: output=cb84cbd781fab85f input=336f38d37a5830ef]*/
+_tracemalloc_get_traced_refs_impl(PyObject *module)
+/*[clinic end generated code: output=81d36fdeb3ffc362 input=d0652f2592733b0e]*/
 {
-    return _PyTraceMalloc_GetTracedAllocs();
+    return _PyTraceMalloc_GetTracedRefs();
 }
 
 
@@ -212,7 +212,7 @@ static PyMethodDef module_methods[] = {
     _TRACEMALLOC_GET_TRACEBACK_LIMIT_METHODDEF
     _TRACEMALLOC_GET_TRACEMALLOC_MEMORY_METHODDEF
     _TRACEMALLOC_GET_TRACED_MEMORY_METHODDEF
-    _TRACEMALLOC_GET_TRACED_ALLOCS_METHODDEF
+    _TRACEMALLOC_GET_TRACED_REFS_METHODDEF
     _TRACEMALLOC_RESET_PEAK_METHODDEF
     /* sentinel */
     {NULL, NULL}

Modules/clinic/_tracemalloc.c.h

@@ -76,8 +76,8 @@ typedef struct {
 #define tracemalloc_tracebacks _PyRuntime.tracemalloc.tracebacks
 #define tracemalloc_traces _PyRuntime.tracemalloc.traces
 #define tracemalloc_domains _PyRuntime.tracemalloc.domains
-#define tracemalloc_allocations _PyRuntime.tracemalloc.allocations
-#define tracemalloc_deallocations _PyRuntime.tracemalloc.deallocations
+#define tracemalloc_refs_created _PyRuntime.tracemalloc.refs_created
+#define tracemalloc_refs_destroyed _PyRuntime.tracemalloc.refs_destroyed
 
 
 #ifdef TRACE_DEBUG
@@ -1255,48 +1255,47 @@ _PyTraceMalloc_Fini(void)
 
    Do nothing if tracemalloc is not tracing memory allocations
    or if the object memory block is not already traced. */
-static int
-_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_int_relaxed(&tracemalloc_config.tracing)) {
-            _Py_atomic_add_ssize(&tracemalloc_deallocations, 1);
-        }
-        return 0;
-    }
-    if (get_reentrant()) {
-        return 0;
-    }
-
-    _Py_AssertHoldsTstate();
-    TABLES_LOCK();
-
-    if (!tracemalloc_config.tracing) {
-        goto done;
-    }
-
-    tracemalloc_allocations += 1;
-
-    PyTypeObject *type = Py_TYPE(op);
-    const size_t presize = _PyType_PreHeaderSize(type);
-    uintptr_t ptr = (uintptr_t)((char *)op - presize);
-
-    trace_t *trace = _Py_hashtable_get(tracemalloc_traces, TO_PTR(ptr));
-    if (trace != NULL) {
-        /* update the traceback of the memory block */
-        traceback_t *traceback = traceback_new();
-        if (traceback != NULL) {
-            trace->traceback = traceback;
-        }
-    }
-    /* else: cannot track the object, its memory block size is unknown */
-
-done:
-    TABLES_UNLOCK();
-    return 0;
-}
+   static int
+   _PyTraceMalloc_TraceRef(PyObject *op, PyRefTracerEvent event,
+                           void* Py_UNUSED(ignore))
+   {
+       if (get_reentrant()) {
+           return 0;
+       }
+
+       _Py_AssertHoldsTstate();
+       TABLES_LOCK();
+
+       if (!tracemalloc_config.tracing) {
+           goto done;
+       }
+
+       if (event == PyRefTracer_CREATE) {
+           tracemalloc_refs_created += 1;
+       }
+       else {
+           tracemalloc_refs_destroyed += 1;
+           goto done;
+       }
+
+       PyTypeObject *type = Py_TYPE(op);
+       const size_t presize = _PyType_PreHeaderSize(type);
+       uintptr_t ptr = (uintptr_t)((char *)op - presize);
+
+       trace_t *trace = _Py_hashtable_get(tracemalloc_traces, TO_PTR(ptr));
+       if (trace != NULL) {
+           /* update the traceback of the memory block */
+           traceback_t *traceback = traceback_new();
+           if (traceback != NULL) {
+               trace->traceback = traceback;
+           }
+       }
+       /* else: cannot track the object, its memory block size is unknown */
+
+   done:
+       TABLES_UNLOCK();
+       return 0;
+   }
 
 
 PyObject*
@@ -1334,8 +1333,8 @@ _PyTraceMalloc_ClearTraces(void)
     TABLES_LOCK();
     if (tracemalloc_config.tracing) {
         tracemalloc_clear_traces_unlocked();
-        tracemalloc_allocations = 0;
-        tracemalloc_deallocations = 0;
+        tracemalloc_refs_created = 0;
+        tracemalloc_refs_destroyed = 0;
     }
     TABLES_UNLOCK();
 }
@@ -1476,21 +1475,21 @@ _PyTraceMalloc_GetTracedMemory(void)
 
 
 PyObject *
-_PyTraceMalloc_GetTracedAllocs(void)
+_PyTraceMalloc_GetTracedRefs(void)
 {
     TABLES_LOCK();
-    Py_ssize_t allocations, deallocations;
+    Py_ssize_t created, destroyed;
     if (tracemalloc_config.tracing) {
-        allocations = tracemalloc_allocations;
-        deallocations = tracemalloc_deallocations;
+        created = tracemalloc_refs_created;
+        destroyed = tracemalloc_refs_destroyed;
     }
     else {
-        allocations = 0;
-        deallocations = 0;
+        created = 0;
+        destroyed = 0;
     }
     TABLES_UNLOCK();
 
-    return Py_BuildValue("nn", allocations, deallocations);
+    return Py_BuildValue("nn", created, destroyed);
 }
 
 void