FAILURE MAP
← Case archive

FA-90736 / Garbage collector invariants / Open access

Remembered sets: pointers into young regions dropped · case 01

Old-to-young references are missing and young evacuation loses live objects.

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

ROOT CAUSE

The filter skips writes whose target is young instead of writes from young slots.

VERIFIED REPAIR

Filter writes from young regions; young targets still need remembered-set entries.

Unsuccessful approach: Filtering on either end still drops old-to-young pointers.

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 src == dst:
            continue
        if kinds[dst] == '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{'6': [16]}{'1': [0], '6': [16], '7': [50]}Failed
pointer within the same region{}{}Passed
neighbouring addresses across a region boundary{}{'1': [7, 23]}Failed
writes from young regions are filtered{'0': [8], '2': [56]}{}Failed
pointer into a humongous continuation{'3': [0, 48]}{'3': [0, 48]}Passed
null writes{'3': [16]}{'3': [16]}Passed

SHA-256 / 09452973fdb79e1daa2ed5b40fe79979f277c25b4079b4e776a9e78a84524dcf

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 src == dst:
            continue
        if 'young' in (kinds[src], kinds[dst]):
            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{'6': [16]}{'1': [0], '6': [16], '7': [50]}Failed
pointer within the same region{}{}Passed
neighbouring addresses across a region boundary{}{'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]}{'3': [16]}Passed

SHA-256 / b7d12aa9a6d9db3b7eb5e48dec32b4c67f6f8e174dd69846bafd0da65561ecaa

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

Case digest / 5b5bb43736e56b091fe9bc41338988bbdbaa354b1408a178f502ab33d90e69b6