YRC: refinements plus a benchmark that is more realistic

tests/benchmarks/yrcbech.nim

@@ -8,28 +8,32 @@ discard """
 ##
 ## Each thread runs its own private copy of the torcbench workload: one long
 ## doubly-linked list of strings, and a stream of short-lived cyclic trees
-## whose every node embeds a copy of the list header — that is two references
+## whose every node embeds a copy of the list header — that is a reference
 ## into the list per tree node. Nothing is shared between threads, so the same
 ## program is a fair measurement under --mm:orc and --mm:yrc.
 ##
-## Three changes vs torcbench, each needed to make the young -> old pattern
+## Two changes vs torcbench, each needed to make the young -> old pattern
 ## measurable rather than incidental:
 ##
 ## 1. The list is built once per THREAD, not once per outer iteration, so it
 ##    survives long enough to be promoted. It is the old generation; the trees
 ##    are the young one.
-## 2. A seed phase traces and stamps the list before the tree traffic starts.
-##    Needed because `flagDirty` is per-SCC and the list is ONE SCC: once trees
-##    are churning, every `parent` copy touches head and tail, so the SCC is
-##    permanently dirty and would never get stamped. Promoting it first makes
-##    the stamp carry it through the young phase.
-## 3. Collection runs at a fixed cadence (GC_partialCollect per outer
+## 2. Collection runs at a fixed cadence (GC_partialCollect per outer
 ##    iteration) instead of being left to each collector's threshold
 ##    heuristic. Without this the benchmark measures how often each collector
 ##    decides to collect rather than what a collection over this heap costs —
 ##    and ORC's threshold scales with heap size, so a bigger list makes it
 ##    collect LESS and the re-trace it is supposed to be paying never appears.
 ##
+## Nothing seeds the promotion: the tree stream itself is what ages the list,
+## which is why the workload can stay an ordinary one. `DoublyLinkedNode.prev`
+## and `DoublyLinkedList.tail` are `{.cursor.}`, so copying a `parent` header
+## incRefs `head` alone, and the list is a chain of one-node SCCs rather than
+## a single big one. Dirtiness is per-SCC, so the churn only ever dirties
+## `head`; every node behind it is traced clean by the collections the trees
+## trigger anyway and promotes after YrcPromoteAge of them. The capture then
+## prunes one edge in — at `head.next` — instead of walking 60000 nodes.
+##
 ##   --mm:orc  every collection follows `parent` into the list and re-traces
 ##             all ListLen nodes of it.
 ##   --mm:yrc  once the list is promoted, capture prunes at the epoch-stamp
@@ -41,8 +45,8 @@ discard """
 ## the default because 8 threads on a 4-performance-core machine dilutes the
 ## result (1.15x vs 1.69x measured on an M1).
 ##
-##   nim c -r --mm:orc -d:release --threads:on yrcbench.nim
-##   nim c -r --mm:yrc -d:release --threads:on yrcbench.nim
+##   nim c -r --mm:orc -d:release --threads:on yrcbech.nim
+##   nim c -r --mm:yrc -d:release --threads:on yrcbech.nim
 ##
 ## Add -d:yrcBenchTime for a wall-clock line, -d:nimOrcStats for capture and
 ## prune counts (YRC only).
@@ -55,23 +59,13 @@ const
   ListLen    {.intdefine.} = 60000  ## the old generation
   TreeIters  {.intdefine.} = 50     ## young trees per collection
   TreeDepth  {.intdefine.} = 8
-  SeedProbes {.intdefine.} = 6      ## must exceed YrcPromoteAge (default 3)
 
 type
   Node = ref object
-    parent: DoublyLinkedList[string]  ## copy of the header: 2 refs into the list
+    parent: DoublyLinkedList[string]  ## copy of the header: a ref into the list
     le, ri: Node
     self: Node                        ## self-cycle, forces cycle detection
 
-  Holder = ref object
-    ## Cyclic handle on the list, used only to get the list traced during the
-    ## seed phase. A plain reference would never be registered as a cycle
-    ## candidate; the self-edge is what makes it one.
-    list: DoublyLinkedList[string]
-    self: Holder
-
-var probeSlot {.threadvar.}: Holder
-
 proc buildTree(parent: DoublyLinkedList[string]; depth: int): Node =
   if depth == 0:
     result = nil
@@ -90,21 +84,10 @@ proc threadWork() {.thread.} =
   for j in 1 .. ListLen:
     leakList.append(newString(200))
 
-  # (2) seed phase: age the list past the promotion threshold while nothing
-  # else is churning. GC_partialCollect, not GC_fullCollect — the latter
-  # advances the epoch and wipes the stamps this depends on.
-  block:
-    let holder = Holder(list: leakList)
-    holder.self = holder
-    for _ in 1 .. SeedProbes:
-      probeSlot = holder
-      probeSlot = nil
-      GC_partialCollect(0)
-
   for i in 1 .. OuterIters:
     for k in 0 .. TreeIters:
       discard buildTree(leakList, TreeDepth)   # young: dead the moment it returns
-    GC_partialCollect(0)                       # (3) fixed cadence
+    GC_partialCollect(0)                       # (2) fixed cadence
 
 var threads: array[NumThreads, Thread[void]]