{"abstract":"The last slot of every TLAB is wasted and extra refills happen.","category":"Garbage collector invariants","checks":8,"contract":"Bump allocation through a thread-local buffer (TLAB). Requests are rounded up to 8 bytes. Requests larger than half a TLAB go straight to shared eden. Otherwise allocate in the TLAB when it fits (end inclusive). If not, and the TLAB still has more free space than the refill waste limit, allocate this object in eden, keep the TLAB and raise the limit by waste_inc; else retire the TLAB (its remaining space counts as waste) and carve a new TLAB from eden. Eden allocations fail (None) when they would end beyond eden_end. Return addresses, total waste, eden top and the final limit.","evaluation_group":"w2-garbage-collector-invariants-tlab-allocation","failed_approach":"Reserving a trailing filler word still refuses exact fits and wastes the last word.","family":"w2-garbage-collector-invariants-tlab-allocation-tlab-fit-test","id":"FA-90751","implementations":{"attempt":{"sha256":"2ec956a8245c129843a3213c36374c978065e4837c21f3e33916d7cb54df752e","source":"\"\"\"Failure Map reference implementation. Python standard library only.\"\"\"\nimport json\n\nN = 1\nobservations = []\ndef solve(reqs, eden_start, eden_end, tlab_size, waste_limit, waste_inc):\n    top = eden_start\n    tlab_end = 0\n    cur = 0\n    limit = waste_limit\n    waste = 0\n    out = []\n    def eden_alloc(n):\n        nonlocal top\n        if top + n > eden_end:\n            return None\n        a = top\n        top += n\n        return a\n    for r in reqs:\n        n = (r + 7) // 8 * 8\n        if n > tlab_size // 2:\n            out.append(eden_alloc(n))\n            continue\n        if cur + n <= tlab_end - 8:\n            out.append(cur)\n            cur += n\n            continue\n        remaining = tlab_end - cur\n        if remaining > limit:\n            limit += waste_inc\n            out.append(eden_alloc(n))\n            continue\n        start = eden_alloc(tlab_size)\n        if start is None:\n            out.append(None)\n            continue\n        waste += remaining\n        tlab_end = start + tlab_size\n        cur = start + n\n        out.append(start)\n    return {'addrs': out, 'waste': waste, 'top': top, 'limit': limit}\ndef check(label, actual, expected):\n    observations.append({\"check\": label, \"actual\": actual, \"expected\": expected, \"passed\": actual == expected})\ncases = [[('regression: refill, slow path and adaptation',\n   ([40, 40, 40, 16, 24, 8, 48, 64], 0, 2048, 128, 16, 8),\n   {'addrs': [0, 40, 80, 128, 144, 168, 176, 256], 'limit': 24, 'top': 320, 'waste': 8}),\n  ('allocation exactly filling the buffer',\n   ([64, 56, 8, 8], 0, 4096, 128, 17, 8),\n   {'addrs': [0, 64, 120, 128], 'limit': 17, 'top': 256, 'waste': 0}),\n  ('unaligned requests near the buffer end',\n   ([60, 57, 1], 0, 4096, 128, 16, 8),\n   {'addrs': [0, 64, 128], 'limit': 16, 'top': 256, 'waste': 0}),\n  ('remaining space exactly at the waste limit',\n   ([56, 56, 24, 8], 0, 4096, 128, 16, 8),\n   {'addrs': [0, 56, 128, 152], 'limit': 16, 'top': 256, 'waste': 16}),\n  ('repeated slow paths raise the limit',\n   ([64, 40, 40, 40, 40, 40, 8], 0, 4096, 128, 16, 4),\n   {'addrs': [0, 64, 128, 168, 208, 248, 288], 'limit': 24, 'top': 336, 'waste': 24}),\n  ('request of exactly half a buffer and just above',\n   ([64, 8, 72, 8], 0, 4096, 128, 8, 8),\n   {'addrs': [0, 64, 128, 72], 'limit': 8, 'top': 200, 'waste': 0}),\n  ('eden filled exactly',\n   ([64, 64, 64, 64, 8], 0, 256, 128, 8, 8),\n   {'addrs': [0, 64, 128, 192, None], 'limit': 8, 'top': 256, 'waste': 0}),\n  ('eden refill that would overrun',\n   ([64, 64, 8], 0, 200, 128, 8, 8),\n   {'addrs': [0, 64, None], 'limit': 8, 'top': 128, 'waste': 0})],\n [('regression: refill, slow path and adaptation',\n   ([40, 40, 40, 16, 24, 8, 48, 64], 0, 2048, 128, 16, 8),\n   {'addrs': [0, 40, 80, 128, 144, 168, 176, 256], 'limit': 24, 'top': 320, 'waste': 8}),\n  ('allocation exactly filling the buffer',\n   ([64, 56, 8, 8], 0, 4096, 128, 18, 8),\n   {'addrs': [0, 64, 120, 128], 'limit': 18, 'top': 256, 'waste': 0}),\n  ('unaligned requests near the buffer end',\n   ([60, 57, 1], 0, 4096, 128, 16, 8),\n   {'addrs': [0, 64, 128], 'limit': 16, 'top': 256, 'waste': 0}),\n  ('remaining space exactly at the waste limit',\n   ([56, 56, 24, 16], 0, 4096, 128, 16, 8),\n   {'addrs': [0, 56, 128, 152], 'limit': 16, 'top': 256, 'waste': 16}),\n  ('repeated slow paths raise the limit',\n   ([64, 40, 40, 40, 40, 40, 16], 0, 4096, 128, 16, 4),\n   {'addrs': [0, 64, 128, 168, 208, 248, 288], 'limit': 24, 'top': 336, 'waste': 24}),\n  ('request of exactly half a buffer and just above',\n   ([64, 8, 72, 16], 0, 4096, 128, 8, 8),\n   {'addrs': [0, 64, 128, 72], 'limit': 8, 'top': 200, 'waste': 0}),\n  ('eden filled exactly',\n   ([64, 64, 64, 64, 16], 0, 256, 128, 8, 8),\n   {'addrs': [0, 64, 128, 192, None], 'limit': 8, 'top': 256, 'waste': 0}),\n  ('eden refill that would overrun',\n   ([64, 64, 16], 0, 200, 128, 8, 8),\n   {'addrs': [0, 64, None], 'limit': 8, 'top': 128, 'waste': 0})],\n [('regression: refill, slow path and adaptation',\n   ([40, 40, 40, 16, 24, 8, 48, 64], 0, 2048, 128, 16, 8),\n   {'addrs': [0, 40, 80, 128, 144, 168, 176, 256], 'limit': 24, 'top': 320, 'waste': 8}),\n  ('allocation exactly filling the buffer',\n   ([64, 56, 8, 8], 0, 4096, 128, 19, 8),\n   {'addrs': [0, 64, 120, 128], 'limit': 19, 'top': 256, 'waste': 0}),\n  ('unaligned requests near the buffer end',\n   ([60, 57, 1], 0, 4096, 128, 16, 8),\n   {'addrs': [0, 64, 128], 'limit': 16, 'top': 256, 'waste': 0}),\n  ('remaining space exactly at the waste limit',\n   ([56, 56, 24, 24], 0, 4096, 128, 16, 8),\n   {'addrs': [0, 56, 128, 152], 'limit': 16, 'top': 256, 'waste': 16}),\n  ('repeated slow paths raise the limit',\n   ([64, 40, 40, 40, 40, 40, 24], 0, 4096, 128, 16, 4),\n   {'addrs': [0, 64, 128, 168, 208, 248, 288], 'limit': 24, 'top': 336, 'waste': 24}),\n  ('request of exactly half a buffer and just above',\n   ([64, 8, 72, 24], 0, 4096, 128, 8, 8),\n   {'addrs': [0, 64, 128, 72], 'limit': 8, 'top': 200, 'waste': 0}),\n  ('eden filled exactly',\n   ([64, 64, 64, 64, 24], 0, 256, 128, 8, 8),\n   {'addrs': [0, 64, 128, 192, None], 'limit': 8, 'top': 256, 'waste': 0}),\n  ('eden refill that would overrun',\n   ([64, 64, 24], 0, 200, 128, 8, 8),\n   {'addrs': [0, 64, None], 'limit': 8, 'top': 128, 'waste': 0})],\n [('regression: refill, slow path and adaptation',\n   ([40, 40, 40, 16, 24, 8, 48, 64], 0, 2048, 128, 16, 8),\n   {'addrs': [0, 40, 80, 128, 144, 168, 176, 256], 'limit': 24, 'top': 320, 'waste': 8}),\n  ('allocation exactly filling the buffer',\n   ([64, 56, 8, 8], 0, 4096, 128, 20, 8),\n   {'addrs': [0, 64, 120, 128], 'limit': 20, 'top': 256, 'waste': 0}),\n  ('unaligned requests near the buffer end',\n   ([60, 57, 1], 0, 4096, 128, 16, 8),\n   {'addrs': [0, 64, 128], 'limit': 16, 'top': 256, 'waste': 0}),\n  ('remaining space exactly at the waste limit',\n   ([56, 56, 24, 32], 0, 4096, 128, 16, 8),\n   {'addrs': [0, 56, 128, 152], 'limit': 16, 'top': 256, 'waste': 16}),\n  ('repeated slow paths raise the limit',\n   ([64, 40, 40, 40, 40, 40, 32], 0, 4096, 128, 16, 4),\n   {'addrs': [0, 64, 128, 168, 208, 248, 288], 'limit': 24, 'top': 336, 'waste': 24}),\n  ('request of exactly half a buffer and just above',\n   ([64, 8, 72, 32], 0, 4096, 128, 8, 8),\n   {'addrs': [0, 64, 128, 72], 'limit': 8, 'top': 200, 'waste': 0}),\n  ('eden filled exactly',\n   ([64, 64, 64, 64, 32], 0, 256, 128, 8, 8),\n   {'addrs': [0, 64, 128, 192, None], 'limit': 8, 'top': 256, 'waste': 0}),\n  ('eden refill that would overrun',\n   ([64, 64, 32], 0, 200, 128, 8, 8),\n   {'addrs': [0, 64, None], 'limit': 8, 'top': 128, 'waste': 0})],\n [('regression: refill, slow path and adaptation',\n   ([40, 40, 40, 16, 24, 8, 48, 64], 0, 2048, 128, 16, 8),\n   {'addrs': [0, 40, 80, 128, 144, 168, 176, 256], 'limit': 24, 'top': 320, 'waste': 8}),\n  ('allocation exactly filling the buffer',\n   ([64, 56, 8, 8], 0, 4096, 128, 21, 8),\n   {'addrs': [0, 64, 120, 128], 'limit': 21, 'top': 256, 'waste': 0}),\n  ('unaligned requests near the buffer end',\n   ([60, 57, 1], 0, 4096, 128, 16, 8),\n   {'addrs': [0, 64, 128], 'limit': 16, 'top': 256, 'waste': 0}),\n  ('remaining space exactly at the waste limit',\n   ([56, 56, 24, 40], 0, 4096, 128, 16, 8),\n   {'addrs': [0, 56, 128, 152], 'limit': 16, 'top': 256, 'waste': 16}),\n  ('repeated slow paths raise the limit',\n   ([64, 40, 40, 40, 40, 40, 40], 0, 4096, 128, 16, 4),\n   {'addrs': [0, 64, 128, 168, 208, 248, 288], 'limit': 24, 'top': 336, 'waste': 24}),\n  ('request of exactly half a buffer and just above',\n   ([64, 8, 72, 40], 0, 4096, 128, 8, 8),\n   {'addrs': [0, 64, 128, 72], 'limit': 8, 'top': 200, 'waste': 0}),\n  ('eden filled exactly',\n   ([64, 64, 64, 64, 40], 0, 256, 128, 8, 8),\n   {'addrs': [0, 64, 128, 192, None], 'limit': 8, 'top': 256, 'waste': 0}),\n  ('eden refill that would overrun',\n   ([64, 64, 40], 0, 200, 128, 8, 8),\n   {'addrs': [0, 64, None], 'limit': 8, 'top': 128, 'waste': 0})]]\nfor label, args, expected in cases[N - 1]:\n    check(label, solve(*args), expected)\nprint(json.dumps({\"observations\": observations, \"passed\": all(x[\"passed\"] for x in observations)}, ensure_ascii=False))\nraise SystemExit(0 if all(x[\"passed\"] for x in observations) else 1)\n"},"broken":{"sha256":"60a194d95bab144197f2c73c45dc2f3f7255606eaecc7f310b32db189899c21f","source":"\"\"\"Failure Map reference implementation. Python standard library only.\"\"\"\nimport json\n\nN = 1\nobservations = []\ndef solve(reqs, eden_start, eden_end, tlab_size, waste_limit, waste_inc):\n    top = eden_start\n    tlab_end = 0\n    cur = 0\n    limit = waste_limit\n    waste = 0\n    out = []\n    def eden_alloc(n):\n        nonlocal top\n        if top + n > eden_end:\n            return None\n        a = top\n        top += n\n        return a\n    for r in reqs:\n        n = (r + 7) // 8 * 8\n        if n > tlab_size // 2:\n            out.append(eden_alloc(n))\n            continue\n        if cur + n < tlab_end:\n            out.append(cur)\n            cur += n\n            continue\n        remaining = tlab_end - cur\n        if remaining > limit:\n            limit += waste_inc\n            out.append(eden_alloc(n))\n            continue\n        start = eden_alloc(tlab_size)\n        if start is None:\n            out.append(None)\n            continue\n        waste += remaining\n        tlab_end = start + tlab_size\n        cur = start + n\n        out.append(start)\n    return {'addrs': out, 'waste': waste, 'top': top, 'limit': limit}\ndef check(label, actual, expected):\n    observations.append({\"check\": label, \"actual\": actual, \"expected\": expected, \"passed\": actual == expected})\ncases = [[('regression: refill, slow path and adaptation',\n   ([40, 40, 40, 16, 24, 8, 48, 64], 0, 2048, 128, 16, 8),\n   {'addrs': [0, 40, 80, 128, 144, 168, 176, 256], 'limit': 24, 'top': 320, 'waste': 8}),\n  ('allocation exactly filling the buffer',\n   ([64, 56, 8, 8], 0, 4096, 128, 17, 8),\n   {'addrs': [0, 64, 120, 128], 'limit': 17, 'top': 256, 'waste': 0}),\n  ('unaligned requests near the buffer end',\n   ([60, 57, 1], 0, 4096, 128, 16, 8),\n   {'addrs': [0, 64, 128], 'limit': 16, 'top': 256, 'waste': 0}),\n  ('remaining space exactly at the waste limit',\n   ([56, 56, 24, 8], 0, 4096, 128, 16, 8),\n   {'addrs': [0, 56, 128, 152], 'limit': 16, 'top': 256, 'waste': 16}),\n  ('repeated slow paths raise the limit',\n   ([64, 40, 40, 40, 40, 40, 8], 0, 4096, 128, 16, 4),\n   {'addrs': [0, 64, 128, 168, 208, 248, 288], 'limit': 24, 'top': 336, 'waste': 24}),\n  ('request of exactly half a buffer and just above',\n   ([64, 8, 72, 8], 0, 4096, 128, 8, 8),\n   {'addrs': [0, 64, 128, 72], 'limit': 8, 'top': 200, 'waste': 0}),\n  ('eden filled exactly',\n   ([64, 64, 64, 64, 8], 0, 256, 128, 8, 8),\n   {'addrs': [0, 64, 128, 192, None], 'limit': 8, 'top': 256, 'waste': 0}),\n  ('eden refill that would overrun',\n   ([64, 64, 8], 0, 200, 128, 8, 8),\n   {'addrs': [0, 64, None], 'limit': 8, 'top': 128, 'waste': 0})],\n [('regression: refill, slow path and adaptation',\n   ([40, 40, 40, 16, 24, 8, 48, 64], 0, 2048, 128, 16, 8),\n   {'addrs': [0, 40, 80, 128, 144, 168, 176, 256], 'limit': 24, 'top': 320, 'waste': 8}),\n  ('allocation exactly filling the buffer',\n   ([64, 56, 8, 8], 0, 4096, 128, 18, 8),\n   {'addrs': [0, 64, 120, 128], 'limit': 18, 'top': 256, 'waste': 0}),\n  ('unaligned requests near the buffer end',\n   ([60, 57, 1], 0, 4096, 128, 16, 8),\n   {'addrs': [0, 64, 128], 'limit': 16, 'top': 256, 'waste': 0}),\n  ('remaining space exactly at the waste limit',\n   ([56, 56, 24, 16], 0, 4096, 128, 16, 8),\n   {'addrs': [0, 56, 128, 152], 'limit': 16, 'top': 256, 'waste': 16}),\n  ('repeated slow paths raise the limit',\n   ([64, 40, 40, 40, 40, 40, 16], 0, 4096, 128, 16, 4),\n   {'addrs': [0, 64, 128, 168, 208, 248, 288], 'limit': 24, 'top': 336, 'waste': 24}),\n  ('request of exactly half a buffer and just above',\n   ([64, 8, 72, 16], 0, 4096, 128, 8, 8),\n   {'addrs': [0, 64, 128, 72], 'limit': 8, 'top': 200, 'waste': 0}),\n  ('eden filled exactly',\n   ([64, 64, 64, 64, 16], 0, 256, 128, 8, 8),\n   {'addrs': [0, 64, 128, 192, None], 'limit': 8, 'top': 256, 'waste': 0}),\n  ('eden refill that would overrun',\n   ([64, 64, 16], 0, 200, 128, 8, 8),\n   {'addrs': [0, 64, None], 'limit': 8, 'top': 128, 'waste': 0})],\n [('regression: refill, slow path and adaptation',\n   ([40, 40, 40, 16, 24, 8, 48, 64], 0, 2048, 128, 16, 8),\n   {'addrs': [0, 40, 80, 128, 144, 168, 176, 256], 'limit': 24, 'top': 320, 'waste': 8}),\n  ('allocation exactly filling the buffer',\n   ([64, 56, 8, 8], 0, 4096, 128, 19, 8),\n   {'addrs': [0, 64, 120, 128], 'limit': 19, 'top': 256, 'waste': 0}),\n  ('unaligned requests near the buffer end',\n   ([60, 57, 1], 0, 4096, 128, 16, 8),\n   {'addrs': [0, 64, 128], 'limit': 16, 'top': 256, 'waste': 0}),\n  ('remaining space exactly at the waste limit',\n   ([56, 56, 24, 24], 0, 4096, 128, 16, 8),\n   {'addrs': [0, 56, 128, 152], 'limit': 16, 'top': 256, 'waste': 16}),\n  ('repeated slow paths raise the limit',\n   ([64, 40, 40, 40, 40, 40, 24], 0, 4096, 128, 16, 4),\n   {'addrs': [0, 64, 128, 168, 208, 248, 288], 'limit': 24, 'top': 336, 'waste': 24}),\n  ('request of exactly half a buffer and just above',\n   ([64, 8, 72, 24], 0, 4096, 128, 8, 8),\n   {'addrs': [0, 64, 128, 72], 'limit': 8, 'top': 200, 'waste': 0}),\n  ('eden filled exactly',\n   ([64, 64, 64, 64, 24], 0, 256, 128, 8, 8),\n   {'addrs': [0, 64, 128, 192, None], 'limit': 8, 'top': 256, 'waste': 0}),\n  ('eden refill that would overrun',\n   ([64, 64, 24], 0, 200, 128, 8, 8),\n   {'addrs': [0, 64, None], 'limit': 8, 'top': 128, 'waste': 0})],\n [('regression: refill, slow path and adaptation',\n   ([40, 40, 40, 16, 24, 8, 48, 64], 0, 2048, 128, 16, 8),\n   {'addrs': [0, 40, 80, 128, 144, 168, 176, 256], 'limit': 24, 'top': 320, 'waste': 8}),\n  ('allocation exactly filling the buffer',\n   ([64, 56, 8, 8], 0, 4096, 128, 20, 8),\n   {'addrs': [0, 64, 120, 128], 'limit': 20, 'top': 256, 'waste': 0}),\n  ('unaligned requests near the buffer end',\n   ([60, 57, 1], 0, 4096, 128, 16, 8),\n   {'addrs': [0, 64, 128], 'limit': 16, 'top': 256, 'waste': 0}),\n  ('remaining space exactly at the waste limit',\n   ([56, 56, 24, 32], 0, 4096, 128, 16, 8),\n   {'addrs': [0, 56, 128, 152], 'limit': 16, 'top': 256, 'waste': 16}),\n  ('repeated slow paths raise the limit',\n   ([64, 40, 40, 40, 40, 40, 32], 0, 4096, 128, 16, 4),\n   {'addrs': [0, 64, 128, 168, 208, 248, 288], 'limit': 24, 'top': 336, 'waste': 24}),\n  ('request of exactly half a buffer and just above',\n   ([64, 8, 72, 32], 0, 4096, 128, 8, 8),\n   {'addrs': [0, 64, 128, 72], 'limit': 8, 'top': 200, 'waste': 0}),\n  ('eden filled exactly',\n   ([64, 64, 64, 64, 32], 0, 256, 128, 8, 8),\n   {'addrs': [0, 64, 128, 192, None], 'limit': 8, 'top': 256, 'waste': 0}),\n  ('eden refill that would overrun',\n   ([64, 64, 32], 0, 200, 128, 8, 8),\n   {'addrs': [0, 64, None], 'limit': 8, 'top': 128, 'waste': 0})],\n [('regression: refill, slow path and adaptation',\n   ([40, 40, 40, 16, 24, 8, 48, 64], 0, 2048, 128, 16, 8),\n   {'addrs': [0, 40, 80, 128, 144, 168, 176, 256], 'limit': 24, 'top': 320, 'waste': 8}),\n  ('allocation exactly filling the buffer',\n   ([64, 56, 8, 8], 0, 4096, 128, 21, 8),\n   {'addrs': [0, 64, 120, 128], 'limit': 21, 'top': 256, 'waste': 0}),\n  ('unaligned requests near the buffer end',\n   ([60, 57, 1], 0, 4096, 128, 16, 8),\n   {'addrs': [0, 64, 128], 'limit': 16, 'top': 256, 'waste': 0}),\n  ('remaining space exactly at the waste limit',\n   ([56, 56, 24, 40], 0, 4096, 128, 16, 8),\n   {'addrs': [0, 56, 128, 152], 'limit': 16, 'top': 256, 'waste': 16}),\n  ('repeated slow paths raise the limit',\n   ([64, 40, 40, 40, 40, 40, 40], 0, 4096, 128, 16, 4),\n   {'addrs': [0, 64, 128, 168, 208, 248, 288], 'limit': 24, 'top': 336, 'waste': 24}),\n  ('request of exactly half a buffer and just above',\n   ([64, 8, 72, 40], 0, 4096, 128, 8, 8),\n   {'addrs': [0, 64, 128, 72], 'limit': 8, 'top': 200, 'waste': 0}),\n  ('eden filled exactly',\n   ([64, 64, 64, 64, 40], 0, 256, 128, 8, 8),\n   {'addrs': [0, 64, 128, 192, None], 'limit': 8, 'top': 256, 'waste': 0}),\n  ('eden refill that would overrun',\n   ([64, 64, 40], 0, 200, 128, 8, 8),\n   {'addrs': [0, 64, None], 'limit': 8, 'top': 128, 'waste': 0})]]\nfor label, args, expected in cases[N - 1]:\n    check(label, solve(*args), expected)\nprint(json.dumps({\"observations\": observations, \"passed\": all(x[\"passed\"] for x in observations)}, ensure_ascii=False))\nraise SystemExit(0 if all(x[\"passed\"] for x in observations) else 1)\n"},"fixed":{"sha256":"4ab965eec17e97897a8432f4ef495b22de3ff271451efe598bc4d8d19ba0c992","source":"\"\"\"Failure Map reference implementation. Python standard library only.\"\"\"\nimport json\n\nN = 1\nobservations = []\ndef solve(reqs, eden_start, eden_end, tlab_size, waste_limit, waste_inc):\n    top = eden_start\n    tlab_end = 0\n    cur = 0\n    limit = waste_limit\n    waste = 0\n    out = []\n    def eden_alloc(n):\n        nonlocal top\n        if top + n > eden_end:\n            return None\n        a = top\n        top += n\n        return a\n    for r in reqs:\n        n = (r + 7) // 8 * 8\n        if n > tlab_size // 2:\n            out.append(eden_alloc(n))\n            continue\n        if cur + n <= tlab_end:\n            out.append(cur)\n            cur += n\n            continue\n        remaining = tlab_end - cur\n        if remaining > limit:\n            limit += waste_inc\n            out.append(eden_alloc(n))\n            continue\n        start = eden_alloc(tlab_size)\n        if start is None:\n            out.append(None)\n            continue\n        waste += remaining\n        tlab_end = start + tlab_size\n        cur = start + n\n        out.append(start)\n    return {'addrs': out, 'waste': waste, 'top': top, 'limit': limit}\ndef check(label, actual, expected):\n    observations.append({\"check\": label, \"actual\": actual, \"expected\": expected, \"passed\": actual == expected})\ncases = [[('regression: refill, slow path and adaptation',\n   ([40, 40, 40, 16, 24, 8, 48, 64], 0, 2048, 128, 16, 8),\n   {'addrs': [0, 40, 80, 128, 144, 168, 176, 256], 'limit': 24, 'top': 320, 'waste': 8}),\n  ('allocation exactly filling the buffer',\n   ([64, 56, 8, 8], 0, 4096, 128, 17, 8),\n   {'addrs': [0, 64, 120, 128], 'limit': 17, 'top': 256, 'waste': 0}),\n  ('unaligned requests near the buffer end',\n   ([60, 57, 1], 0, 4096, 128, 16, 8),\n   {'addrs': [0, 64, 128], 'limit': 16, 'top': 256, 'waste': 0}),\n  ('remaining space exactly at the waste limit',\n   ([56, 56, 24, 8], 0, 4096, 128, 16, 8),\n   {'addrs': [0, 56, 128, 152], 'limit': 16, 'top': 256, 'waste': 16}),\n  ('repeated slow paths raise the limit',\n   ([64, 40, 40, 40, 40, 40, 8], 0, 4096, 128, 16, 4),\n   {'addrs': [0, 64, 128, 168, 208, 248, 288], 'limit': 24, 'top': 336, 'waste': 24}),\n  ('request of exactly half a buffer and just above',\n   ([64, 8, 72, 8], 0, 4096, 128, 8, 8),\n   {'addrs': [0, 64, 128, 72], 'limit': 8, 'top': 200, 'waste': 0}),\n  ('eden filled exactly',\n   ([64, 64, 64, 64, 8], 0, 256, 128, 8, 8),\n   {'addrs': [0, 64, 128, 192, None], 'limit': 8, 'top': 256, 'waste': 0}),\n  ('eden refill that would overrun',\n   ([64, 64, 8], 0, 200, 128, 8, 8),\n   {'addrs': [0, 64, None], 'limit': 8, 'top': 128, 'waste': 0})],\n [('regression: refill, slow path and adaptation',\n   ([40, 40, 40, 16, 24, 8, 48, 64], 0, 2048, 128, 16, 8),\n   {'addrs': [0, 40, 80, 128, 144, 168, 176, 256], 'limit': 24, 'top': 320, 'waste': 8}),\n  ('allocation exactly filling the buffer',\n   ([64, 56, 8, 8], 0, 4096, 128, 18, 8),\n   {'addrs': [0, 64, 120, 128], 'limit': 18, 'top': 256, 'waste': 0}),\n  ('unaligned requests near the buffer end',\n   ([60, 57, 1], 0, 4096, 128, 16, 8),\n   {'addrs': [0, 64, 128], 'limit': 16, 'top': 256, 'waste': 0}),\n  ('remaining space exactly at the waste limit',\n   ([56, 56, 24, 16], 0, 4096, 128, 16, 8),\n   {'addrs': [0, 56, 128, 152], 'limit': 16, 'top': 256, 'waste': 16}),\n  ('repeated slow paths raise the limit',\n   ([64, 40, 40, 40, 40, 40, 16], 0, 4096, 128, 16, 4),\n   {'addrs': [0, 64, 128, 168, 208, 248, 288], 'limit': 24, 'top': 336, 'waste': 24}),\n  ('request of exactly half a buffer and just above',\n   ([64, 8, 72, 16], 0, 4096, 128, 8, 8),\n   {'addrs': [0, 64, 128, 72], 'limit': 8, 'top': 200, 'waste': 0}),\n  ('eden filled exactly',\n   ([64, 64, 64, 64, 16], 0, 256, 128, 8, 8),\n   {'addrs': [0, 64, 128, 192, None], 'limit': 8, 'top': 256, 'waste': 0}),\n  ('eden refill that would overrun',\n   ([64, 64, 16], 0, 200, 128, 8, 8),\n   {'addrs': [0, 64, None], 'limit': 8, 'top': 128, 'waste': 0})],\n [('regression: refill, slow path and adaptation',\n   ([40, 40, 40, 16, 24, 8, 48, 64], 0, 2048, 128, 16, 8),\n   {'addrs': [0, 40, 80, 128, 144, 168, 176, 256], 'limit': 24, 'top': 320, 'waste': 8}),\n  ('allocation exactly filling the buffer',\n   ([64, 56, 8, 8], 0, 4096, 128, 19, 8),\n   {'addrs': [0, 64, 120, 128], 'limit': 19, 'top': 256, 'waste': 0}),\n  ('unaligned requests near the buffer end',\n   ([60, 57, 1], 0, 4096, 128, 16, 8),\n   {'addrs': [0, 64, 128], 'limit': 16, 'top': 256, 'waste': 0}),\n  ('remaining space exactly at the waste limit',\n   ([56, 56, 24, 24], 0, 4096, 128, 16, 8),\n   {'addrs': [0, 56, 128, 152], 'limit': 16, 'top': 256, 'waste': 16}),\n  ('repeated slow paths raise the limit',\n   ([64, 40, 40, 40, 40, 40, 24], 0, 4096, 128, 16, 4),\n   {'addrs': [0, 64, 128, 168, 208, 248, 288], 'limit': 24, 'top': 336, 'waste': 24}),\n  ('request of exactly half a buffer and just above',\n   ([64, 8, 72, 24], 0, 4096, 128, 8, 8),\n   {'addrs': [0, 64, 128, 72], 'limit': 8, 'top': 200, 'waste': 0}),\n  ('eden filled exactly',\n   ([64, 64, 64, 64, 24], 0, 256, 128, 8, 8),\n   {'addrs': [0, 64, 128, 192, None], 'limit': 8, 'top': 256, 'waste': 0}),\n  ('eden refill that would overrun',\n   ([64, 64, 24], 0, 200, 128, 8, 8),\n   {'addrs': [0, 64, None], 'limit': 8, 'top': 128, 'waste': 0})],\n [('regression: refill, slow path and adaptation',\n   ([40, 40, 40, 16, 24, 8, 48, 64], 0, 2048, 128, 16, 8),\n   {'addrs': [0, 40, 80, 128, 144, 168, 176, 256], 'limit': 24, 'top': 320, 'waste': 8}),\n  ('allocation exactly filling the buffer',\n   ([64, 56, 8, 8], 0, 4096, 128, 20, 8),\n   {'addrs': [0, 64, 120, 128], 'limit': 20, 'top': 256, 'waste': 0}),\n  ('unaligned requests near the buffer end',\n   ([60, 57, 1], 0, 4096, 128, 16, 8),\n   {'addrs': [0, 64, 128], 'limit': 16, 'top': 256, 'waste': 0}),\n  ('remaining space exactly at the waste limit',\n   ([56, 56, 24, 32], 0, 4096, 128, 16, 8),\n   {'addrs': [0, 56, 128, 152], 'limit': 16, 'top': 256, 'waste': 16}),\n  ('repeated slow paths raise the limit',\n   ([64, 40, 40, 40, 40, 40, 32], 0, 4096, 128, 16, 4),\n   {'addrs': [0, 64, 128, 168, 208, 248, 288], 'limit': 24, 'top': 336, 'waste': 24}),\n  ('request of exactly half a buffer and just above',\n   ([64, 8, 72, 32], 0, 4096, 128, 8, 8),\n   {'addrs': [0, 64, 128, 72], 'limit': 8, 'top': 200, 'waste': 0}),\n  ('eden filled exactly',\n   ([64, 64, 64, 64, 32], 0, 256, 128, 8, 8),\n   {'addrs': [0, 64, 128, 192, None], 'limit': 8, 'top': 256, 'waste': 0}),\n  ('eden refill that would overrun',\n   ([64, 64, 32], 0, 200, 128, 8, 8),\n   {'addrs': [0, 64, None], 'limit': 8, 'top': 128, 'waste': 0})],\n [('regression: refill, slow path and adaptation',\n   ([40, 40, 40, 16, 24, 8, 48, 64], 0, 2048, 128, 16, 8),\n   {'addrs': [0, 40, 80, 128, 144, 168, 176, 256], 'limit': 24, 'top': 320, 'waste': 8}),\n  ('allocation exactly filling the buffer',\n   ([64, 56, 8, 8], 0, 4096, 128, 21, 8),\n   {'addrs': [0, 64, 120, 128], 'limit': 21, 'top': 256, 'waste': 0}),\n  ('unaligned requests near the buffer end',\n   ([60, 57, 1], 0, 4096, 128, 16, 8),\n   {'addrs': [0, 64, 128], 'limit': 16, 'top': 256, 'waste': 0}),\n  ('remaining space exactly at the waste limit',\n   ([56, 56, 24, 40], 0, 4096, 128, 16, 8),\n   {'addrs': [0, 56, 128, 152], 'limit': 16, 'top': 256, 'waste': 16}),\n  ('repeated slow paths raise the limit',\n   ([64, 40, 40, 40, 40, 40, 40], 0, 4096, 128, 16, 4),\n   {'addrs': [0, 64, 128, 168, 208, 248, 288], 'limit': 24, 'top': 336, 'waste': 24}),\n  ('request of exactly half a buffer and just above',\n   ([64, 8, 72, 40], 0, 4096, 128, 8, 8),\n   {'addrs': [0, 64, 128, 72], 'limit': 8, 'top': 200, 'waste': 0}),\n  ('eden filled exactly',\n   ([64, 64, 64, 64, 40], 0, 256, 128, 8, 8),\n   {'addrs': [0, 64, 128, 192, None], 'limit': 8, 'top': 256, 'waste': 0}),\n  ('eden refill that would overrun',\n   ([64, 64, 40], 0, 200, 128, 8, 8),\n   {'addrs': [0, 64, None], 'limit': 8, 'top': 128, 'waste': 0})]]\nfor label, args, expected in cases[N - 1]:\n    check(label, solve(*args), expected)\nprint(json.dumps({\"observations\": observations, \"passed\": all(x[\"passed\"] for x in observations)}, ensure_ascii=False))\nraise SystemExit(0 if all(x[\"passed\"] for x in observations) else 1)\n"}},"limitations":"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.","method":"Deterministic executable model with adversarial boundary fixtures.","provenance":{"created_by":"Failure Map","dependencies":"Python standard library","family":"w2-garbage-collector-invariants-tlab-allocation-tlab-fit-test","generated_at":"2026-09-29T14:51:29.666984+00:00","license":"CC0-1.0","python":"3.12.14","seed":1,"split":"open-access"},"relevance":"Allocation fast paths decide heap layout and GC frequency; boundary slips waste memory or overlap objects.","repair":"An object fits when cur + size <= end.","root_cause":"The fast-path fit test uses <, excluding an exact fit.","sha256":"c2fe1c12d31981881df37fc2c122ef29b00d95678b89fdf955aee43932bfbed6","title":"TLAB: allocation ending exactly at the buffer end refused · case 01","variant":1,"variant_policy":"Five numbered records share a model and may reuse boundary fixtures.","verification":{"attempt":{"elapsed_ms":41.477,"exit_code":1,"observations":[{"actual":{"addrs":[0,40,80,128,144,168,176,256],"limit":24,"top":320,"waste":8},"check":"regression: refill, slow path and adaptation","expected":{"addrs":[0,40,80,128,144,168,176,256],"limit":24,"top":320,"waste":8},"passed":true},{"actual":{"addrs":[0,64,128,136],"limit":17,"top":256,"waste":8},"check":"allocation exactly filling the buffer","expected":{"addrs":[0,64,120,128],"limit":17,"top":256,"waste":0},"passed":false},{"actual":{"addrs":[0,128,64],"limit":24,"top":192,"waste":0},"check":"unaligned requests near the buffer end","expected":{"addrs":[0,64,128],"limit":16,"top":256,"waste":0},"passed":false},{"actual":{"addrs":[0,56,128,152],"limit":16,"top":256,"waste":16},"check":"remaining space exactly at the waste limit","expected":{"addrs":[0,56,128,152],"limit":16,"top":256,"waste":16},"passed":true},{"actual":{"addrs":[0,64,128,168,208,248,288],"limit":24,"top":336,"waste":24},"check":"repeated slow paths raise the limit","expected":{"addrs":[0,64,128,168,208,248,288],"limit":24,"top":336,"waste":24},"passed":true},{"actual":{"addrs":[0,64,128,72],"limit":8,"top":200,"waste":0},"check":"request of exactly half a buffer and just above","expected":{"addrs":[0,64,128,72],"limit":8,"top":200,"waste":0},"passed":true},{"actual":{"addrs":[0,128,192,null,64],"limit":32,"top":256,"waste":0},"check":"eden filled exactly","expected":{"addrs":[0,64,128,192,null],"limit":8,"top":256,"waste":0},"passed":false},{"actual":{"addrs":[0,128,64],"limit":16,"top":192,"waste":0},"check":"eden refill that would overrun","expected":{"addrs":[0,64,null],"limit":8,"top":128,"waste":0},"passed":false}],"passed":false,"stderr":"","stdout":"{\"observations\": [{\"check\": \"regression: refill, slow path and adaptation\", \"actual\": {\"addrs\": [0, 40, 80, 128, 144, 168, 176, 256], \"waste\": 8, \"top\": 320, \"limit\": 24}, \"expected\": {\"addrs\": [0, 40, 80, 128, 144, 168, 176, 256], \"limit\": 24, \"top\": 320, \"waste\": 8}, \"passed\": true}, {\"check\": \"allocation exactly filling the buffer\", \"actual\": {\"addrs\": [0, 64, 128, 136], \"waste\": 8, \"top\": 256, \"limit\": 17}, \"expected\": {\"addrs\": [0, 64, 120, 128], \"limit\": 17, \"top\": 256, \"waste\": 0}, \"passed\": false}, {\"check\": \"unaligned requests near the buffer end\", \"actual\": {\"addrs\": [0, 128, 64], \"waste\": 0, \"top\": 192, \"limit\": 24}, \"expected\": {\"addrs\": [0, 64, 128], \"limit\": 16, \"top\": 256, \"waste\": 0}, \"passed\": false}, {\"check\": \"remaining space exactly at the waste limit\", \"actual\": {\"addrs\": [0, 56, 128, 152], \"waste\": 16, \"top\": 256, \"limit\": 16}, \"expected\": {\"addrs\": [0, 56, 128, 152], \"limit\": 16, \"top\": 256, \"waste\": 16}, \"passed\": true}, {\"check\": \"repeated slow paths raise the limit\", \"actual\": {\"addrs\": [0, 64, 128, 168, 208, 248, 288], \"waste\": 24, \"top\": 336, \"limit\": 24}, \"expected\": {\"addrs\": [0, 64, 128, 168, 208, 248, 288], \"limit\": 24, \"top\": 336, \"waste\": 24}, \"passed\": true}, {\"check\": \"request of exactly half a buffer and just above\", \"actual\": {\"addrs\": [0, 64, 128, 72], \"waste\": 0, \"top\": 200, \"limit\": 8}, \"expected\": {\"addrs\": [0, 64, 128, 72], \"limit\": 8, \"top\": 200, \"waste\": 0}, \"passed\": true}, {\"check\": \"eden filled exactly\", \"actual\": {\"addrs\": [0, 128, 192, null, 64], \"waste\": 0, \"top\": 256, \"limit\": 32}, \"expected\": {\"addrs\": [0, 64, 128, 192, null], \"limit\": 8, \"top\": 256, \"waste\": 0}, \"passed\": false}, {\"check\": \"eden refill that would overrun\", \"actual\": {\"addrs\": [0, 128, 64], \"waste\": 0, \"top\": 192, \"limit\": 16}, \"expected\": {\"addrs\": [0, 64, null], \"limit\": 8, \"top\": 128, \"waste\": 0}, \"passed\": false}], \"passed\": false}\n"},"broken":{"elapsed_ms":39.084,"exit_code":1,"observations":[{"actual":{"addrs":[0,40,80,128,144,168,176,256],"limit":24,"top":320,"waste":8},"check":"regression: refill, slow path and adaptation","expected":{"addrs":[0,40,80,128,144,168,176,256],"limit":24,"top":320,"waste":8},"passed":true},{"actual":{"addrs":[0,64,128,136],"limit":17,"top":256,"waste":8},"check":"allocation exactly filling the buffer","expected":{"addrs":[0,64,120,128],"limit":17,"top":256,"waste":0},"passed":false},{"actual":{"addrs":[0,128,64],"limit":24,"top":192,"waste":0},"check":"unaligned requests near the buffer end","expected":{"addrs":[0,64,128],"limit":16,"top":256,"waste":0},"passed":false},{"actual":{"addrs":[0,56,128,152],"limit":16,"top":256,"waste":16},"check":"remaining space exactly at the waste limit","expected":{"addrs":[0,56,128,152],"limit":16,"top":256,"waste":16},"passed":true},{"actual":{"addrs":[0,64,128,168,208,248,288],"limit":24,"top":336,"waste":24},"check":"repeated slow paths raise the limit","expected":{"addrs":[0,64,128,168,208,248,288],"limit":24,"top":336,"waste":24},"passed":true},{"actual":{"addrs":[0,64,128,72],"limit":8,"top":200,"waste":0},"check":"request of exactly half a buffer and just above","expected":{"addrs":[0,64,128,72],"limit":8,"top":200,"waste":0},"passed":true},{"actual":{"addrs":[0,128,192,null,64],"limit":32,"top":256,"waste":0},"check":"eden filled exactly","expected":{"addrs":[0,64,128,192,null],"limit":8,"top":256,"waste":0},"passed":false},{"actual":{"addrs":[0,128,64],"limit":16,"top":192,"waste":0},"check":"eden refill that would overrun","expected":{"addrs":[0,64,null],"limit":8,"top":128,"waste":0},"passed":false}],"passed":false,"stderr":"","stdout":"{\"observations\": [{\"check\": \"regression: refill, slow path and adaptation\", \"actual\": {\"addrs\": [0, 40, 80, 128, 144, 168, 176, 256], \"waste\": 8, \"top\": 320, \"limit\": 24}, \"expected\": {\"addrs\": [0, 40, 80, 128, 144, 168, 176, 256], \"limit\": 24, \"top\": 320, \"waste\": 8}, \"passed\": true}, {\"check\": \"allocation exactly filling the buffer\", \"actual\": {\"addrs\": [0, 64, 128, 136], \"waste\": 8, \"top\": 256, \"limit\": 17}, \"expected\": {\"addrs\": [0, 64, 120, 128], \"limit\": 17, \"top\": 256, \"waste\": 0}, \"passed\": false}, {\"check\": \"unaligned requests near the buffer end\", \"actual\": {\"addrs\": [0, 128, 64], \"waste\": 0, \"top\": 192, \"limit\": 24}, \"expected\": {\"addrs\": [0, 64, 128], \"limit\": 16, \"top\": 256, \"waste\": 0}, \"passed\": false}, {\"check\": \"remaining space exactly at the waste limit\", \"actual\": {\"addrs\": [0, 56, 128, 152], \"waste\": 16, \"top\": 256, \"limit\": 16}, \"expected\": {\"addrs\": [0, 56, 128, 152], \"limit\": 16, \"top\": 256, \"waste\": 16}, \"passed\": true}, {\"check\": \"repeated slow paths raise the limit\", \"actual\": {\"addrs\": [0, 64, 128, 168, 208, 248, 288], \"waste\": 24, \"top\": 336, \"limit\": 24}, \"expected\": {\"addrs\": [0, 64, 128, 168, 208, 248, 288], \"limit\": 24, \"top\": 336, \"waste\": 24}, \"passed\": true}, {\"check\": \"request of exactly half a buffer and just above\", \"actual\": {\"addrs\": [0, 64, 128, 72], \"waste\": 0, \"top\": 200, \"limit\": 8}, \"expected\": {\"addrs\": [0, 64, 128, 72], \"limit\": 8, \"top\": 200, \"waste\": 0}, \"passed\": true}, {\"check\": \"eden filled exactly\", \"actual\": {\"addrs\": [0, 128, 192, null, 64], \"waste\": 0, \"top\": 256, \"limit\": 32}, \"expected\": {\"addrs\": [0, 64, 128, 192, null], \"limit\": 8, \"top\": 256, \"waste\": 0}, \"passed\": false}, {\"check\": \"eden refill that would overrun\", \"actual\": {\"addrs\": [0, 128, 64], \"waste\": 0, \"top\": 192, \"limit\": 16}, \"expected\": {\"addrs\": [0, 64, null], \"limit\": 8, \"top\": 128, \"waste\": 0}, \"passed\": false}], \"passed\": false}\n"},"fixed":{"elapsed_ms":38.764,"exit_code":0,"observations":[{"actual":{"addrs":[0,40,80,128,144,168,176,256],"limit":24,"top":320,"waste":8},"check":"regression: refill, slow path and adaptation","expected":{"addrs":[0,40,80,128,144,168,176,256],"limit":24,"top":320,"waste":8},"passed":true},{"actual":{"addrs":[0,64,120,128],"limit":17,"top":256,"waste":0},"check":"allocation exactly filling the buffer","expected":{"addrs":[0,64,120,128],"limit":17,"top":256,"waste":0},"passed":true},{"actual":{"addrs":[0,64,128],"limit":16,"top":256,"waste":0},"check":"unaligned requests near the buffer end","expected":{"addrs":[0,64,128],"limit":16,"top":256,"waste":0},"passed":true},{"actual":{"addrs":[0,56,128,152],"limit":16,"top":256,"waste":16},"check":"remaining space exactly at the waste limit","expected":{"addrs":[0,56,128,152],"limit":16,"top":256,"waste":16},"passed":true},{"actual":{"addrs":[0,64,128,168,208,248,288],"limit":24,"top":336,"waste":24},"check":"repeated slow paths raise the limit","expected":{"addrs":[0,64,128,168,208,248,288],"limit":24,"top":336,"waste":24},"passed":true},{"actual":{"addrs":[0,64,128,72],"limit":8,"top":200,"waste":0},"check":"request of exactly half a buffer and just above","expected":{"addrs":[0,64,128,72],"limit":8,"top":200,"waste":0},"passed":true},{"actual":{"addrs":[0,64,128,192,null],"limit":8,"top":256,"waste":0},"check":"eden filled exactly","expected":{"addrs":[0,64,128,192,null],"limit":8,"top":256,"waste":0},"passed":true},{"actual":{"addrs":[0,64,null],"limit":8,"top":128,"waste":0},"check":"eden refill that would overrun","expected":{"addrs":[0,64,null],"limit":8,"top":128,"waste":0},"passed":true}],"passed":true,"stderr":"","stdout":"{\"observations\": [{\"check\": \"regression: refill, slow path and adaptation\", \"actual\": {\"addrs\": [0, 40, 80, 128, 144, 168, 176, 256], \"waste\": 8, \"top\": 320, \"limit\": 24}, \"expected\": {\"addrs\": [0, 40, 80, 128, 144, 168, 176, 256], \"limit\": 24, \"top\": 320, \"waste\": 8}, \"passed\": true}, {\"check\": \"allocation exactly filling the buffer\", \"actual\": {\"addrs\": [0, 64, 120, 128], \"waste\": 0, \"top\": 256, \"limit\": 17}, \"expected\": {\"addrs\": [0, 64, 120, 128], \"limit\": 17, \"top\": 256, \"waste\": 0}, \"passed\": true}, {\"check\": \"unaligned requests near the buffer end\", \"actual\": {\"addrs\": [0, 64, 128], \"waste\": 0, \"top\": 256, \"limit\": 16}, \"expected\": {\"addrs\": [0, 64, 128], \"limit\": 16, \"top\": 256, \"waste\": 0}, \"passed\": true}, {\"check\": \"remaining space exactly at the waste limit\", \"actual\": {\"addrs\": [0, 56, 128, 152], \"waste\": 16, \"top\": 256, \"limit\": 16}, \"expected\": {\"addrs\": [0, 56, 128, 152], \"limit\": 16, \"top\": 256, \"waste\": 16}, \"passed\": true}, {\"check\": \"repeated slow paths raise the limit\", \"actual\": {\"addrs\": [0, 64, 128, 168, 208, 248, 288], \"waste\": 24, \"top\": 336, \"limit\": 24}, \"expected\": {\"addrs\": [0, 64, 128, 168, 208, 248, 288], \"limit\": 24, \"top\": 336, \"waste\": 24}, \"passed\": true}, {\"check\": \"request of exactly half a buffer and just above\", \"actual\": {\"addrs\": [0, 64, 128, 72], \"waste\": 0, \"top\": 200, \"limit\": 8}, \"expected\": {\"addrs\": [0, 64, 128, 72], \"limit\": 8, \"top\": 200, \"waste\": 0}, \"passed\": true}, {\"check\": \"eden filled exactly\", \"actual\": {\"addrs\": [0, 64, 128, 192, null], \"waste\": 0, \"top\": 256, \"limit\": 8}, \"expected\": {\"addrs\": [0, 64, 128, 192, null], \"limit\": 8, \"top\": 256, \"waste\": 0}, \"passed\": true}, {\"check\": \"eden refill that would overrun\", \"actual\": {\"addrs\": [0, 64, null], \"waste\": 0, \"top\": 128, \"limit\": 8}, \"expected\": {\"addrs\": [0, 64, null], \"limit\": 8, \"top\": 128, \"waste\": 0}, \"passed\": true}], \"passed\": true}\n"}},"verified":true,"visibility":"public"}