FAILURE MAP
← Case archive

FA-90731 / Garbage collector invariants / Open access

Remembered sets: intra-region pointers recorded · case 01

Remembered sets fill with pointers that never cross a region boundary.

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

ROOT CAUSE

The filter compares cards instead of regions.

VERIFIED REPAIR

Skip writes whose slot and target are in the same region.

Unsuccessful approach: A distance test filters short cross-region pointers and keeps far intra-region ones.

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
        while kinds[dst] == 'hcont':
            dst -= 1
        if slot // card == val // card:
            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{'2': [16, 23]}{}Failed
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 / b49b9fd216ac338f92f8de5f56e83fd9a4cfa982a091fb74d909736fcd5517e0

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
        while kinds[dst] == 'hcont':
            dst -= 1
        if abs(slot - val) < region_size:
            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]}{'1': [0], '6': [16], '7': [50]}Failed
pointer within the same region{}{}Passed
neighbouring addresses across a region boundary{'1': [23]}{'1': [7, 23]}Failed
writes from young regions are filtered{}{}Passed
pointer into a humongous continuation{'3': [0, 48]}{'3': [0, 48]}Passed
null writes{}{'3': [16]}Failed

SHA-256 / 420696102ef059584b9a4d54077b4d1acc5504985c5bfd83bb7958415bf2b46d

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.439180+00:00.

Case digest / 9e42c75b0bd9fbecad32c35c1f1094df37e707a2189d8e19b4ed46eb9906b439