FAILURE MAP
← Case archive

FA-90716 / Garbage collector invariants / Open access

Identity hash: stored hash computed from the destination address · case 01

The hash observed before a move differs from the one observed after it.

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

ROOT CAUSE

The hash slot is filled using the new address instead of the address at which the hash was handed out.

THE FAILURE

The hash slot is filled using the new address instead of the address at which the hash was handed out.

Unsuccessful approach: Storing the raw address skips the shift and mask.

Case contract

objs maps id -> [address, size]. The identity hash of an object is (address >> 3) & 0xFFFF of the address at which it was first hashed. Objects start unhashed; hash marks them hashed and returns the hash computed from the current address while they have not moved. The first move of a hashed object stores that hash in a new 8-byte trailing slot (size grows by 8) and later moves keep it; moving an unhashed object stores nothing. Return all hashes and the final [address, size] layout.

Why this case matters

Moving collectors must keep identity hashes stable even though they are derived from addresses.

1 / The failure

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

N = 1
observations = []
def solve(objs, events):
    objs = {k: list(v) for k, v in objs.items()}
    state = {o: 'unhashed' for o in objs}
    stored = {}
    out = []
    for ev in events:
        o = ev[1]
        if ev[0] == 'hash':
            if state[o] == 'unhashed':
                state[o] = 'hashed'
            if state[o] == 'hashed':
                out.append(objs[o][0] >> 3 & 0xFFFF)
            else:
                out.append(stored[o])
        else:
            if state[o] == 'hashed':
                stored[o] = ev[2] >> 3 & 0xFFFF
                state[o] = 'moved'
                objs[o][1] += 8
            objs[o][0] = ev[2]
    return {'hashes': out, 'layout': {str(k): v for k, v in sorted(objs.items())}}
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
cases = [[('regression: hash survives a move',
   ({1: [65608, 24], 2: [8192, 16], 3: [201272, 32]}, [['hash', 1], ['move', 1, 32768], ['hash', 1]]),
   {'hashes': [8201, 8201], 'layout': {'1': [32768, 32], '2': [8192, 16], '3': [201272, 32]}}),
  ('object moved twice after hashing',
   ({1: [65608, 24], 2: [8192, 16], 3: [201272, 32]},
    [['hash', 2], ['move', 2, 36872], ['move', 2, 40960], ['hash', 2]]),
   {'hashes': [1024, 1024], 'layout': {'1': [65608, 24], '2': [40960, 24], '3': [201272, 32]}}),
  ('unhashed object moves freely',
   ({1: [65608, 24], 2: [8192, 16], 3: [201272, 32]}, [['move', 3, 16400], ['hash', 3], ['hash', 3]]),
   {'hashes': [2050, 2050], 'layout': {'1': [65608, 24], '2': [8192, 16], '3': [16400, 32]}}),
  ('high address bits masked after shifting',
   ({1: [65608, 24], 2: [8192, 16], 3: [201272, 32]}, [['hash', 3], ['hash', 1]]),
   {'hashes': [25159, 8201], 'layout': {'1': [65608, 24], '2': [8192, 16], '3': [201272, 32]}}),
  ('hash requested again before any move',
   ({1: [65608, 24], 2: [8192, 16], 3: [201272, 32]}, [['hash', 2], ['hash', 2], ['move', 1, 20488]]),
   {'hashes': [1024, 1024], 'layout': {'1': [20488, 24], '2': [8192, 16], '3': [201272, 32]}}),
  ('control: no hashing',
   ({1: [65608, 24], 2: [8192, 16], 3: [201272, 32]}, [['move', 2, 24576], ['move', 2, 28680]]),
   {'hashes': [], 'layout': {'1': [65608, 24], '2': [28680, 16], '3': [201272, 32]}})],
 [('regression: hash survives a move',
   ({1: [65616, 24], 2: [8192, 16], 3: [201272, 32]}, [['hash', 1], ['move', 1, 32768], ['hash', 1]]),
   {'hashes': [8202, 8202], 'layout': {'1': [32768, 32], '2': [8192, 16], '3': [201272, 32]}}),
  ('object moved twice after hashing',
   ({1: [65616, 24], 2: [8192, 16], 3: [201272, 32]},
    [['hash', 2], ['move', 2, 36880], ['move', 2, 40960], ['hash', 2]]),
   {'hashes': [1024, 1024], 'layout': {'1': [65616, 24], '2': [40960, 24], '3': [201272, 32]}}),
  ('unhashed object moves freely',
   ({1: [65616, 24], 2: [8192, 16], 3: [201272, 32]}, [['move', 3, 16416], ['hash', 3], ['hash', 3]]),
   {'hashes': [2052, 2052], 'layout': {'1': [65616, 24], '2': [8192, 16], '3': [16416, 32]}}),
  ('high address bits masked after shifting',
   ({1: [65616, 24], 2: [8192, 16], 3: [201272, 32]}, [['hash', 3], ['hash', 1]]),
   {'hashes': [25159, 8202], 'layout': {'1': [65616, 24], '2': [8192, 16], '3': [201272, 32]}}),
  ('hash requested again before any move',
   ({1: [65616, 24], 2: [8192, 16], 3: [201272, 32]}, [['hash', 2], ['hash', 2], ['move', 1, 20496]]),
   {'hashes': [1024, 1024], 'layout': {'1': [20496, 24], '2': [8192, 16], '3': [201272, 32]}}),
  ('control: no hashing',
   ({1: [65616, 24], 2: [8192, 16], 3: [201272, 32]}, [['move', 2, 24576], ['move', 2, 28688]]),
   {'hashes': [], 'layout': {'1': [65616, 24], '2': [28688, 16], '3': [201272, 32]}})],
 [('regression: hash survives a move',
   ({1: [65624, 24], 2: [8192, 16], 3: [201272, 32]}, [['hash', 1], ['move', 1, 32768], ['hash', 1]]),
   {'hashes': [8203, 8203], 'layout': {'1': [32768, 32], '2': [8192, 16], '3': [201272, 32]}}),
  ('object moved twice after hashing',
   ({1: [65624, 24], 2: [8192, 16], 3: [201272, 32]},
    [['hash', 2], ['move', 2, 36888], ['move', 2, 40960], ['hash', 2]]),
   {'hashes': [1024, 1024], 'layout': {'1': [65624, 24], '2': [40960, 24], '3': [201272, 32]}}),
  ('unhashed object moves freely',
   ({1: [65624, 24], 2: [8192, 16], 3: [201272, 32]}, [['move', 3, 16432], ['hash', 3], ['hash', 3]]),
   {'hashes': [2054, 2054], 'layout': {'1': [65624, 24], '2': [8192, 16], '3': [16432, 32]}}),
  ('high address bits masked after shifting',
   ({1: [65624, 24], 2: [8192, 16], 3: [201272, 32]}, [['hash', 3], ['hash', 1]]),
   {'hashes': [25159, 8203], 'layout': {'1': [65624, 24], '2': [8192, 16], '3': [201272, 32]}}),
  ('hash requested again before any move',
   ({1: [65624, 24], 2: [8192, 16], 3: [201272, 32]}, [['hash', 2], ['hash', 2], ['move', 1, 20504]]),
   {'hashes': [1024, 1024], 'layout': {'1': [20504, 24], '2': [8192, 16], '3': [201272, 32]}}),
  ('control: no hashing',
   ({1: [65624, 24], 2: [8192, 16], 3: [201272, 32]}, [['move', 2, 24576], ['move', 2, 28696]]),
   {'hashes': [], 'layout': {'1': [65624, 24], '2': [28696, 16], '3': [201272, 32]}})],
 [('regression: hash survives a move',
   ({1: [65632, 24], 2: [8192, 16], 3: [201272, 32]}, [['hash', 1], ['move', 1, 32768], ['hash', 1]]),
   {'hashes': [8204, 8204], 'layout': {'1': [32768, 32], '2': [8192, 16], '3': [201272, 32]}}),
  ('object moved twice after hashing',
   ({1: [65632, 24], 2: [8192, 16], 3: [201272, 32]},
    [['hash', 2], ['move', 2, 36896], ['move', 2, 40960], ['hash', 2]]),
   {'hashes': [1024, 1024], 'layout': {'1': [65632, 24], '2': [40960, 24], '3': [201272, 32]}}),
  ('unhashed object moves freely',
   ({1: [65632, 24], 2: [8192, 16], 3: [201272, 32]}, [['move', 3, 16448], ['hash', 3], ['hash', 3]]),
   {'hashes': [2056, 2056], 'layout': {'1': [65632, 24], '2': [8192, 16], '3': [16448, 32]}}),
  ('high address bits masked after shifting',
   ({1: [65632, 24], 2: [8192, 16], 3: [201272, 32]}, [['hash', 3], ['hash', 1]]),
   {'hashes': [25159, 8204], 'layout': {'1': [65632, 24], '2': [8192, 16], '3': [201272, 32]}}),
  ('hash requested again before any move',
   ({1: [65632, 24], 2: [8192, 16], 3: [201272, 32]}, [['hash', 2], ['hash', 2], ['move', 1, 20512]]),
   {'hashes': [1024, 1024], 'layout': {'1': [20512, 24], '2': [8192, 16], '3': [201272, 32]}}),
  ('control: no hashing',
   ({1: [65632, 24], 2: [8192, 16], 3: [201272, 32]}, [['move', 2, 24576], ['move', 2, 28704]]),
   {'hashes': [], 'layout': {'1': [65632, 24], '2': [28704, 16], '3': [201272, 32]}})],
 [('regression: hash survives a move',
   ({1: [65640, 24], 2: [8192, 16], 3: [201272, 32]}, [['hash', 1], ['move', 1, 32768], ['hash', 1]]),
   {'hashes': [8205, 8205], 'layout': {'1': [32768, 32], '2': [8192, 16], '3': [201272, 32]}}),
  ('object moved twice after hashing',
   ({1: [65640, 24], 2: [8192, 16], 3: [201272, 32]},
    [['hash', 2], ['move', 2, 36904], ['move', 2, 40960], ['hash', 2]]),
   {'hashes': [1024, 1024], 'layout': {'1': [65640, 24], '2': [40960, 24], '3': [201272, 32]}}),
  ('unhashed object moves freely',
   ({1: [65640, 24], 2: [8192, 16], 3: [201272, 32]}, [['move', 3, 16464], ['hash', 3], ['hash', 3]]),
   {'hashes': [2058, 2058], 'layout': {'1': [65640, 24], '2': [8192, 16], '3': [16464, 32]}}),
  ('high address bits masked after shifting',
   ({1: [65640, 24], 2: [8192, 16], 3: [201272, 32]}, [['hash', 3], ['hash', 1]]),
   {'hashes': [25159, 8205], 'layout': {'1': [65640, 24], '2': [8192, 16], '3': [201272, 32]}}),
  ('hash requested again before any move',
   ({1: [65640, 24], 2: [8192, 16], 3: [201272, 32]}, [['hash', 2], ['hash', 2], ['move', 1, 20520]]),
   {'hashes': [1024, 1024], 'layout': {'1': [20520, 24], '2': [8192, 16], '3': [201272, 32]}}),
  ('control: no hashing',
   ({1: [65640, 24], 2: [8192, 16], 3: [201272, 32]}, [['move', 2, 24576], ['move', 2, 28712]]),
   {'hashes': [], 'layout': {'1': [65640, 24], '2': [28712, 16], '3': [201272, 32]}})]]
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: hash survives a move{'hashes': [8201, 4096], 'layout': {'1': [32768, 32], '2': [8192, 16], '3': [201272, 32]}}{'hashes': [8201, 8201], 'layout': {'1': [32768, 32], '2': [8192, 16], '3': [201272, 32]}}Failed
object moved twice after hashing{'hashes': [1024, 4609], 'layout': {'1': [65608, 24], '2': [40960, 24], '3': [201272, 32]}}{'hashes': [1024, 1024], 'layout': {'1': [65608, 24], '2': [40960, 24], '3': [201272, 32]}}Failed
unhashed object moves freely{'hashes': [2050, 2050], 'layout': {'1': [65608, 24], '2': [8192, 16], '3': [16400, 32]}}{'hashes': [2050, 2050], 'layout': {'1': [65608, 24], '2': [8192, 16], '3': [16400, 32]}}Passed
high address bits masked after shifting{'hashes': [25159, 8201], 'layout': {'1': [65608, 24], '2': [8192, 16], '3': [201272, 32]}}{'hashes': [25159, 8201], 'layout': {'1': [65608, 24], '2': [8192, 16], '3': [201272, 32]}}Passed
hash requested again before any move{'hashes': [1024, 1024], 'layout': {'1': [20488, 24], '2': [8192, 16], '3': [201272, 32]}}{'hashes': [1024, 1024], 'layout': {'1': [20488, 24], '2': [8192, 16], '3': [201272, 32]}}Passed
control: no hashing{'hashes': [], 'layout': {'1': [65608, 24], '2': [28680, 16], '3': [201272, 32]}}{'hashes': [], 'layout': {'1': [65608, 24], '2': [28680, 16], '3': [201272, 32]}}Passed

