Compute sizes nearer to use, not in stats.

Author: markshannon

Include/internal/pycore_gc.h

@@ -158,8 +158,6 @@ struct gc_generation {
 };
 
 struct gc_collection_stats {
-    /* number of surviving objects */
-    Py_ssize_t survivors;
     /* number of collected objects */
     Py_ssize_t collected;
     /* total number of uncollectable objects (put into gc.garbage) */

Modules/gcmodule.c

@@ -472,16 +472,14 @@ validate_list_is_aging(PyGC_Head *head)
 /* Set all gc_refs = ob_refcnt.  After this, gc_refs is > 0 and
  * PREV_MASK_COLLECTING bit is set for all objects in containers.
  */
-static Py_ssize_t
+static void
 update_refs(PyGC_Head *containers)
 {
     PyGC_Head *next;
     PyGC_Head *gc = GC_NEXT(containers);
-    Py_ssize_t size = 0;
 
     while (gc != containers) {
         next = GC_NEXT(gc);
-        size++;
         /* Move any object that might have become immortal to the
          * permanent generation as the reference count is not accurately
          * reflecting the actual number of live references to this object
@@ -514,7 +512,6 @@ update_refs(PyGC_Head *containers)
         gc = next;
     }
 
-    return size;
 }
 
 /* A traversal callback for subtract_refs. */
@@ -1122,25 +1119,6 @@ clear_freelists(PyInterpreterState *interp)
     _PyContext_ClearFreeList(interp);
 }
 
-// Show stats for objects in each generations
-static void
-show_stats_each_generations(GCState *gcstate)
-{
-    char buf[100];
-    size_t pos = 0;
-
-    for (int i = 0; i < NUM_GENERATIONS && pos < sizeof(buf); i++) {
-        pos += PyOS_snprintf(buf+pos, sizeof(buf)-pos,
-                             " %zd",
-                             gc_list_size(GEN_HEAD(gcstate, i)));
-    }
-
-    PySys_FormatStderr(
-        "gc: objects in each generation:%s\n"
-        "gc: objects in permanent generation: %zd\n",
-        buf, gc_list_size(&gcstate->permanent_generation.head));
-}
-
 /* Deduce which objects among "base" are unreachable from outside the list
    and move them to 'unreachable'. The process consist in the following steps:
 
@@ -1168,15 +1146,15 @@ flag set but it does not clear it to skip unnecessary iteration. Before the
 flag is cleared (for example, by using 'clear_unreachable_mask' function or
 by a call to 'move_legacy_finalizers'), the 'unreachable' list is not a normal
 list and we can not use most gc_list_* functions for it. */
-static inline Py_ssize_t
+static inline void
 deduce_unreachable(PyGC_Head *base, PyGC_Head *unreachable) {
     validate_list(base, collecting_clear_unreachable_clear);
     /* Using ob_refcnt and gc_refs, calculate which objects in the
      * container set are reachable from outside the set (i.e., have a
      * refcount greater than 0 when all the references within the
      * set are taken into account).
      */
-    Py_ssize_t size = update_refs(base);  // gc_prev is used for gc_refs
+    update_refs(base);  // gc_prev is used for gc_refs
     subtract_refs(base);
 
     /* Leave everything reachable from outside base in base, and move
@@ -1218,7 +1196,6 @@ deduce_unreachable(PyGC_Head *base, PyGC_Head *unreachable) {
     move_unreachable(base, unreachable);  // gc_prev is pointer again
     validate_list(base, collecting_clear_unreachable_clear);
     validate_list(unreachable, collecting_set_unreachable_set);
-    return size;
 }
 
 /* Handle objects that may have resurrected after a call to 'finalize_garbage', moving
@@ -1263,22 +1240,28 @@ gc_collect_region(PyThreadState *tstate,
                   int untrack,
                   struct gc_collection_stats *stats);
 
-static void
+static Py_ssize_t
 make_space0(PyGC_Head *list)
 {
+    Py_ssize_t size = 0;
     PyGC_Head *gc;
     for (gc = GC_NEXT(list); gc != list; gc = GC_NEXT(gc)) {
         gc->_gc_prev &= ~_PyGC_PREV_MASK_OLD_SPACE_1;
+        size++;
     }
+    return size;
 }
 
-static void
+static Py_ssize_t
 make_space1(PyGC_Head *list)
 {
+    Py_ssize_t size = 0;
     PyGC_Head *gc;
     for (gc = GC_NEXT(list); gc != list; gc = GC_NEXT(gc)) {
         gc->_gc_prev |= _PyGC_PREV_MASK_OLD_SPACE_1;
+        size++;
     }
+    return size;
 }
 
 static void
@@ -1293,7 +1276,6 @@ static void
 gc_collect_young(PyThreadState *tstate,
                  struct gc_collection_stats *stats)
 {
-    assert(stats->survivors == 0);
     GCState *gcstate = &tstate->interp->gc;
     PyGC_Head *young = &gcstate->young.head;
     PyGC_Head *aging = &gcstate->old[gcstate->aging_space].head;
@@ -1311,25 +1293,26 @@ gc_collect_young(PyThreadState *tstate,
     gc_list_init(&survivors);
     gc_collect_region(tstate, young, &survivors, UNTRACK_TUPLES, stats);
     validate_old(gcstate);
+    Py_ssize_t surivivor_count = 0;
     if (gcstate->aging_space) {
-        make_space0(&survivors);
         /* objects in aging space have bit set, so we set it here */
-        make_space1(&survivors);
+        surivivor_count = make_space1(&survivors);
     }
-#ifdef GC_DEBUG
     else {
         PyGC_Head *gc;
         for (gc = GC_NEXT(&survivors); gc != &survivors; gc = GC_NEXT(gc)) {
+#ifdef GC_DEBUG
             assert((gc->_gc_prev & _PyGC_PREV_MASK_OLD_SPACE_1) == 0);
+#endif
+            surivivor_count++;
         }
     }
-#endif
     validate_old(gcstate);
     gc_list_merge(&survivors, aging);
     validate_old(gcstate);
     gcstate->young.count = 0;
     gcstate->old[gcstate->aging_space].count++;
-    gcstate->incremental_gc_progress -= stats->survivors;
+    gcstate->incremental_gc_progress -= surivivor_count;
     add_stats(gcstate, 0, stats);
 }
 
@@ -1343,13 +1326,14 @@ gc_collect_aging(PyThreadState *tstate,
     PyGC_Head *aging = &gcstate->old[gcstate->aging_space].head;
     PyGC_Head *oldest = &gcstate->old[gcstate->aging_space^1].head;
     /* Need to tag all objects as part of oldest generation */
+    Py_ssize_t size;
     if (gcstate->aging_space) {
         /* No need to tag young objects */
-        make_space0(aging);
+        size = make_space0(aging);
     }
     else {
         make_space1(young);
-        make_space1(aging);
+        size = make_space1(aging);
     }
     /* merge young in pending before collecting */
     gc_list_merge(young, aging);
@@ -1359,7 +1343,7 @@ gc_collect_aging(PyThreadState *tstate,
     gc_collect_region(tstate, aging, oldest,
                       UNTRACK_TUPLES, stats);
     validate_old(gcstate);
-    gcstate->incremental_gc_progress += stats->survivors + stats->collected;
+    gcstate->incremental_gc_progress += size;
     add_stats(gcstate, 1, stats);
 }
 
@@ -1373,18 +1357,19 @@ IS_IN_OLDEST(PyGC_Head *head, uintptr_t aging_space)
 struct container_and_flag {
     PyGC_Head *container;
     uintptr_t aging_space;
-    uintptr_t size;
 };
 
 /* A traversal callback for adding to container) */
 static int
 visit_add_to_container(PyObject *op, void *arg)
 {
     OBJECT_STAT_INC(object_visits);
+    struct container_and_flag *cf = (struct container_and_flag *)arg;
+    uintptr_t oldest_flag = cf->aging_space ^ _PyGC_PREV_MASK_OLD_SPACE_1;
     if (_PyObject_IS_GC(op)) {
-        struct container_and_flag *cf = (struct container_and_flag *)arg;
         PyGC_Head *gc = AS_GC(op);
-        if (_PyObject_GC_IS_TRACKED(op) && IS_IN_OLDEST(gc, cf->aging_space)) {
+        if (_PyObject_GC_IS_TRACKED(op) &&
+            (gc->_gc_prev & _PyGC_PREV_MASK_OLD_SPACE_1) == oldest_flag) {
             assert(!_Py_IsImmortal(op));
             gc->_gc_prev ^= _PyGC_PREV_MASK_OLD_SPACE_1;
             gc_list_move(gc, cf->container);
@@ -1431,11 +1416,6 @@ gc_collect_increment(PyThreadState *tstate, struct gc_collection_stats *stats)
     if (gcstate->incremental_gc_progress >= 0) {
         return;
     }
-    /* We rely on stats for controlling work done in incremental GC,
-     * so they need to zeroed */
-    assert(stats->survivors == 0);
-    assert(stats->collected == 0);
-    assert(stats->uncollectable == 0);
     PyGC_Head *oldest = &gcstate->old[gcstate->aging_space^1].head;
     PyGC_Head *aging = &gcstate->old[gcstate->aging_space].head;
     validate_old(gcstate);
@@ -1448,7 +1428,9 @@ gc_collect_increment(PyThreadState *tstate, struct gc_collection_stats *stats)
     validate_old(gcstate);
     if (gc_list_is_empty(oldest)) {
         if (gc_list_is_empty(aging)) {
-            gcstate->incremental_gc_progress = gcstate->young.threshold;
+            if (gcstate->incremental_gc_progress < gcstate->young.threshold) {
+                gcstate->incremental_gc_progress = gcstate->young.threshold;
+            }
             return;
         }
         /* aging is empty, so swap with oldest */
@@ -1460,6 +1442,7 @@ gc_collect_increment(PyThreadState *tstate, struct gc_collection_stats *stats)
     validate_old(gcstate);
     while (region_size < work_to_do) {
         if (gc_list_is_empty(oldest)) {
+            gcstate->incremental_gc_progress = 0;
             break;
         }
         PyGC_Head *gc = _PyGCHead_NEXT(oldest);
@@ -1473,10 +1456,8 @@ gc_collect_increment(PyThreadState *tstate, struct gc_collection_stats *stats)
     gc_collect_region(tstate, &increment, aging, 0, stats);
     validate_old(gcstate);
     assert(gc_list_is_empty(&increment));
-    Py_ssize_t work_done = stats->collected + stats->survivors + stats->uncollectable;
-    //fprintf(stderr, "Work done %d\n", (int)work_done);
-    gcstate->incremental_gc_progress += work_done;
-    //fprintf(stderr, "Incremental GC complete\n");
+    gcstate->incremental_gc_progress += region_size;
+    assert(gcstate->incremental_gc_progress >= 0);
     validate_old(gcstate);
     add_stats(gcstate, 1, stats);
 }
@@ -1508,7 +1489,7 @@ gc_collect_full(PyThreadState *tstate,
     gcstate->old[0].count = 0;
     gcstate->old[1].count = 0;
 
-    gcstate->incremental_gc_progress += stats->survivors + stats->collected;
+    gcstate->incremental_gc_progress = gcstate->young.threshold * 2;
     clear_freelists(tstate->interp);
     validate_old(gcstate);
     add_stats(gcstate, 2, stats);
@@ -1536,7 +1517,7 @@ gc_collect_region(PyThreadState *tstate,
 
     validate_list(to, collecting_clear_unreachable_clear);
 
-    Py_ssize_t processed = deduce_unreachable(from, &unreachable);
+    deduce_unreachable(from, &unreachable);
     if (untrack & UNTRACK_TUPLES) {
         untrack_tuples(from);
     }
@@ -1609,7 +1590,6 @@ gc_collect_region(PyThreadState *tstate,
     handle_legacy_finalizers(tstate, gcstate, &finalizers, to);
     validate_list(to, collecting_clear_unreachable_clear);
 
-    stats->survivors = processed - m - n;
     stats->collected = m;
     stats->uncollectable = n;
     validate_old(gcstate);
@@ -2169,7 +2149,7 @@ gc.unfreeze
 
 Unfreeze all objects in the permanent generation.
 
-Put all objects in the permanent generation back into old[0].
+Put all objects in the permanent generation back into oldest generation.
 [clinic start generated code]*/
 
 static PyObject *