Revert to 2M+I from 3M+I

python · markshannon · Dec 6, 2024 · Nov 9, 2024 · Nov 10, 2024 · Nov 11, 2024
commit 72d0284492ff0adc8e15e01e8a819853f1d1a85a
diff --git a/InternalDocs/garbage_collector.md b/InternalDocs/garbage_collector.md
@@ -541,13 +541,13 @@ garbage. Also, note that `T == M + I` where `M` is the number of objects marked
 as reachable and `I` is the number of objects visited in increments.
 Everything in `M` is live, so `I ≥ G0` and in practice `I` is closer to `G0 + G1`.
 
-If we choose the amount of work done such that `3*M + I == 8N` then we can do
+If we choose the amount of work done such that `2*M + I == 6N` then we can do
 do less work in most cases, but are still guaranteed to keep up.
 Since `I ≥ G0 + G1` (not strictly true, but close enough)
-Since `I ≥ G0 + G1` (not strictly true, but close enough)
+Since `I ≈ G0 + G1` (not strictly true, but close enough)
-Since `I ≥ G0 + G1` (not strictly true, but close enough)
+Since `I ≈ G0 + G1` (not strictly true, but close enough)
-`T == M + I == (8N + 2I)/3` and `(8N + 2I)/3 ≥ 4G`, so we can keep up.
+`T == M + I == (6N + I)/2` and `(6N + I)/2 ≥ 4G`, so we can keep up.
-`T == M + I == (6N + I)/2` and `(6N + I)/2 ≥ 4G`, so we can keep up.
+`T == M + I == (6N + I)/2` and `(6N + I)/2 ≳ 4G`, so we can keep up.
-`T == M + I == (6N + I)/2` and `(6N + I)/2 ≥ 4G`, so we can keep up.
+`T == M + I == (6N + I)/2` and `(6N + I)/2 ≳ 4G`, so we can keep up.
 
 The reason that this improves performance is that `M` is usually much larger
-than `I` Suppose `M == 10I`, then `T < 3N`.
+than `I` Suppose `M == 10I`, then `T ≅ 3N`.
-than `I` Suppose `M == 10I`, then `T ≅ 3N`.
+than `I`. If `M == 10I`, then `T ≅ 3N`.
-than `I` Suppose `M == 10I`, then `T ≅ 3N`.
+than `I`. If `M == 10I`, then `T ≅ 3N`.
 
 Finally, instead of using a fixed multiple of 8, we gradually increase it as the
 heap grows. This avoids wasting work for small heaps and during startup.

diff --git a/Python/gc.c b/Python/gc.c
@@ -1566,7 +1566,7 @@ assess_work_to_do(GCState *gcstate)
         scale_factor = 2;
     }
     intptr_t new_objects = gcstate->young.count;
-    intptr_t max_heap_fraction = new_objects*7;
+    intptr_t max_heap_fraction = new_objects*5;
     intptr_t heap_fraction = gcstate->heap_size / SCAN_RATE_DIVISOR / scale_factor;
     if (heap_fraction > max_heap_fraction) {
         heap_fraction = max_heap_fraction;
@@ -1575,7 +1575,8 @@ assess_work_to_do(GCState *gcstate)
     return new_objects + heap_fraction;
 }
 
-#define MARKING_PROGRESS_MULTIPLIER 3
+/* See Internal GC docs for explanation */
+#define MARKING_PROGRESS_MULTIPLIER 2
 
 static void
 gc_collect_increment(PyThreadState *tstate, struct gc_collection_stats *stats)