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>
504 lines
17 KiB
Python
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())
|