amos 2f32624d3b Batch 18 (20261026-C-hwe-codegen-18): add 100 calibrated HWE code-gen tasks; pause production for rollout
100 tasks from the HWE arm-linux code-gen pool (outside the lk/man/pth
range given to batch 22), each with at least one independent
contract-edge defect and plain public docs. Claude reviewed 100/100
USABLE against current digests; no ID or source overlap with main or
batch 22. Difficulty is unmeasured.

progress.md records the wrap-up: all Codex sessions and Qwen schedulers
stopped for the user's rollout, Qwen results so far (57 HARD of 373),
and what is left on each batch branch.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-27 17:52:13 +08:00

504 lines
17 KiB
Python

import json
from pathlib import Path
import random
import shutil
import struct
import subprocess
import sys
import tempfile
INF = 0xffffffff
FILES = ['include/bounded_channel.hpp', 'src/channel_internal.hpp', 'src/channel.cpp',
'src/transfer.cpp', 'src/waiters.cpp', 'src/observe.cpp']
def u32(value):
return struct.pack('<I', value)
def blob(value):
return u32(len(value)) + bytes(value)
class Model:
def __init__(self):
self.capacity = 1
self.data = bytearray()
self.records = {}
self.reads = self.writes = self.ticks = 0
def available(self, record):
return len(self.data) if record['direction'] == 0 else self.capacity - len(self.data)
def stop(self, record):
record['state'] = 1 if record['done'] else 3
def advance(self, record):
amount = min(record['requested'] - record['done'], self.available(record))
if record['direction'] == 0:
record['bytes'].extend(self.data[:amount])
del self.data[:amount]
self.reads += amount
else:
start = record['done']
self.data.extend(record['source'][start:start + amount])
self.writes += amount
record['done'] += amount
if record['done'] == record['requested']:
record['state'] = 1
elif record['mode'] == 1:
record['state'] = 1 if record['done'] else 2
elif record['budget'] == 0:
self.stop(record)
def settle(self):
while True:
selected = next((record for record in self.records.values()
if record['state'] == 0 and self.available(record)), None)
if selected is None:
return
self.advance(selected)
def submit(self, direction, ident, mode, budget, count, source=b''):
if not 1 <= ident <= 65535 or mode not in (0, 1) or not (budget <= 65535 or budget == INF) or count > 4096:
return 1
if ident in self.records:
return 2
if len(self.records) == 64:
return 3
record = dict(id=ident, direction=direction, mode=mode, budget=budget,
requested=count, done=0, state=0, waits=0,
source=bytes(source), bytes=bytearray())
self.records[ident] = record
if count == 0:
record['state'] = 1
return 0
self.advance(record)
self.settle()
return 0
def lookup(self, ident):
if not 1 <= ident <= 65535:
return 1
return 0 if ident in self.records else 4
def result_bytes(self, record):
return (struct.pack('<6IQI', record['id'], record['direction'], record['mode'],
record['requested'], record['done'], record['state'],
record['waits'], record['budget']) + blob(record['bytes']))
def step(self, command):
op, *args = command
extra = b''
code = 0
if op == 1:
capacity, = args
if not 1 <= capacity <= 256:
code = 1
elif any(r['state'] == 0 for r in self.records.values()):
code = 5
else:
self.__init__()
self.capacity = capacity
elif op == 2:
ident, mode, budget, source = args
code = self.submit(1, ident, mode, budget, len(source), source)
elif op == 3:
ident, mode, budget, count = args
code = self.submit(0, ident, mode, budget, count)
elif op == 4:
self.ticks += 1
self.settle()
for record in self.records.values():
if record['state'] == 0:
record['waits'] += 1
if record['budget'] != INF:
record['budget'] -= 1
if record['budget'] == 0:
self.stop(record)
self.settle()
elif op in (5, 6, 7):
ident, = args
code = self.lookup(ident)
if code == 0:
record = self.records[ident]
if op == 5:
if record['state'] != 0:
code = 6
else:
self.stop(record)
self.settle()
elif op == 6:
extra = self.result_bytes(record)
elif record['state'] == 0:
code = 5
else:
del self.records[ident]
elif op == 8:
pending = [r for r in self.records.values() if r['state'] == 0]
extra = (struct.pack('<5I3Q', self.capacity, len(self.data),
sum(r['direction'] == 0 for r in pending),
sum(r['direction'] == 1 for r in pending), len(self.records),
self.reads, self.writes, self.ticks) + blob(self.data))
return bytes([op]) + u32(code) + extra
class Script:
def __init__(self, name):
self.name = name
self.model = Model()
self.inputs = []
self.outputs = []
def add(self, op, *args):
self.outputs.append(self.model.step((op,) + args))
encoded = bytes([op])
if op == 2:
ident, mode, budget, value = args
encoded += struct.pack('<4I', ident, mode, budget, len(value)) + bytes(value)
else:
encoded += b''.join(u32(value) for value in args)
self.inputs.append(encoded)
def observe(self, *ids):
for ident in ids:
self.add(6, ident)
self.add(8)
def reset(self, capacity):
for ident, record in list(self.model.records.items()):
if record['state'] == 0:
self.add(5, ident)
self.add(1, capacity)
def build(self):
count = u32(len(self.inputs))
return self.name, b'BBC1' + count + b''.join(self.inputs), b'BBO1' + count + b''.join(self.outputs)
def make_cases():
cases = []
cases.append(Script('empty-commands'))
s = Script('W1-space-wakeup')
s.add(1, 4)
s.add(2, 10, 0, INF, b'ABCDEF')
s.add(6, 10)
s.add(3, 20, 1, INF, 2)
s.observe(20, 10)
cases.append(s)
s = Script('W2-zero-exact-boundary')
for capacity in (1, 256):
for mode in (0, 1):
for budget in (0, 1, 65535, INF):
s.reset(capacity)
s.add(3, 1, mode, budget, 0)
s.observe(1)
s.add(4)
s.observe(1)
s.add(2, 2, 1, INF, bytes(range(256))[:capacity])
s.add(2, 3, mode, budget, b'')
s.observe(1, 2, 3)
s.add(4)
s.observe(3)
s.reset(capacity)
s.add(3, 65000, 0, 1, 1)
s.add(3, 1, 0, 0, 0)
s.add(2, 2, 0, 0, b'')
s.observe(65000, 1, 2)
s.add(4)
s.observe(65000, 1, 2)
s.reset(capacity)
s.add(2, 1, 1, INF, bytes([23]) * capacity)
s.add(2, 65000, 0, 1, b'Q')
s.add(3, 2, 0, 0, 0)
s.add(2, 3, 0, 0, b'')
s.observe(65000, 2, 3)
s.add(4)
s.observe(65000, 2, 3)
cases.append(s)
s = Script('management-domains-priority-atomicity')
s.observe()
for capacity in (0, 1, 256, 257, INF):
s.add(1, capacity)
s.observe()
for ident in (0, 1, 65535, 65536, INF):
s.reset(7)
for op in (6, 5, 7):
s.add(op, ident)
s.add(2, ident, 1, INF, b'Z')
s.observe(ident)
s.add(3, ident, 0, INF, 1)
for op in (6, 5, 7, 7, 6):
s.add(op, ident)
for mode in (0, 1, 2, INF):
for budget in (0, 1, 65535, 65536, INF - 1, INF):
for count in (0, 1, 4096, 4097):
s.reset(3)
s.add(2, 1, mode, budget, bytes([0, 10, 13, 255]) * (count // 4) + bytes(count % 4))
s.observe(1)
s.reset(3)
s.add(3, 1, mode, budget, count)
s.observe(1)
s.reset(4)
s.add(3, 1, 0, INF, INF)
s.observe(1)
for ident in range(1, 65):
s.add(3, ident, 0, INF, 0)
s.add(6, ident)
s.observe(1, 64)
s.add(3, 65, 0, 0, 0)
s.add(2, 65, 1, INF, b'')
for command in ((3, 1, 0, INF, 0), (3, 1, 2, INF, 0),
(3, 1, 0, 65536, 0), (3, 1, 0, INF, 4097),
(2, 1, 0, INF, b''), (2, 1, 2, INF, b''),
(2, 1, 0, 65536, b''), (2, 1, 0, INF, bytes(4097))):
s.add(*command)
s.observe(1, 64, 65)
s.add(7, 32)
s.add(2, 65, 1, INF, b'')
s.observe(32, 65)
s.reset(4)
s.add(2, 9, 0, 2, b'abcdef')
for command in ((1, 0), (1, 257), (1, 4), (7, 9),
(3, 0, 0, INF, 1), (3, 9, 2, 65536, 4097)):
s.add(*command)
s.observe(9)
s.add(5, 9)
s.add(1, 4)
s.observe(9)
s.add(4)
s.add(1, 4)
s.observe()
s.reset(3)
for ident in range(1, 65):
s.add(3, ident, 0, INF, 1)
s.observe(1, 64)
s.add(2, 65, 1, INF, b'Z')
s.add(3, 65, 0, INF, 0)
s.observe(1, 64, 65)
s.add(5, 1)
s.add(2, 65, 1, INF, b'Z')
s.observe(1, 64, 65)
s.add(7, 1)
s.add(2, 65, 1, INF, b'Z')
s.observe(1, 2, 64, 65)
s.reset(1)
s.add(2, 1, 1, INF, b'X')
for ident in range(2, 65):
s.add(2, ident, 0, INF, b'Y')
s.add(3, 65, 1, INF, 1)
s.observe(1, 2, 64, 65)
s.add(7, 1)
s.add(3, 65, 1, INF, 1)
s.observe(1, 2, 3, 64, 65)
cases.append(s)
s = Script('prefixes-order-binary-and-lifecycle')
for capacity in (1, 3, 7, 255, 256):
for length in (1, 255, 256, 257, 4096):
s.reset(capacity)
payload = bytes((i * 37 + 10) % 256 for i in range(length))
s.add(2, 65000, 0, INF, payload)
s.observe(65000)
s.add(3, 1, 0, INF, length)
s.observe(1, 65000)
s.observe(1, 65000)
s.add(7, 1)
s.add(7, 65000)
s.observe(1, 65000)
for shift in range(3):
s.add(2, 100 + 2 * shift, 1, 0, payload[:capacity + 1])
s.add(3, 101 + 2 * shift, 1, 0, max(1, capacity - 1))
s.observe(100 + 2 * shift, 101 + 2 * shift)
s.reset(4)
s.add(3, 65000, 0, INF, 2)
s.add(3, 1, 0, INF, 2)
s.add(2, 9, 1, INF, b'ABCD')
s.observe(65000, 1, 9)
s.reset(4)
s.add(2, 9, 1, INF, b'XXXX')
s.add(2, 65000, 0, INF, b'AB')
s.add(2, 1, 0, INF, b'CD')
s.add(3, 5, 0, INF, 6)
s.observe(65000, 1, 5)
s.add(7, 65000)
s.add(2, 65000, 0, INF, b'EFGH')
s.add(3, 8, 1, INF, 4)
s.observe(1, 65000, 8)
s.reset(3)
s.add(3, 100, 0, INF, 1)
s.add(3, 200, 0, INF, 0)
s.add(3, 1, 0, INF, 1)
s.add(7, 200)
s.add(3, 65000, 0, INF, 1)
s.add(2, 3, 1, INF, b'ABC')
s.observe(100, 1, 65000, 3)
for direction in (0, 1):
for budget in (0, 1, 2, INF):
s.reset(4)
if direction == 0:
s.add(2, 100, 1, INF, b'ABC')
s.add(3, 1, 0, budget, 6)
else:
s.add(2, 1, 0, budget, b'ABCDxy')
s.observe(1)
s.add(7, 1)
s.add(4)
s.observe(1)
s.add(5, 1)
s.observe(1)
s.add(5, 1)
s.add(7, 1)
s.add(7, 1)
s.observe(1)
s.reset(4)
s.add(3, 65000, 0, INF, 6)
s.add(2, 1, 0, 0, b'ABCDEF')
s.observe(65000, 1)
s.reset(4)
s.add(2, 65000, 0, INF, b'ABCDEFGH')
s.add(3, 1, 0, 0, 6)
s.observe(65000, 1)
s.reset(4)
s.add(3, 1, 1, 0, 1)
s.add(2, 2, 1, INF, b'ABCD')
s.add(2, 3, 1, 0, b'Z')
s.add(2, 4, 0, 0, b'Z')
s.add(3, 5, 0, 1, 0)
s.observe(1, 2, 3, 4, 5)
s.add(4)
s.add(4)
s.observe(1, 2, 3, 4, 5)
for ident in (1, 2, 3, 4, 5):
s.add(5, ident)
s.add(5, ident)
s.add(7, ident)
s.add(6, ident)
s.reset(1)
s.add(3, 1, 0, 2, 1)
s.observe(1)
s.add(5, 1)
s.observe(1)
s.add(7, 1)
s.add(7, 1)
s.reset(1)
s.add(2, 1, 1, INF, b'X')
s.add(2, 2, 0, 2, b'Y')
s.observe(1, 2)
s.add(5, 2)
s.observe(1, 2)
s.add(7, 2)
s.add(7, 2)
s.reset(3)
s.add(2, 1, 1, INF, b'ABC')
s.add(7, 1)
s.observe(1)
s.add(3, 2, 1, INF, 3)
s.observe(2)
s.add(7, 2)
s.observe(2)
s.add(2, 3, 1, INF, b'DD')
s.observe(3)
cases.append(s)
s = Script('maximum-wait-budget')
s.add(3, 1, 0, 65535, 1)
s.add(3, 65535, 0, INF, 1)
s.add(3, 2, 0, 1, 0)
for _ in range(65534):
s.add(4)
s.observe(1, 65535, 2)
s.add(4)
s.observe(1, 65535, 2)
s.add(4)
s.observe(1, 65535, 2)
s.add(5, 65535)
s.observe(65535)
cases.append(s)
s = Script('seeded-combinations')
rng = random.Random(0xBBC118)
for block in range(40):
s.reset(rng.choice([1, 2, 7, 255, 256]))
for _ in range(80):
op = rng.choice([2, 2, 3, 3, 4, 5, 6, 7, 8, 1])
ident = rng.choice([0, 1, 2, 3, 4, 5, 65000, 65535, 65536, INF])
if op in (2, 3):
mode = rng.choice([0, 0, 1, 2])
budget = rng.choice([0, 1, 2, 65535, 65536, INF])
length = rng.choice([0, 1, 2, 3, 7, 8, 257])
value = bytes(rng.randrange(256) for _ in range(length)) if op == 2 else length
s.add(op, ident, mode, budget, value)
s.add(6, ident)
elif op in (5, 6, 7):
s.add(op, ident)
elif op == 1:
s.add(op, rng.choice([0, 1, 7, 256, 257]))
else:
s.add(op)
s.add(8)
cases.append(s)
s = Script('maximum-wire-volume')
s.add(1, 256)
payload = bytes(range(256)) * 16
for ident in range(1, 4097):
s.add(2, ident, 1, INF, payload)
for _ in range(131072 - len(s.inputs) - 65):
s.add(4)
s.observe(*range(1, 65))
cases.append(s)
return [s.build() for s in cases]
def main():
compiler = shutil.which('c++')
if compiler is None:
print('missing C++17 compiler', file=sys.stderr)
print('FAIL unavailable compiler')
return 2
candidate = Path(sys.argv[1])
sources = {name: (candidate / name).read_bytes() for name in FILES}
observer = Path(__file__).with_name('raw_observer.cpp').read_bytes()
plans = make_cases()
scratch = Path(tempfile.mkdtemp(prefix='bounded-byte-', dir=Path.cwd()))
for name, content in sources.items():
destination = scratch / name
destination.parent.mkdir(parents=True, exist_ok=True)
destination.write_bytes(content)
(scratch / 'raw_observer.cpp').write_bytes(observer)
executable = str(scratch / 'channel-observe')
argv = [compiler, '-std=c++17', '-O2', '-I', str(scratch / 'include')]
argv += [str(scratch / name) for name in FILES if name.endswith('.cpp')]
argv += [str(scratch / 'raw_observer.cpp'), '-o', executable]
# All trusted reads/writes and expected data preparation end before this compiler.
built = subprocess.run(argv, cwd=str(scratch), capture_output=True, timeout=30)
print('BUILD exit=' + str(built.returncode), file=sys.stderr)
if built.returncode:
print(built.stderr.decode('utf-8', 'replace')[-1500:], file=sys.stderr)
print('FAIL build')
return 1
failures = []
for name, incoming, expected in plans:
try:
actual = subprocess.run([executable], cwd=str(scratch), input=incoming,
capture_output=True, timeout=5)
except subprocess.TimeoutExpired:
failures.append(name + ':timeout')
print('RUN case=' + name + ' timeout', file=sys.stderr)
continue
reason = 'ok'
if actual.returncode:
reason = 'exit_nonzero:' + str(actual.returncode)
elif actual.stderr:
reason = 'stderr_nonempty:' + str(len(actual.stderr))
elif actual.stdout != expected:
if actual.stdout.startswith(expected):
reason = 'stdout_extra_bytes:' + str(len(actual.stdout) - len(expected))
else:
offset = next((i for i, pair in enumerate(zip(actual.stdout, expected)) if pair[0] != pair[1]), min(len(actual.stdout), len(expected)))
reason = 'stdout_mismatch_at:' + str(offset)
print('RUN case={} exit={} stdin={} stdout={} expected={} stderr={} stdout_equal={} {}'.format(
name, actual.returncode, len(incoming), len(actual.stdout), len(expected), len(actual.stderr),
int(actual.stdout == expected), reason), file=sys.stderr)
if reason != 'ok':
failures.append(name + ':' + reason)
if failures:
print('FAIL ' + ';'.join(failures[:4]))
return 1
print('PASS')
return 0
if __name__ == '__main__':
sys.exit(main())