@@ -269,14 +269,64 @@ struct gc_generation {
                   generations */
 };
 
+/* Stock 3.13's three counters.  The generation_counters[] array below keeps
+   this type and therefore its original 24 bytes at its original offset, so
+   that _gc_runtime_state's layout is byte-identical to an unpatched build.
+   It is still maintained, so an extension compiled against stock headers
+   that reads it keeps reading correct values. */
+struct gc_generation_counters {
+    /* total number of collections */
+    Py_ssize_t collections;
+    /* total number of collected objects */
+    Py_ssize_t collected;
+    /* total number of uncollectable objects (put into gc.garbage) */
+    Py_ssize_t uncollectable;
+};
+
 /* Running stats per generation */
 struct gc_generation_stats {
+    PyTime_t ts_start;
+    PyTime_t ts_stop;
     /* total number of collections */
     Py_ssize_t collections;
     /* total number of collected objects */
     Py_ssize_t collected;
     /* total number of uncollectable objects (put into gc.garbage) */
     Py_ssize_t uncollectable;
+    // Total number of objects considered for collection and traversed:
+    Py_ssize_t candidates;
+    // Total duration of the collection in seconds:
+    double duration;
+    /* heap_size on the start of the collection */
+    Py_ssize_t heap_size;
+};
+
+#ifdef Py_GIL_DISABLED
+#define GC_YOUNG_STATS_SIZE 1
+#define GC_OLD_STATS_SIZE 1
+#else
+#define GC_YOUNG_STATS_SIZE 11
+#define GC_OLD_STATS_SIZE 3
+#endif
+struct gc_young_stats_buffer {
+    struct gc_generation_stats items[GC_YOUNG_STATS_SIZE];
+    int8_t index;
+};
+
+struct gc_old_stats_buffer {
+    struct gc_generation_stats items[GC_OLD_STATS_SIZE];
+    int8_t index;
+};
+
+/* Ring buffers of per-collection statistics, published to external readers.
+   Upstream 3.15 keeps a struct gc_stats* here in _gc_runtime_state; this tree
+   heap-allocates one too, but hangs the pointer off the tail of
+   PyInterpreterState instead -- see the Deviations note in
+   patches/gc-stats.patch for why _gc_runtime_state cannot carry it. */
+struct gc_stats {
+    struct gc_young_stats_buffer young;
+    struct gc_old_stats_buffer old[2];
+    uint32_t update_seq;
 };
 
 struct _gc_runtime_state {
@@ -294,7 +344,7 @@ struct _gc_runtime_state {
     PyGC_Head *generation0;
     /* a permanent generation which won't be collected */
     struct gc_generation permanent_generation;
-    struct gc_generation_stats generation_stats[NUM_GENERATIONS];
+    struct gc_generation_counters generation_counters[NUM_GENERATIONS];
     /* true if we are currently running the collector */
     int collecting;
     /* list of uncollectable objects */
 
@@ -277,6 +277,15 @@ struct _is {
     Py_ssize_t _interactive_src_count;
     // In 3.14+ this is interp->threads.preallocated.
     _PyThreadStateImpl *threads_preallocated;
+
+    /* Heap-allocated ring of per-collection GC statistics, published to
+       external readers.  Upstream 3.15 keeps this pointer in _gc_runtime_state
+       (interp->gc); this tree cannot, because _gc_runtime_state sits mid-struct
+       with sixty-one members after it, so growing it would move every one of
+       their offsets.  Appended at the very tail of PyInterpreterState instead,
+       which grows sizeof(PyInterpreterState) by one pointer and moves nothing.
+       See the Deviations note in patches/gc-stats.patch. */
+    struct gc_stats *generation_stats;
 };
 
 
 
@@ -806,11 +806,15 @@ def test_get_stats(self):
         self.assertEqual(len(stats), 3)
         for st in stats:
             self.assertIsInstance(st, dict)
-            self.assertEqual(set(st),
-                             {"collected", "collections", "uncollectable"})
+            self.assertEqual(
+                set(st),
+                {"collected", "collections", "uncollectable", "candidates", "duration"}
+            )
             self.assertGreaterEqual(st["collected"], 0)
             self.assertGreaterEqual(st["collections"], 0)
             self.assertGreaterEqual(st["uncollectable"], 0)
+            self.assertGreaterEqual(st["candidates"], 0)
+            self.assertGreaterEqual(st["duration"], 0)
         # Check that collection counts are incremented correctly
         if gc.isenabled():
             self.addCleanup(gc.enable)
@@ -821,11 +825,25 @@ def test_get_stats(self):
         self.assertEqual(new[0]["collections"], old[0]["collections"] + 1)
         self.assertEqual(new[1]["collections"], old[1]["collections"])
         self.assertEqual(new[2]["collections"], old[2]["collections"])
+        self.assertGreater(new[0]["duration"], old[0]["duration"])
+        self.assertEqual(new[1]["duration"], old[1]["duration"])
+        self.assertEqual(new[2]["duration"], old[2]["duration"])
+        for stat in ["collected", "uncollectable", "candidates"]:
+            self.assertGreaterEqual(new[0][stat], old[0][stat])
+            self.assertEqual(new[1][stat], old[1][stat])
+            self.assertEqual(new[2][stat], old[2][stat])
         gc.collect(2)
-        new = gc.get_stats()
-        self.assertEqual(new[0]["collections"], old[0]["collections"] + 1)
+        old, new = new, gc.get_stats()
+        self.assertEqual(new[0]["collections"], old[0]["collections"])
         self.assertEqual(new[1]["collections"], old[1]["collections"])
         self.assertEqual(new[2]["collections"], old[2]["collections"] + 1)
+        self.assertEqual(new[0]["duration"], old[0]["duration"])
+        self.assertEqual(new[1]["duration"], old[1]["duration"])
+        self.assertGreater(new[2]["duration"], old[2]["duration"])
+        for stat in ["collected", "uncollectable", "candidates"]:
+            self.assertEqual(new[0][stat], old[0][stat])
+            self.assertEqual(new[1][stat], old[1][stat])
+            self.assertGreaterEqual(new[2][stat], old[2][stat])
 
     def test_freeze(self):
         gc.freeze()