SHA-256 / 9e24ae873105fe765267e357b0cf25360320362054e9e815324cbf1461965844

2 / The unsuccessful fix

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

N = 1
observations = []
def solve(objs, events):
    objs = {k: list(v) for k, v in objs.items()}
    state = {o: 'unhashed' for o in objs}
    stored = {}
    out = []
    for ev in events:
        o = ev[1]
        if ev[0] == 'hash':
            if state[o] == 'unhashed':
                state[o] = 'hashed'
            if state[o] == 'hashed':
                out.append(objs[o][0] >> 3 & 0xFFFF)
            else:
                out.append(stored[o])
        else:
            if state[o] == 'hashed':
                stored[o] = objs[o][0]
                state[o] = 'moved'
                objs[o][1] += 8
            objs[o][0] = ev[2]
    return {'hashes': out, 'layout': {str(k): v for k, v in sorted(objs.items())}}
def check(label, actual, expected):
    observations.append({"check": label, "actual": actual, "expected": expected, "passed": actual == expected})
cases = [[('regression: hash survives a move',
   ({1: [65608, 24], 2: [8192, 16], 3: [201272, 32]}, [['hash', 1], ['move', 1, 32768], ['hash', 1]]),
   {'hashes': [8201, 8201], 'layout': {'1': [32768, 32], '2': [8192, 16], '3': [201272, 32]}}),
  ('object moved twice after hashing',
   ({1: [65608, 24], 2: [8192, 16], 3: [201272, 32]},
    [['hash', 2], ['move', 2, 36872], ['move', 2, 40960], ['hash', 2]]),
   {'hashes': [1024, 1024], 'layout': {'1': [65608, 24], '2': [40960, 24], '3': [201272, 32]}}),
  ('unhashed object moves freely',
   ({1: [65608, 24], 2: [8192, 16], 3: [201272, 32]}, [['move', 3, 16400], ['hash', 3], ['hash', 3]]),
   {'hashes': [2050, 2050], 'layout': {'1': [65608, 24], '2': [8192, 16], '3': [16400, 32]}}),
  ('high address bits masked after shifting',
   ({1: [65608, 24], 2: [8192, 16], 3: [201272, 32]}, [['hash', 3], ['hash', 1]]),
   {'hashes': [25159, 8201], 'layout': {'1': [65608, 24], '2': [8192, 16], '3': [201272, 32]}}),
  ('hash requested again before any move',
   ({1: [65608, 24], 2: [8192, 16], 3: [201272, 32]}, [['hash', 2], ['hash', 2], ['move', 1, 20488]]),
   {'hashes': [1024, 1024], 'layout': {'1': [20488, 24], '2': [8192, 16], '3': [201272, 32]}}),
  ('control: no hashing',
   ({1: [65608, 24], 2: [8192, 16], 3: [201272, 32]}, [['move', 2, 24576], ['move', 2, 28680]]),
   {'hashes': [], 'layout': {'1': [65608, 24], '2': [28680, 16], '3': [201272, 32]}})],
 [('regression: hash survives a move',
   ({1: [65616, 24], 2: [8192, 16], 3: [201272, 32]}, [['hash', 1], ['move', 1, 32768], ['hash', 1]]),
   {'hashes': [8202, 8202], 'layout': {'1': [32768, 32], '2': [8192, 16], '3': [201272, 32]}}),
  ('object moved twice after hashing',
   ({1: [65616, 24], 2: [8192, 16], 3: [201272, 32]},
    [['hash', 2], ['move', 2, 36880], ['move', 2, 40960], ['hash', 2]]),
   {'hashes': [1024, 1024], 'layout': {'1': [65616, 24], '2': [40960, 24], '3': [201272, 32]}}),
  ('unhashed object moves freely',
   ({1: [65616, 24], 2: [8192, 16], 3: [201272, 32]}, [['move', 3, 16416], ['hash', 3], ['hash', 3]]),
   {'hashes': [2052, 2052], 'layout': {'1': [65616, 24], '2': [8192, 16], '3': [16416, 32]}}),
  ('high address bits masked after shifting',
   ({1: [65616, 24], 2: [8192, 16], 3: [201272, 32]}, [['hash', 3], ['hash', 1]]),
   {'hashes': [25159, 8202], 'layout': {'1': [65616, 24], '2': [8192, 16], '3': [201272, 32]}}),
  ('hash requested again before any move',
   ({1: [65616, 24], 2: [8192, 16], 3: [201272, 32]}, [['hash', 2], ['hash', 2], ['move', 1, 20496]]),
   {'hashes': [1024, 1024], 'layout': {'1': [20496, 24], '2': [8192, 16], '3': [201272, 32]}}),
  ('control: no hashing',
   ({1: [65616, 24], 2: [8192, 16], 3: [201272, 32]}, [['move', 2, 24576], ['move', 2, 28688]]),
   {'hashes': [], 'layout': {'1': [65616, 24], '2': [28688, 16], '3': [201272, 32]}})],
 [('regression: hash survives a move',
   ({1: [65624, 24], 2: [8192, 16], 3: [201272, 32]}, [['hash', 1], ['move', 1, 32768], ['hash', 1]]),
   {'hashes': [8203, 8203], 'layout': {'1': [32768, 32], '2': [8192, 16], '3': [201272, 32]}}),
  ('object moved twice after hashing',
   ({1: [65624, 24], 2: [8192, 16], 3: [201272, 32]},
    [['hash', 2], ['move', 2, 36888], ['move', 2, 40960], ['hash', 2]]),
   {'hashes': [1024, 1024], 'layout': {'1': [65624, 24], '2': [40960, 24], '3': [201272, 32]}}),
  ('unhashed object moves freely',
   ({1: [65624, 24], 2: [8192, 16], 3: [201272, 32]}, [['move', 3, 16432], ['hash', 3], ['hash', 3]]),
   {'hashes': [2054, 2054], 'layout': {'1': [65624, 24], '2': [8192, 16], '3': [16432, 32]}}),
  ('high address bits masked after shifting',
   ({1: [65624, 24], 2: [8192, 16], 3: [201272, 32]}, [['hash', 3], ['hash', 1]]),
   {'hashes': [25159, 8203], 'layout': {'1': [65624, 24], '2': [8192, 16], '3': [201272, 32]}}),
  ('hash requested again before any move',
   ({1: [65624, 24], 2: [8192, 16], 3: [201272, 32]}, [['hash', 2], ['hash', 2], ['move', 1, 20504]]),
   {'hashes': [1024, 1024], 'layout': {'1': [20504, 24], '2': [8192, 16], '3': [201272, 32]}}),
  ('control: no hashing',
   ({1: [65624, 24], 2: [8192, 16], 3: [201272, 32]}, [['move', 2, 24576], ['move', 2, 28696]]),
   {'hashes': [], 'layout': {'1': [65624, 24], '2': [28696, 16], '3': [201272, 32]}})],
 [('regression: hash survives a move',
   ({1: [65632, 24], 2: [8192, 16], 3: [201272, 32]}, [['hash', 1], ['move', 1, 32768], ['hash', 1]]),
   {'hashes': [8204, 8204], 'layout': {'1': [32768, 32], '2': [8192, 16], '3': [201272, 32]}}),
  ('object moved twice after hashing',
   ({1: [65632, 24], 2: [8192, 16], 3: [201272, 32]},
    [['hash', 2], ['move', 2, 36896], ['move', 2, 40960], ['hash', 2]]),
   {'hashes': [1024, 1024], 'layout': {'1': [65632, 24], '2': [40960, 24], '3': [201272, 32]}}),
  ('unhashed object moves freely',
   ({1: [65632, 24], 2: [8192, 16], 3: [201272, 32]}, [['move', 3, 16448], ['hash', 3], ['hash', 3]]),
   {'hashes': [2056, 2056], 'layout': {'1': [65632, 24], '2': [8192, 16], '3': [16448, 32]}}),
  ('high address bits masked after shifting',
   ({1: [65632, 24], 2: [8192, 16], 3: [201272, 32]}, [['hash', 3], ['hash', 1]]),
   {'hashes': [25159, 8204], 'layout': {'1': [65632, 24], '2': [8192, 16], '3': [201272, 32]}}),
  ('hash requested again before any move',
   ({1: [65632, 24], 2: [8192, 16], 3: [201272, 32]}, [['hash', 2], ['hash', 2], ['move', 1, 20512]]),
   {'hashes': [1024, 1024], 'layout': {'1': [20512, 24], '2': [8192, 16], '3': [201272, 32]}}),
  ('control: no hashing',
   ({1: [65632, 24], 2: [8192, 16], 3: [201272, 32]}, [['move', 2, 24576], ['move', 2, 28704]]),
   {'hashes': [], 'layout': {'1': [65632, 24], '2': [28704, 16], '3': [201272, 32]}})],
 [('regression: hash survives a move',
   ({1: [65640, 24], 2: [8192, 16], 3: [201272, 32]}, [['hash', 1], ['move', 1, 32768], ['hash', 1]]),
   {'hashes': [8205, 8205], 'layout': {'1': [32768, 32], '2': [8192, 16], '3': [201272, 32]}}),
  ('object moved twice after hashing',
   ({1: [65640, 24], 2: [8192, 16], 3: [201272, 32]},
    [['hash', 2], ['move', 2, 36904], ['move', 2, 40960], ['hash', 2]]),
   {'hashes': [1024, 1024], 'layout': {'1': [65640, 24], '2': [40960, 24], '3': [201272, 32]}}),
  ('unhashed object moves freely',
   ({1: [65640, 24], 2: [8192, 16], 3: [201272, 32]}, [['move', 3, 16464], ['hash', 3], ['hash', 3]]),
   {'hashes': [2058, 2058], 'layout': {'1': [65640, 24], '2': [8192, 16], '3': [16464, 32]}}),
  ('high address bits masked after shifting',
   ({1: [65640, 24], 2: [8192, 16], 3: [201272, 32]}, [['hash', 3], ['hash', 1]]),
   {'hashes': [25159, 8205], 'layout': {'1': [65640, 24], '2': [8192, 16], '3': [201272, 32]}}),
  ('hash requested again before any move',
   ({1: [65640, 24], 2: [8192, 16], 3: [201272, 32]}, [['hash', 2], ['hash', 2], ['move', 1, 20520]]),
   {'hashes': [1024, 1024], 'layout': {'1': [20520, 24], '2': [8192, 16], '3': [201272, 32]}}),
  ('control: no hashing',
   ({1: [65640, 24], 2: [8192, 16], 3: [201272, 32]}, [['move', 2, 24576], ['move', 2, 28712]]),
   {'hashes': [], 'layout': {'1': [65640, 24], '2': [28712, 16], '3': [201272, 32]}})]]
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: hash survives a move{'hashes': [8201, 65608], 'layout': {'1': [32768, 32], '2': [8192, 16], '3': [201272, 32]}}{'hashes': [8201, 8201], 'layout': {'1': [32768, 32], '2': [8192, 16], '3': [201272, 32]}}Failed
object moved twice after hashing{'hashes': [1024, 8192], 'layout': {'1': [65608, 24], '2': [40960, 24], '3': [201272, 32]}}{'hashes': [1024, 1024], 'layout': {'1': [65608, 24], '2': [40960, 24], '3': [201272, 32]}}Failed
unhashed object moves freely{'hashes': [2050, 2050], 'layout': {'1': [65608, 24], '2': [8192, 16], '3': [16400, 32]}}{'hashes': [2050, 2050], 'layout': {'1': [65608, 24], '2': [8192, 16], '3': [16400, 32]}}Passed
high address bits masked after shifting{'hashes': [25159, 8201], 'layout': {'1': [65608, 24], '2': [8192, 16], '3': [201272, 32]}}{'hashes': [25159, 8201], 'layout': {'1': [65608, 24], '2': [8192, 16], '3': [201272, 32]}}Passed
hash requested again before any move{'hashes': [1024, 1024], 'layout': {'1': [20488, 24], '2': [8192, 16], '3': [201272, 32]}}{'hashes': [1024, 1024], 'layout': {'1': [20488, 24], '2': [8192, 16], '3': [201272, 32]}}Passed
control: no hashing{'hashes': [], 'layout': {'1': [65608, 24], '2': [28680, 16], '3': [201272, 32]}}{'hashes': [], 'layout': {'1': [65608, 24], '2': [28680, 16], '3': [201272, 32]}}Passed

SHA-256 / 933ed9b93c4a5d2caf91d2709ce005251734331efdaa26774eba2b9aa0925dd8

HELD IN THE MEMBER ARCHIVE

The verified repair and its recorded checks are member-only.

This mechanism has 6 recorded checks per implementation. The open-access tier publishes the failure and the unsuccessful fix; the repaired source that passes every check, and the observations that prove it, are available to members.

Every case sharing this mechanism uses the same contract and the same repair, so this one record is held back for all of them.

Member access is invitation-based. Sign in with your invited account to inspect the repair.

Sign in to the archive ↗

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

Case digest / 884df628eb6c3987150ef2ec7c3dc04970e3aab36206f50c9eda5091da931a3f