FAILURE MAP
← Case archive

FA-90746 / Garbage collector invariants / Open access

Remembered sets: continuation regions get their own sets · case 01

References into the tail of a humongous object are filed under a continuation region nobody scans.

Verified by executionVariant 1 · 6 checks per implementationDownload source bundle ↓JSON ↗

ROOT CAUSE

The target region is not mapped back to the humongous start region.

VERIFIED REPAIR

Walk back from continuation regions to the region where the humongous object starts.

Unsuccessful approach: Stepping back a single region is wrong for objects spanning three or more regions.

Case contract

Region-based remembered sets. kinds[r] is young, old, humongous or hcont (a continuation region of the humongous object that starts in the nearest preceding humongous region). For each write [slot, value]: null values are ignored; the target region is the region of value, mapped from continuations back to the humongous start; writes within one region and writes whose slot is in a young region are filtered; otherwise the slot's card index (slot // card) is added to the target region's set. Return the remembered sets.

Why this case matters

Remembered-set filtering decides which cross-region pointers an evacuation will find.

1 / The failure

Exit 1
"""Failure Map reference implementation. Python standard library only."""
import json

N = 1
observations = []
def solve(kinds, region_size, card, writes):
    remsets = {}
    for slot, val in writes:
        if val is None:
            continue
        src, dst = slot // region_size, val // region_size
        if src == dst:
            continue
        if kinds[src] == 'young':
            continue
        remsets.setdefault(dst, set()).add(slot // card)
    return {str(k): sorted(v) for k, v in sorted(remsets.items())}
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
cases = [[('regression: old-to-young and old-to-old writes',
   (['old', 'young', 'old', 'humongous', 'hcont', 'hcont', 'old', 'young'],
    1024,
    128,
    [[8, 1040], [2056, 6152], [6452, 7168]]),
   {'1': [0], '6': [16], '7': [50]}),
  ('pointer within the same region',
   (['old', 'young', 'old', 'humongous', 'hcont', 'hcont', 'old', 'young'],
    1024,
    128,
    [[2056, 2948], [3048, 2056]]),
   {}),
  ('neighbouring addresses across a region boundary',
   (['old', 'young', 'old', 'humongous', 'hcont', 'hcont', 'old', 'young'],
    1024,
    128,
    [[1016, 1040], [3056, 2032]]),
   {'1': [7, 23]}),
  ('writes from young regions are filtered',
   (['old', 'young', 'old', 'humongous', 'hcont', 'hcont', 'old', 'young'],
    1024,
    128,
    [[1032, 0], [7208, 2048], [1032, 7168]]),
   {}),
  ('pointer into a humongous continuation',
   (['old', 'young', 'old', 'humongous', 'hcont', 'hcont', 'old', 'young'],
    1024,
    128,
    [[8, 5220], [6144, 4104]]),
   {'3': [0, 48]}),
  ('null writes',
   (['old', 'young', 'old', 'humongous', 'hcont', 'hcont', 'old', 'young'],
    1024,
    128,
    [[8, None], [6144, None], [2112, 3072]]),
   {'3': [16]})],
 [('regression: old-to-young and old-to-old writes',
   (['old', 'young', 'old', 'humongous', 'hcont', 'hcont', 'old', 'young'],
    1024,
    128,
    [[16, 1040], [2064, 6152], [6460, 7168]]),
   {'1': [0], '6': [16], '7': [50]}),
  ('pointer within the same region',
   (['old', 'young', 'old', 'humongous', 'hcont', 'hcont', 'old', 'young'],
    1024,
    128,
    [[2064, 2948], [3048, 2056]]),
   {}),
  ('neighbouring addresses across a region boundary',
   (['old', 'young', 'old', 'humongous', 'hcont', 'hcont', 'old', 'young'],
    1024,
    128,
    [[1016, 1048], [3056, 2032]]),
   {'1': [7, 23]}),
  ('writes from young regions are filtered',
   (['old', 'young', 'old', 'humongous', 'hcont', 'hcont', 'old', 'young'],
    1024,
    128,
    [[1040, 0], [7208, 2048], [1032, 7168]]),
   {}),
  ('pointer into a humongous continuation',
   (['old', 'young', 'old', 'humongous', 'hcont', 'hcont', 'old', 'young'],
    1024,
    128,
    [[16, 5220], [6144, 4104]]),
   {'3': [0, 48]}),
  ('null writes',
   (['old', 'young', 'old', 'humongous', 'hcont', 'hcont', 'old', 'young'],
    1024,
    128,
    [[16, None], [6144, None], [2112, 3072]]),
   {'3': [16]})],
 [('regression: old-to-young and old-to-old writes',
   (['old', 'young', 'old', 'humongous', 'hcont', 'hcont', 'old', 'young'],
    1024,
    128,
    [[24, 1040], [2072, 6152], [6468, 7168]]),
   {'1': [0], '6': [16], '7': [50]}),
  ('pointer within the same region',
   (['old', 'young', 'old', 'humongous', 'hcont', 'hcont', 'old', 'young'],
    1024,
    128,
    [[2072, 2948], [3048, 2056]]),
   {}),
  ('neighbouring addresses across a region boundary',
   (['old', 'young', 'old', 'humongous', 'hcont', 'hcont', 'old', 'young'],
    1024,
    128,
    [[1016, 1056], [3056, 2032]]),
   {'1': [7, 23]}),
  ('writes from young regions are filtered',
   (['old', 'young', 'old', 'humongous', 'hcont', 'hcont', 'old', 'young'],
    1024,
    128,
    [[1048, 0], [7208, 2048], [1032, 7168]]),
   {}),
  ('pointer into a humongous continuation',
   (['old', 'young', 'old', 'humongous', 'hcont', 'hcont', 'old', 'young'],
    1024,
    128,
    [[24, 5220], [6144, 4104]]),
   {'3': [0, 48]}),
  ('null writes',
   (['old', 'young', 'old', 'humongous', 'hcont', 'hcont', 'old', 'young'],
    1024,
    128,
    [[24, None], [6144, None], [2112, 3072]]),
   {'3': [16]})],
 [('regression: old-to-young and old-to-old writes',
   (['old', 'young', 'old', 'humongous', 'hcont', 'hcont', 'old', 'young'],
    1024,
    128,
    [[32, 1040], [2080, 6152], [6476, 7168]]),
   {'1': [0], '6': [16], '7': [50]}),
  ('pointer within the same region',
   (['old', 'young', 'old', 'humongous', 'hcont', 'hcont', 'old', 'young'],
    1024,
    128,
    [[2080, 2948], [3048, 2056]]),
   {}),
  ('neighbouring addresses across a region boundary',
   (['old', 'young', 'old', 'humongous', 'hcont', 'hcont', 'old', 'young'],
    1024,
    128,
    [[1016, 1064], [3056, 2032]]),
   {'1': [7, 23]}),
  ('writes from young regions are filtered',
   (['old', 'young', 'old', 'humongous', 'hcont', 'hcont', 'old', 'young'],
    1024,
    128,
    [[1056, 0], [7208, 2048], [1032, 7168]]),
   {}),
  ('pointer into a humongous continuation',
   (['old', 'young', 'old', 'humongous', 'hcont', 'hcont', 'old', 'young'],
    1024,
    128,
    [[32, 5220], [6144, 4104]]),
   {'3': [0, 48]}),
  ('null writes',
   (['old', 'young', 'old', 'humongous', 'hcont', 'hcont', 'old', 'young'],
    1024,
    128,
    [[32, None], [6144, None], [2112, 3072]]),
   {'3': [16]})],
 [('regression: old-to-young and old-to-old writes',
   (['old', 'young', 'old', 'humongous', 'hcont', 'hcont', 'old', 'young'],
    1024,
    128,
    [[40, 1040], [2088, 6152], [6484, 7168]]),
   {'1': [0], '6': [16], '7': [50]}),
  ('pointer within the same region',
   (['old', 'young', 'old', 'humongous', 'hcont', 'hcont', 'old', 'young'],
    1024,
    128,
    [[2088, 2948], [3048, 2056]]),
   {}),
  ('neighbouring addresses across a region boundary',
   (['old', 'young', 'old', 'humongous', 'hcont', 'hcont', 'old', 'young'],
    1024,
    128,
    [[1016, 1072], [3056, 2032]]),
   {'1': [7, 23]}),
  ('writes from young regions are filtered',
   (['old', 'young', 'old', 'humongous', 'hcont', 'hcont', 'old', 'young'],
    1024,
    128,
    [[1064, 0], [7208, 2048], [1032, 7168]]),
   {}),
  ('pointer into a humongous continuation',
   (['old', 'young', 'old', 'humongous', 'hcont', 'hcont', 'old', 'young'],
    1024,
    128,
    [[40, 5220], [6144, 4104]]),
   {'3': [0, 48]}),
  ('null writes',
   (['old', 'young', 'old', 'humongous', 'hcont', 'hcont', 'old', 'young'],
    1024,
    128,
    [[40, None], [6144, None], [2112, 3072]]),
   {'3': [16]})]]
for label, args, expected in cases[N - 1]:
    check(label, solve(*args), expected)
print(json.dumps({"observations": observations, "passed": all(x["passed"] for x in observations)}, ensure_ascii=False))
raise SystemExit(0 if all(x["passed"] for x in observations) else 1)
Boundary fixtureActualExpectedOutcome
regression: old-to-young and old-to-old writes{'1': [0], '6': [16], '7': [50]}{'1': [0], '6': [16], '7': [50]}Passed
pointer within the same region{}{}Passed
neighbouring addresses across a region boundary{'1': [7, 23]}{'1': [7, 23]}Passed
writes from young regions are filtered{}{}Passed
pointer into a humongous continuation{'4': [48], '5': [0]}{'3': [0, 48]}Failed
null writes{'3': [16]}{'3': [16]}Passed

SHA-256 / df886d57a76757a44e29a7e732116446f391fb2467b3c09b1e53f55fd2a9ba94

2 / The unsuccessful fix

Exit 1
"""Failure Map reference implementation. Python standard library only."""
import json

N = 1
observations = []
def solve(kinds, region_size, card, writes):
    remsets = {}
    for slot, val in writes:
        if val is None:
            continue
        src, dst = slot // region_size, val // region_size
        if kinds[dst] == 'hcont':
            dst -= 1
        if src == dst:
            continue
        if kinds[src] == 'young':
            continue
        remsets.setdefault(dst, set()).add(slot // card)
    return {str(k): sorted(v) for k, v in sorted(remsets.items())}
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
cases = [[('regression: old-to-young and old-to-old writes',
   (['old', 'young', 'old', 'humongous', 'hcont', 'hcont', 'old', 'young'],
    1024,
    128,
    [[8, 1040], [2056, 6152], [6452, 7168]]),
   {'1': [0], '6': [16], '7': [50]}),
  ('pointer within the same region',
   (['old', 'young', 'old', 'humongous', 'hcont', 'hcont', 'old', 'young'],
    1024,
    128,
    [[2056, 2948], [3048, 2056]]),
   {}),
  ('neighbouring addresses across a region boundary',
   (['old', 'young', 'old', 'humongous', 'hcont', 'hcont', 'old', 'young'],
    1024,
    128,
    [[1016, 1040], [3056, 2032]]),
   {'1': [7, 23]}),
  ('writes from young regions are filtered',
   (['old', 'young', 'old', 'humongous', 'hcont', 'hcont', 'old', 'young'],
    1024,
    128,
    [[1032, 0], [7208, 2048], [1032, 7168]]),
   {}),
  ('pointer into a humongous continuation',
   (['old', 'young', 'old', 'humongous', 'hcont', 'hcont', 'old', 'young'],
    1024,
    128,
    [[8, 5220], [6144, 4104]]),
   {'3': [0, 48]}),
  ('null writes',
   (['old', 'young', 'old', 'humongous', 'hcont', 'hcont', 'old', 'young'],
    1024,
    128,
    [[8, None], [6144, None], [2112, 3072]]),
   {'3': [16]})],
 [('regression: old-to-young and old-to-old writes',
   (['old', 'young', 'old', 'humongous', 'hcont', 'hcont', 'old', 'young'],
    1024,
    128,
    [[16, 1040], [2064, 6152], [6460, 7168]]),
   {'1': [0], '6': [16], '7': [50]}),
  ('pointer within the same region',
   (['old', 'young', 'old', 'humongous', 'hcont', 'hcont', 'old', 'young'],
    1024,
    128,
    [[2064, 2948], [3048, 2056]]),
   {}),
  ('neighbouring addresses across a region boundary',
   (['old', 'young', 'old', 'humongous', 'hcont', 'hcont', 'old', 'young'],
    1024,
    128,
    [[1016, 1048], [3056, 2032]]),
   {'1': [7, 23]}),
  ('writes from young regions are filtered',
   (['old', 'young', 'old', 'humongous', 'hcont', 'hcont', 'old', 'young'],
    1024,
    128,
    [[1040, 0], [7208, 2048], [1032, 7168]]),
   {}),
  ('pointer into a humongous continuation',
   (['old', 'young', 'old', 'humongous', 'hcont', 'hcont', 'old', 'young'],
    1024,
    128,
    [[16, 5220], [6144, 4104]]),
   {'3': [0, 48]}),
  ('null writes',
   (['old', 'young', 'old', 'humongous', 'hcont', 'hcont', 'old', 'young'],
    1024,
    128,
    [[16, None], [6144, None], [2112, 3072]]),
   {'3': [16]})],
 [('regression: old-to-young and old-to-old writes',
   (['old', 'young', 'old', 'humongous', 'hcont', 'hcont', 'old', 'young'],
    1024,
    128,
    [[24, 1040], [2072, 6152], [6468, 7168]]),
   {'1': [0], '6': [16], '7': [50]}),
  ('pointer within the same region',
   (['old', 'young', 'old', 'humongous', 'hcont', 'hcont', 'old', 'young'],
    1024,
    128,
    [[2072, 2948], [3048, 2056]]),
   {}),
  ('neighbouring addresses across a region boundary',
   (['old', 'young', 'old', 'humongous', 'hcont', 'hcont', 'old', 'young'],
    1024,
    128,
    [[1016, 1056], [3056, 2032]]),
   {'1': [7, 23]}),
  ('writes from young regions are filtered',
   (['old', 'young', 'old', 'humongous', 'hcont', 'hcont', 'old', 'young'],
    1024,
    128,
    [[1048, 0], [7208, 2048], [1032, 7168]]),
   {}),
  ('pointer into a humongous continuation',
   (['old', 'young', 'old', 'humongous', 'hcont', 'hcont', 'old', 'young'],
    1024,
    128,
    [[24, 5220], [6144, 4104]]),
   {'3': [0, 48]}),
  ('null writes',
   (['old', 'young', 'old', 'humongous', 'hcont', 'hcont', 'old', 'young'],
    1024,
    128,
    [[24, None], [6144, None], [2112, 3072]]),
   {'3': [16]})],
 [('regression: old-to-young and old-to-old writes',
   (['old', 'young', 'old', 'humongous', 'hcont', 'hcont', 'old', 'young'],
    1024,
    128,
    [[32, 1040], [2080, 6152], [6476, 7168]]),
   {'1': [0], '6': [16], '7': [50]}),
  ('pointer within the same region',
   (['old', 'young', 'old', 'humongous', 'hcont', 'hcont', 'old', 'young'],
    1024,
    128,
    [[2080, 2948], [3048, 2056]]),
   {}),
  ('neighbouring addresses across a region boundary',
   (['old', 'young', 'old', 'humongous', 'hcont', 'hcont', 'old', 'young'],
    1024,
    128,
    [[1016, 1064], [3056, 2032]]),
   {'1': [7, 23]}),
  ('writes from young regions are filtered',
   (['old', 'young', 'old', 'humongous', 'hcont', 'hcont', 'old', 'young'],
    1024,
    128,
    [[1056, 0], [7208, 2048], [1032, 7168]]),
   {}),
  ('pointer into a humongous continuation',
   (['old', 'young', 'old', 'humongous', 'hcont', 'hcont', 'old', 'young'],
    1024,
    128,
    [[32, 5220], [6144, 4104]]),
   {'3': [0, 48]}),
  ('null writes',
   (['old', 'young', 'old', 'humongous', 'hcont', 'hcont', 'old', 'young'],
    1024,
    128,
    [[32, None], [6144, None], [2112, 3072]]),
   {'3': [16]})],
 [('regression: old-to-young and old-to-old writes',
   (['old', 'young', 'old', 'humongous', 'hcont', 'hcont', 'old', 'young'],
    1024,
    128,
    [[40, 1040], [2088, 6152], [6484, 7168]]),
   {'1': [0], '6': [16], '7': [50]}),
  ('pointer within the same region',
   (['old', 'young', 'old', 'humongous', 'hcont', 'hcont', 'old', 'young'],
    1024,
    128,
    [[2088, 2948], [3048, 2056]]),
   {}),
  ('neighbouring addresses across a region boundary',
   (['old', 'young', 'old', 'humongous', 'hcont', 'hcont', 'old', 'young'],
    1024,
    128,
    [[1016, 1072], [3056, 2032]]),
   {'1': [7, 23]}),
  ('writes from young regions are filtered',
   (['old', 'young', 'old', 'humongous', 'hcont', 'hcont', 'old', 'young'],
    1024,
    128,
    [[1064, 0], [7208, 2048], [1032, 7168]]),
   {}),
  ('pointer into a humongous continuation',
   (['old', 'young', 'old', 'humongous', 'hcont', 'hcont', 'old', 'young'],
    1024,
    128,
    [[40, 5220], [6144, 4104]]),
   {'3': [0, 48]}),
  ('null writes',
   (['old', 'young', 'old', 'humongous', 'hcont', 'hcont', 'old', 'young'],
    1024,
    128,
    [[40, None], [6144, None], [2112, 3072]]),
   {'3': [16]})]]
for label, args, expected in cases[N - 1]:
    check(label, solve(*args), expected)
print(json.dumps({"observations": observations, "passed": all(x["passed"] for x in observations)}, ensure_ascii=False))
raise SystemExit(0 if all(x["passed"] for x in observations) else 1)
Boundary fixtureActualExpectedOutcome
regression: old-to-young and old-to-old writes{'1': [0], '6': [16], '7': [50]}{'1': [0], '6': [16], '7': [50]}Passed
pointer within the same region{}{}Passed
neighbouring addresses across a region boundary{'1': [7, 23]}{'1': [7, 23]}Passed
writes from young regions are filtered{}{}Passed
pointer into a humongous continuation{'3': [48], '4': [0]}{'3': [0, 48]}Failed
null writes{'3': [16]}{'3': [16]}Passed

SHA-256 / 6bf98a2ba48b4e323bbdb0c76166a6a66fbce723c00265ef2c8c3cb9cb688d8b

3 / The verified repair

Exit 0
"""Failure Map reference implementation. Python standard library only."""
import json

N = 1
observations = []
def solve(kinds, region_size, card, writes):
    remsets = {}
    for slot, val in writes:
        if val is None:
            continue
        src, dst = slot // region_size, val // region_size
        while kinds[dst] == 'hcont':
            dst -= 1
        if src == dst:
            continue
        if kinds[src] == 'young':
            continue
        remsets.setdefault(dst, set()).add(slot // card)
    return {str(k): sorted(v) for k, v in sorted(remsets.items())}
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
cases = [[('regression: old-to-young and old-to-old writes',
   (['old', 'young', 'old', 'humongous', 'hcont', 'hcont', 'old', 'young'],
    1024,
    128,
    [[8, 1040], [2056, 6152], [6452, 7168]]),
   {'1': [0], '6': [16], '7': [50]}),
  ('pointer within the same region',
   (['old', 'young', 'old', 'humongous', 'hcont', 'hcont', 'old', 'young'],
    1024,
    128,
    [[2056, 2948], [3048, 2056]]),
   {}),
  ('neighbouring addresses across a region boundary',
   (['old', 'young', 'old', 'humongous', 'hcont', 'hcont', 'old', 'young'],
    1024,
    128,
    [[1016, 1040], [3056, 2032]]),
   {'1': [7, 23]}),
  ('writes from young regions are filtered',
   (['old', 'young', 'old', 'humongous', 'hcont', 'hcont', 'old', 'young'],
    1024,
    128,
    [[1032, 0], [7208, 2048], [1032, 7168]]),
   {}),
  ('pointer into a humongous continuation',
   (['old', 'young', 'old', 'humongous', 'hcont', 'hcont', 'old', 'young'],
    1024,
    128,
    [[8, 5220], [6144, 4104]]),
   {'3': [0, 48]}),
  ('null writes',
   (['old', 'young', 'old', 'humongous', 'hcont', 'hcont', 'old', 'young'],
    1024,
    128,
    [[8, None], [6144, None], [2112, 3072]]),
   {'3': [16]})],
 [('regression: old-to-young and old-to-old writes',
   (['old', 'young', 'old', 'humongous', 'hcont', 'hcont', 'old', 'young'],
    1024,
    128,
    [[16, 1040], [2064, 6152], [6460, 7168]]),
   {'1': [0], '6': [16], '7': [50]}),
  ('pointer within the same region',
   (['old', 'young', 'old', 'humongous', 'hcont', 'hcont', 'old', 'young'],
    1024,
    128,
    [[2064, 2948], [3048, 2056]]),
   {}),
  ('neighbouring addresses across a region boundary',
   (['old', 'young', 'old', 'humongous', 'hcont', 'hcont', 'old', 'young'],
    1024,
    128,
    [[1016, 1048], [3056, 2032]]),
   {'1': [7, 23]}),
  ('writes from young regions are filtered',
   (['old', 'young', 'old', 'humongous', 'hcont', 'hcont', 'old', 'young'],
    1024,
    128,
    [[1040, 0], [7208, 2048], [1032, 7168]]),
   {}),
  ('pointer into a humongous continuation',
   (['old', 'young', 'old', 'humongous', 'hcont', 'hcont', 'old', 'young'],
    1024,
    128,
    [[16, 5220], [6144, 4104]]),
   {'3': [0, 48]}),
  ('null writes',
   (['old', 'young', 'old', 'humongous', 'hcont', 'hcont', 'old', 'young'],
    1024,
    128,
    [[16, None], [6144, None], [2112, 3072]]),
   {'3': [16]})],
 [('regression: old-to-young and old-to-old writes',
   (['old', 'young', 'old', 'humongous', 'hcont', 'hcont', 'old', 'young'],
    1024,
    128,
    [[24, 1040], [2072, 6152], [6468, 7168]]),
   {'1': [0], '6': [16], '7': [50]}),
  ('pointer within the same region',
   (['old', 'young', 'old', 'humongous', 'hcont', 'hcont', 'old', 'young'],
    1024,
    128,
    [[2072, 2948], [3048, 2056]]),
   {}),
  ('neighbouring addresses across a region boundary',
   (['old', 'young', 'old', 'humongous', 'hcont', 'hcont', 'old', 'young'],
    1024,
    128,
    [[1016, 1056], [3056, 2032]]),
   {'1': [7, 23]}),
  ('writes from young regions are filtered',
   (['old', 'young', 'old', 'humongous', 'hcont', 'hcont', 'old', 'young'],
    1024,
    128,
    [[1048, 0], [7208, 2048], [1032, 7168]]),
   {}),
  ('pointer into a humongous continuation',
   (['old', 'young', 'old', 'humongous', 'hcont', 'hcont', 'old', 'young'],
    1024,
    128,
    [[24, 5220], [6144, 4104]]),
   {'3': [0, 48]}),
  ('null writes',
   (['old', 'young', 'old', 'humongous', 'hcont', 'hcont', 'old', 'young'],
    1024,
    128,
    [[24, None], [6144, None], [2112, 3072]]),
   {'3': [16]})],
 [('regression: old-to-young and old-to-old writes',
   (['old', 'young', 'old', 'humongous', 'hcont', 'hcont', 'old', 'young'],
    1024,
    128,
    [[32, 1040], [2080, 6152], [6476, 7168]]),
   {'1': [0], '6': [16], '7': [50]}),
  ('pointer within the same region',
   (['old', 'young', 'old', 'humongous', 'hcont', 'hcont', 'old', 'young'],
    1024,
    128,
    [[2080, 2948], [3048, 2056]]),
   {}),
  ('neighbouring addresses across a region boundary',
   (['old', 'young', 'old', 'humongous', 'hcont', 'hcont', 'old', 'young'],
    1024,
    128,
    [[1016, 1064], [3056, 2032]]),
   {'1': [7, 23]}),
  ('writes from young regions are filtered',
   (['old', 'young', 'old', 'humongous', 'hcont', 'hcont', 'old', 'young'],
    1024,
    128,
    [[1056, 0], [7208, 2048], [1032, 7168]]),
   {}),
  ('pointer into a humongous continuation',
   (['old', 'young', 'old', 'humongous', 'hcont', 'hcont', 'old', 'young'],
    1024,
    128,
    [[32, 5220], [6144, 4104]]),
   {'3': [0, 48]}),
  ('null writes',
   (['old', 'young', 'old', 'humongous', 'hcont', 'hcont', 'old', 'young'],
    1024,
    128,
    [[32, None], [6144, None], [2112, 3072]]),
   {'3': [16]})],
 [('regression: old-to-young and old-to-old writes',
   (['old', 'young', 'old', 'humongous', 'hcont', 'hcont', 'old', 'young'],
    1024,
    128,
    [[40, 1040], [2088, 6152], [6484, 7168]]),
   {'1': [0], '6': [16], '7': [50]}),
  ('pointer within the same region',
   (['old', 'young', 'old', 'humongous', 'hcont', 'hcont', 'old', 'young'],
    1024,
    128,
    [[2088, 2948], [3048, 2056]]),
   {}),
  ('neighbouring addresses across a region boundary',
   (['old', 'young', 'old', 'humongous', 'hcont', 'hcont', 'old', 'young'],
    1024,
    128,
    [[1016, 1072], [3056, 2032]]),
   {'1': [7, 23]}),
  ('writes from young regions are filtered',
   (['old', 'young', 'old', 'humongous', 'hcont', 'hcont', 'old', 'young'],
    1024,
    128,
    [[1064, 0], [7208, 2048], [1032, 7168]]),
   {}),
  ('pointer into a humongous continuation',
   (['old', 'young', 'old', 'humongous', 'hcont', 'hcont', 'old', 'young'],
    1024,
    128,
    [[40, 5220], [6144, 4104]]),
   {'3': [0, 48]}),
  ('null writes',
   (['old', 'young', 'old', 'humongous', 'hcont', 'hcont', 'old', 'young'],
    1024,
    128,
    [[40, None], [6144, None], [2112, 3072]]),
   {'3': [16]})]]
for label, args, expected in cases[N - 1]:
    check(label, solve(*args), expected)
print(json.dumps({"observations": observations, "passed": all(x["passed"] for x in observations)}, ensure_ascii=False))
raise SystemExit(0 if all(x["passed"] for x in observations) else 1)
Boundary fixtureActualExpectedOutcome
regression: old-to-young and old-to-old writes{'1': [0], '6': [16], '7': [50]}{'1': [0], '6': [16], '7': [50]}Passed
pointer within the same region{}{}Passed
neighbouring addresses across a region boundary{'1': [7, 23]}{'1': [7, 23]}Passed
writes from young regions are filtered{}{}Passed
pointer into a humongous continuation{'3': [0, 48]}{'3': [0, 48]}Passed
null writes{'3': [16]}{'3': [16]}Passed

SHA-256 / 343769a8aaa84ed1fd322d254803775f50099dd3494bf4e330884267d9432ffc

Verification & scope

A deterministic, bounded teaching model of one garbage-collector mechanism with stipulated rules; it is not a production collector and claims no conformance to any particular runtime. This reproducer isolates one failure mechanism. Results cover the supplied fixtures. Variants within a family share a test contract and should remain grouped when constructing evaluation splits. Related mechanisms with a shared evaluation_group must also remain together; these controlled models are not independent production incidents.

Observations recorded using Python 3.12.14 at 2026-09-29T14:51:29.654666+00:00.

Case digest / b5937736f6366473550bc8fa0e08660a377dffea95d396c302dc84236acbfd5e