@@ -193,6 +193,9 @@ struct gc_generation_stats {
     /* total number of uncollectable objects (put into gc.garbage) */
     Py_ssize_t uncollectable;
     Py_ssize_t untracked_tuples;
+    Py_ssize_t total_untracked_tuples;
+    Py_ssize_t total_tuples;
+    Py_ssize_t tuples_by_size[33];
 };
 
 enum _GCPhase {
 
@@ -22,6 +22,44 @@ class tuple "PyTupleObject *" "&PyTuple_Type"
 
 static inline int maybe_freelist_push(PyTupleObject *);
 
+static uint8_t
+_log2_int(Py_ssize_t size)
+{
+    if (size == 0) {
+        return 0;
+    }
+
+    const uint64_t b[] = {0x2, 0xC, 0xF0, 0xFF00, 0xFFFF0000, 0xFFFFFFFF00000000};
+    const uint64_t S[] = {1, 2, 4, 8, 16, 32};
+
+    int64_t v = size;
+    uint8_t r = 0; // result of log2(v) will go here
+    for (int i = 5; i >= 0; i--) // unroll for speed...
+    {
+        if (v & b[i])
+        {
+            v >>= S[i];
+            r |= S[i];
+        }
+    }
+
+#ifdef Py_DEBUG
+    uint8_t x = (uint8_t)log2((double)size);
+    assert(x == r);
+#endif
+
+    return r + 1;
+}
+
+static void
+_count_tuple(Py_ssize_t size)
+{
+    PyInterpreterState *interp = _PyInterpreterState_GET();
+    interp->gc.generation_stats[0].total_tuples += 1;
+    uint8_t size_index = _log2_int(size);
+    interp->gc.generation_stats[0].tuples_by_size[size_index] += 1;
+}
+
 
 /* Allocate an uninitialized tuple object. Before making it public, following
    steps must be done:
@@ -46,6 +84,7 @@ tuple_alloc(Py_ssize_t size)
         PyTupleObject *op = _Py_FREELIST_POP(PyTupleObject, tuples[index]);
         if (op != NULL) {
             _PyTuple_RESET_HASH_CACHE(op);
+            _count_tuple(size);
             return op;
         }
     }
@@ -57,6 +96,7 @@ tuple_alloc(Py_ssize_t size)
     PyTupleObject *result = PyObject_GC_NewVar(PyTupleObject, &PyTuple_Type, size);
     if (result != NULL) {
         _PyTuple_RESET_HASH_CACHE(result);
+        _count_tuple(size);
     }
     return result;
 }
@@ -68,6 +108,7 @@ tuple_alloc(Py_ssize_t size)
 static inline PyObject *
 tuple_get_empty(void)
 {
+    _count_tuple(0);
     return (PyObject *)&_Py_SINGLETON(tuple_empty);
 }
 
 
@@ -2101,6 +2101,7 @@ _PyGC_Collect(PyThreadState *tstate, int generation, _PyGC_Reason reason)
             Py_UNREACHABLE();
     }
     gcstate->generation_stats[generation].untracked_tuples += stats.untracked_tuples;
+    gcstate->generation_stats[0].total_untracked_tuples += stats.untracked_tuples;
     if (PyDTrace_GC_DONE_ENABLED()) {
         PyDTrace_GC_DONE(stats.uncollectable + stats.collected);
     }
@@ -2109,6 +2110,13 @@ _PyGC_Collect(PyThreadState *tstate, int generation, _PyGC_Reason reason)
     }
     else {
         FILE *out = stderr;
+
+        fprintf(out, "GC[%d] total tuples    : %zd\n", 0, gcstate->generation_stats[0].total_tuples);
+        fprintf(out, "GC[%d] total untracked_tuples    : %zd\n", 0, gcstate->generation_stats[0].total_untracked_tuples);
+        for (int i = 0; i < 33; i++) {
+            fprintf(out, "GC[%d] by size %d  : %zd\n", 0, i, gcstate->generation_stats[0].tuples_by_size[i]);
+        }
+
         for (int i = 0; i < NUM_GENERATIONS; i++) {
             fprintf(out, "GC[%d] collections     : %zd\n", i, gcstate->generation_stats[i].collections);
             fprintf(out, "GC[%d] collected       : %zd\n", i, gcstate->generation_stats[i].collected);