{"abstract":"After a slow-path allocation the limit collapses, so a thread keeps retiring buffers too eagerly or never adapts.","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":"Resetting to the initial limit plus one increment does not accumulate.","family":"w2-garbage-collector-invariants-tlab-allocation-waste-limit-adaptation","id":"FA-90761","implementations":{"attempt":{"sha256":"7965806849fb5e20be0c2cd7a756399bb07f165c0feb334a6d896a2359a9b1bc","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_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":"9b5e14ab87bdf466620605af1028d829e17ad5ef264375a4d6e5a6452e04a2ee","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-waste-limit-adaptation","generated_at":"2026-09-29T14:51:29.738026+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":"Increase the limit by the increment on every slow-path allocation.","root_cause":"The limit is overwritten with the increment instead of being raised by it.","sha256":"c35f5ec2a8cb3d3ac336d7b27390f0997fcdcd49d46cd19b0e8908cefa23f1ea","title":"TLAB: refill waste limit reset instead of raised · case 01","variant":1,"variant_policy":"Five numbered records share a model and may reuse boundary fixtures.","verification":{"attempt":{"elapsed_ms":40.152,"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,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,104],"limit":20,"top":288,"waste":0},"check":"repeated slow paths raise the limit","expected":{"addrs":[0,64,128,168,208,248,288],"limit":24,"top":336,"waste":24},"passed":false},{"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":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, 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, 104], \"waste\": 0, \"top\": 288, \"limit\": 20}, \"expected\": {\"addrs\": [0, 64, 128, 168, 208, 248, 288], \"limit\": 24, \"top\": 336, \"waste\": 24}, \"passed\": false}, {\"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\": false}\n"},"broken":{"elapsed_ms":41.315,"exit_code":1,"observations":[{"actual":{"addrs":[0,40,80,128,144,168,176,256],"limit":8,"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":false},{"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,104],"limit":4,"top":288,"waste":0},"check":"repeated slow paths raise the limit","expected":{"addrs":[0,64,128,168,208,248,288],"limit":24,"top":336,"waste":24},"passed":false},{"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":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\": 8}, \"expected\": {\"addrs\": [0, 40, 80, 128, 144, 168, 176, 256], \"limit\": 24, \"top\": 320, \"waste\": 8}, \"passed\": false}, {\"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, 104], \"waste\": 0, \"top\": 288, \"limit\": 4}, \"expected\": {\"addrs\": [0, 64, 128, 168, 208, 248, 288], \"limit\": 24, \"top\": 336, \"waste\": 24}, \"passed\": false}, {\"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\": false}\n"},"fixed":{"elapsed_ms":41.571,"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"}