amos 9d633e9e67 Batch 15 (20261023-C-hwe-scale-15): 320 HWE-derived repair tasks
One user-space repair task per eligible HWE debug-diag / compile-deploy base
ID: 320 admitted (C 218, C++ 97, build scripts 5), 1 skipped by the content
filter. Each ships a public spec with a check-to-basis table, at least two
defects with single-fix fixtures, a symptom-masking fixture and an alternative
correct implementation. Claude re-checked all 320: structure, the HWE quality
items and trace6 Docker calibration receipts against current digests
(320/320 USABLE). Difficulty is unmeasured. Known follow-up: 212 tasks use 120
ad-hoc family names; the next batch maps them to the canonical list.
The batch's 1,256-line progress log stays in its factory report and the
36-local branch batch15-hwe.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-27 01:55:56 +08:00

874 lines
37 KiB
Python

import base64
import hashlib
import json
import math
import os
from pathlib import Path
import random
import re
import secrets
import shutil
import stat
import subprocess
import sys
import tempfile
import time
import zlib
CANDIDATES = ["include/request.hpp", "src/request.cpp", "src/text.cpp",
"src/format.cpp", "src/console.cpp"]
HARNESS = '#include "request.hpp"\n\n#include <cerrno>\n#include <cstdint>\n#include <iostream>\n#include <sstream>\n#include <string>\n#include <vector>\n\nnamespace {\n\nstruct Event {\n char kind;\n std::int64_t first;\n std::int64_t second;\n};\n\nclass ScriptedPort final : public remaining::WaitPort {\npublic:\n void push(Event event) { events_.push_back(event); }\n\n int wait(const remaining::Time &requested, remaining::Time &left, int &error) override\n {\n Event event{\'F\', EAGAIN, 0};\n if (cursor_ < events_.size()) {\n event = events_[cursor_++];\n }\n int result = -1;\n if (event.kind == \'S\') {\n result = 0;\n error = 0;\n } else if (event.kind == \'I\') {\n error = EINTR;\n left = remaining::to_time(static_cast<std::uint64_t>(event.first));\n } else if (event.kind == \'X\') {\n error = EINTR;\n left = {event.first, event.second};\n } else {\n error = static_cast<int>(event.first);\n left = {-7, -7};\n }\n std::cout << "W " << requested.sec << \' \' << requested.nsec << \' \'\n << result << \' \' << error << \'\\n\';\n return result;\n }\n\nprivate:\n std::vector<Event> events_;\n std::size_t cursor_ = 0;\n};\n\nbool event_line(const std::string &line, Event &event)\n{\n std::istringstream input(line);\n std::string prefix;\n std::string extra;\n if (!(input >> prefix) || prefix != "E" || !(input >> event.kind)) return false;\n if (event.kind == \'S\') return !(input >> extra);\n if (event.kind == \'I\' || event.kind == \'F\') {\n return bool(input >> event.first) && !(input >> extra);\n }\n if (event.kind == \'X\') {\n return bool(input >> event.first >> event.second) && !(input >> extra);\n }\n return false;\n}\n\n} // namespace\n\nint main()\n{\n ScriptedPort port;\n remaining::Manager manager(port);\n remaining::Console console(manager);\n std::string line;\n while (std::getline(std::cin, line)) {\n if (line.size() >= 2 && line[0] == \'E\' && line[1] == \' \') {\n Event event{};\n if (!event_line(line, event)) return 2;\n port.push(event);\n continue;\n }\n std::string output;\n if (!console.execute(line, output)) return 2;\n if (!output.empty()) std::cout << "O " << output << \'\\n\';\n }\n return std::cin.bad() ? 2 : 0;\n}\n'
IMAGE_DEADLINE = 12.0
CASE_DEADLINE = 3.0
STAGE_GRACE = 3.0
ISOLATED = os.environ.get('ROLLOUT_GRADE_ISOLATION') == 'uid65534'
EXPECTED_UID = 65534 if ISOLATED else os.getuid()
EXPECTED_GID = 65534 if ISOLATED else os.getgid()
EXPECTED_GROUPS = [] if ISOLATED else os.getgroups()
STAGE_RECORDS = []
SUPERVISOR = r'''
import base64, ctypes, hashlib, json, os, selectors, signal, subprocess, sys, time
def exact_stat(pid):
try:
raw = open('/proc/%d/stat' % pid, 'rb').read()
except (FileNotFoundError, ProcessLookupError):
return None
fields = raw[raw.rfind(b')') + 2:].split()
return (fields[0].decode('ascii'), int(fields[1]), int(fields[2]),
int(fields[3]), int(fields[19]))
def scan(problems):
table = {}
for name in os.listdir('/proc'):
if not name.isdecimal():
continue
pid = int(name)
try:
record = exact_stat(pid)
except Exception as error:
entry = 'scan:%d:%s' % (pid, type(error).__name__)
if entry not in problems:
problems.append(entry)
continue
if record is not None:
table[pid] = record
return table
def live(record):
return record is not None and record[0] not in ('Z', 'X')
def descendants(table, self_pid, known):
roots = {self_pid}
for pid, token in known.items():
record = table.get(pid)
if live(record) and record[4] == token:
roots.add(pid)
found = {}
changed = True
while changed:
changed = False
for pid, record in table.items():
if pid == self_pid or not live(record) or pid in found:
continue
if record[1] in roots:
found[pid] = record[4]
roots.add(pid)
changed = True
return found
def signal_owned(found, problems):
for pid, start in found.items():
try:
fresh = exact_stat(pid)
if not live(fresh) or fresh[4] != start:
continue
os.kill(pid, signal.SIGKILL)
except (FileNotFoundError, ProcessLookupError):
continue
except Exception as error:
problems.append('signal:%d:%s' % (pid, type(error).__name__))
def main():
request_bytes = sys.stdin.buffer.read()
plan = json.loads(request_bytes)
deadline = float(plan['deadline'])
started = time.monotonic()
self_pid = os.getpid()
self_record = exact_stat(self_pid)
problems = []
reaped = []
known = {}
output = {1: bytearray(), 2: bytearray()}
leader = None
leader_start = None
leader_pgid = None
leader_rc = None
timed_out = False
try:
if ctypes.CDLL(None).prctl(36, 1, 0, 0, 0) != 0:
raise OSError('prctl subreaper failed')
input_data = base64.b64decode(plan['stdin_b64'], validate=True)
leader = subprocess.Popen(plan['argv'], cwd=plan['cwd'],
stdin=subprocess.PIPE, stdout=subprocess.PIPE,
stderr=subprocess.PIPE, start_new_session=True)
leader_record = exact_stat(leader.pid)
if leader_record is None:
raise RuntimeError('leader disappeared before start identity capture')
leader_start = leader_record[4]
leader_pgid = leader_record[2]
known[leader.pid] = leader_start
watch = selectors.DefaultSelector()
for number, stream in ((1, leader.stdout), (2, leader.stderr)):
os.set_blocking(stream.fileno(), False)
watch.register(stream, selectors.EVENT_READ, number)
os.set_blocking(leader.stdin.fileno(), False)
if input_data:
watch.register(leader.stdin, selectors.EVENT_WRITE, 0)
else:
leader.stdin.close()
offset = 0
while True:
own = leader.poll()
if own is not None:
leader_rc = own
table = scan(problems)
current = descendants(table, self_pid, known)
known.update(current)
if time.monotonic() - started >= deadline:
timed_out = True
break
if leader_rc is not None and not current and not watch.get_map():
break
if leader_rc is not None and current:
signal_owned(current, problems)
for key, mask in watch.select(0.025):
stream = key.fileobj
if key.data == 0:
try:
count = os.write(stream.fileno(), input_data[offset:offset + 65536])
except BrokenPipeError:
count = 0
offset = len(input_data)
except BlockingIOError:
continue
offset += count
if offset >= len(input_data):
watch.unregister(stream)
stream.close()
else:
try:
data = os.read(stream.fileno(), 65536)
except BlockingIOError:
continue
if data:
output[key.data].extend(data)
else:
watch.unregister(stream)
stream.close()
if leader_rc is not None:
for pid in list(known):
if pid == leader.pid:
continue
try:
result, status = os.waitpid(pid, os.WNOHANG)
if result:
reaped.append([pid, status])
except (ChildProcessError, ProcessLookupError):
pass
watch.close()
except Exception as error:
problems.append('supervisor:%s:%s' % (type(error).__name__, str(error)[:120]))
finally:
if leader is not None:
until = time.monotonic() + 2.0
while time.monotonic() < until:
leader_rc = leader.poll() if leader_rc is None else leader_rc
try:
table = scan(problems)
current = descendants(table, self_pid, known)
known.update(current)
signal_owned(current, problems)
if leader_rc is not None and not current:
break
for pid in list(known):
if pid == leader.pid:
continue
try:
result, status = os.waitpid(pid, os.WNOHANG)
if result:
reaped.append([pid, status])
except (ChildProcessError, ProcessLookupError):
pass
except Exception as error:
problems.append('recovery:%s' % type(error).__name__)
time.sleep(0.02)
leader_rc = leader.poll() if leader_rc is None else leader_rc
if leader_rc is None:
problems.append('leader-not-reaped')
try:
table = scan(problems)
current = descendants(table, self_pid, known)
absence = not current
try:
os.killpg(leader_pgid, 0)
pg_absence = False
except ProcessLookupError:
pg_absence = True
except Exception as error:
problems.append('pg-absence:%s' % type(error).__name__)
pg_absence = False
except Exception as error:
problems.append('absence:%s' % type(error).__name__)
absence = False
pg_absence = False
else:
absence = False
pg_absence = False
for number, stream in ((1, leader.stdout if leader else None),
(2, leader.stderr if leader else None)):
if stream is None:
continue
try:
while True:
data = os.read(stream.fileno(), 65536)
if not data:
break
output[number].extend(data)
except (OSError, ValueError):
pass
try:
stream.close()
except Exception:
pass
stdout = bytes(output[1]); stderr = bytes(output[2])
wire = dict(version=1, nonce=plan['nonce'], cwd=plan['cwd'],
request_len=len(request_bytes),
request_sha256=hashlib.sha256(request_bytes).hexdigest(),
input_len=len(input_data) if 'input_data' in locals() else None,
input_sha256=hashlib.sha256(input_data).hexdigest() if 'input_data' in locals() else None,
supervisor_pid=self_pid, supervisor_start=self_record[4],
leader_pid=leader.pid if leader else None, leader_start=leader_start,
leader_pgid=leader_pgid,
uid=os.getuid(), gid=os.getgid(), groups=os.getgroups(),
argv=plan['argv'], deadline=deadline,
elapsed=time.monotonic() - started, leader_rc=leader_rc,
returncode=leader_rc, leader_reaped=leader_rc is not None,
timed_out=timed_out, descendants_absent=absence, pg_absent=pg_absence,
exceptions=problems, reaped=reaped,
stdout_b64=base64.b64encode(stdout).decode('ascii'),
stderr_b64=base64.b64encode(stderr).decode('ascii'),
stdout_len=len(stdout), stderr_len=len(stderr),
stdout_sha256=hashlib.sha256(stdout).hexdigest(),
stderr_sha256=hashlib.sha256(stderr).hexdigest())
sys.stdout.write(json.dumps(wire, separators=(',', ':')))
main()
'''
ABSENCE = r'''import os,sys
try:
os.lstat(sys.argv[1])
except FileNotFoundError:
raise SystemExit(0)
raise SystemExit(1)
'''
def sha(data):
return hashlib.sha256(data).hexdigest()
def prepare(candidate, scratch):
for name in CANDIDATES:
root_fd = os.open(candidate, os.O_RDONLY | os.O_DIRECTORY | os.O_NOFOLLOW)
folder_fd = os.dup(root_fd)
try:
for part in Path(name).parts[:-1]:
next_fd = os.open(part, os.O_RDONLY | os.O_DIRECTORY | os.O_NOFOLLOW,
dir_fd=folder_fd)
os.close(folder_fd)
folder_fd = next_fd
file_fd = os.open(Path(name).name, os.O_RDONLY | os.O_NOFOLLOW | os.O_NONBLOCK,
dir_fd=folder_fd)
try:
info = os.fstat(file_fd)
if not stat.S_ISREG(info.st_mode) or info.st_size > 1024 * 1024:
raise ValueError('candidate is not a regular bounded file')
with os.fdopen(file_fd, 'rb', closefd=False) as stream:
data = stream.read(1024 * 1024 + 1)
if len(data) != info.st_size:
raise ValueError('candidate changed during copy')
finally:
os.close(file_fd)
target = scratch / name
target.parent.mkdir(parents=True, exist_ok=True)
target.write_bytes(data)
if ISOLATED:
os.chown(target, 65534, 65534)
finally:
os.close(folder_fd)
os.close(root_fd)
driver = scratch / 'driver.cpp'
driver.write_text(HARNESS)
if ISOLATED:
os.chown(driver, 65534, 65534)
for folder in (scratch / 'src', scratch / 'include'):
os.chown(folder, 65534, 65534)
def valid_wire(meta, argv, deadline, nonce, cwd, input_data, request_bytes):
def integer(value, positive=False):
return type(value) is int and (not positive or value > 0)
if type(meta) is not dict or type(meta.get('version')) is not int or meta['version'] != 1:
return False, 'wire-version'
if type(meta.get('nonce')) is not str or meta['nonce'] != nonce:
return False, 'nonce'
if type(meta.get('cwd')) is not str or meta['cwd'] != cwd:
return False, 'cwd'
if type(meta.get('request_len')) is not int or meta['request_len'] != len(request_bytes):
return False, 'request-len'
if type(meta.get('request_sha256')) is not str or meta['request_sha256'] != sha(request_bytes):
return False, 'request-digest'
if type(meta.get('input_len')) is not int or meta['input_len'] != len(input_data):
return False, 'input-len'
if type(meta.get('input_sha256')) is not str or meta['input_sha256'] != sha(input_data):
return False, 'input-digest'
for field in ('supervisor_pid', 'supervisor_start', 'leader_pid', 'leader_start', 'leader_pgid'):
if not integer(meta.get(field), True):
return False, field
if meta['supervisor_pid'] == meta['leader_pid']:
return False, 'pid-alias'
if meta['leader_pgid'] != meta['leader_pid']:
return False, 'leader-pgid'
for field in ('uid', 'gid'):
expected = EXPECTED_UID if field == 'uid' else EXPECTED_GID
if not integer(meta.get(field)) or meta[field] != expected:
return False, field
if (type(meta.get('groups')) is not list or
any(type(x) is not int for x in meta['groups']) or meta['groups'] != EXPECTED_GROUPS):
return False, 'groups'
if meta.get('argv') != argv or type(meta.get('argv')) is not list:
return False, 'argv'
elapsed = meta.get('elapsed')
if type(elapsed) not in (int, float) or not math.isfinite(elapsed) or not 0 <= elapsed <= deadline + STAGE_GRACE:
return False, 'elapsed'
if type(meta.get('deadline')) not in (int, float) or meta['deadline'] != deadline:
return False, 'deadline'
if type(meta.get('timed_out')) is not bool or type(meta.get('leader_reaped')) is not bool:
return False, 'timeout-reap'
if type(meta.get('descendants_absent')) is not bool or type(meta.get('pg_absent')) is not bool:
return False, 'absence-types'
if type(meta.get('exceptions')) is not list or any(type(x) is not str for x in meta['exceptions']):
return False, 'exceptions'
if type(meta.get('reaped')) is not list:
return False, 'reaped'
if any(type(item) is not list or len(item) != 2 or
not integer(item[0], True) or not integer(item[1])
for item in meta['reaped']):
return False, 'reaped-items'
for field in ('leader_rc', 'returncode'):
if not integer(meta.get(field)):
return False, field
if meta['returncode'] != meta['leader_rc'] or not meta['leader_reaped']:
return False, 'leader-consistency'
for stream in ('stdout', 'stderr'):
size = meta.get(stream + '_len')
if not integer(size) or size < 0:
return False, stream + '-len'
try:
data = base64.b64decode(meta[stream + '_b64'], validate=True)
except Exception:
return False, stream + '-bytes'
if len(data) != size or sha(data) != meta.get(stream + '_sha256'):
return False, stream + '-digest'
if (meta['timed_out'] or not meta['descendants_absent'] or
not meta['pg_absent'] or meta['exceptions']):
return False, 'stage-presence-timeout-exception'
return True, ''
def stage(argv, cwd, data, deadline):
nonce = secrets.token_hex(16)
plan = dict(argv=argv, cwd=str(cwd), stdin_b64=base64.b64encode(data).decode('ascii'),
deadline=deadline, nonce=nonce)
request_bytes = json.dumps(plan, sort_keys=True, separators=(',', ':')).encode()
wrapper = subprocess.run([sys.executable, '-I', '-c', SUPERVISOR],
input=request_bytes, capture_output=True,
timeout=deadline + STAGE_GRACE + 3)
raw = wrapper.stdout
evidence = dict(wrapper_rc=wrapper.returncode, wire_len=len(raw), wire_sha256=sha(raw),
wrapper_stderr_len=len(wrapper.stderr), wrapper_stderr_sha256=sha(wrapper.stderr),
argv=argv, deadline=deadline,
request_len=len(request_bytes), request_sha256=sha(request_bytes))
def note(reason, meta=None):
entry = dict(argv=argv, role=argv[0], reason=reason or 'ok', wrapper_rc=evidence['wrapper_rc'],
wire_len=evidence['wire_len'], wire_sha256=evidence['wire_sha256'],
request_len=evidence['request_len'],
request_sha256=evidence['request_sha256'],
wrapper_stderr_len=evidence['wrapper_stderr_len'],
nonce=nonce, cwd=str(cwd), input_len=len(data), input_sha256=sha(data),
deadline=deadline)
if evidence['wrapper_stderr_len']:
entry['wrapper_stderr_sha256'] = evidence['wrapper_stderr_sha256']
if meta is not None:
entry['meta'] = {key: meta.get(key) for key in
('nonce', 'cwd', 'request_len', 'request_sha256',
'input_len', 'input_sha256',
'supervisor_pid', 'supervisor_start', 'leader_pid',
'leader_start', 'leader_pgid', 'uid', 'gid', 'groups',
'elapsed', 'leader_rc', 'returncode', 'leader_reaped',
'timed_out', 'descendants_absent', 'pg_absent',
'exceptions', 'reaped', 'stdout_len', 'stderr_len',
'stdout_sha256', 'stderr_sha256')}
STAGE_RECORDS.append(entry)
if wrapper.returncode != 0:
note('wrapper-exit')
return None, evidence, 'wrapper-exit'
try:
meta = json.loads(raw)
except (UnicodeError, json.JSONDecodeError):
note('wire-json')
return None, evidence, 'wire-json'
okay, reason = valid_wire(meta, argv, deadline, nonce, str(cwd), data, request_bytes)
note(reason, meta if type(meta) is dict else None)
selected = meta if type(meta) is dict else {}
evidence['meta'] = {key: selected.get(key) for key in
('nonce', 'cwd', 'request_len', 'request_sha256',
'input_len', 'input_sha256',
'supervisor_pid', 'supervisor_start', 'leader_pid', 'leader_start',
'leader_pgid', 'pg_absent',
'uid', 'gid', 'groups', 'elapsed', 'leader_rc', 'returncode',
'leader_reaped', 'timed_out', 'descendants_absent', 'exceptions',
'stdout_len', 'stderr_len', 'stdout_sha256', 'stderr_sha256')}
if not okay:
return None, evidence, reason
meta['stdout'] = base64.b64decode(meta['stdout_b64'], validate=True)
meta['stderr'] = base64.b64decode(meta['stderr_b64'], validate=True)
return meta, evidence, ''
def integer_token(raw):
if not re.fullmatch(r'[+-]?[0-9]+', raw, re.ASCII):
raise ValueError('non-decimal token')
sign = -1 if raw.startswith('-') else 1
digits = raw.lstrip('+-').lstrip('0') or '0'
if len(digits) > 20:
raise ValueError('number exceeds observable range')
return sign * int(digits)
def normalize(stdout):
if not stdout.endswith(b'\n'):
raise ValueError('missing final newline')
lines = stdout.decode('ascii').split('\n')[:-1]
result = []
for line in lines:
words = re.split(r'[ \t\r]+', line.strip(' \t\r'))
if not words or words[0] not in ('W', 'O'):
raise ValueError('raw line prefix')
result.append([integer_token(word) if re.fullmatch(r'[+-]?[0-9]+', word, re.ASCII)
else word for word in words])
return result
def render_expected(lines):
return normalize(('\n'.join(lines) + '\n').encode())
class Model:
def __init__(self):
self.rows = []
self.serial = 0
self.consumed = 0
self.calls = 0
self.events = []
self.output = []
self.input = []
def row(self, ident):
return next((item for item in self.rows if item['id'] == ident), None)
def emit(self, value):
self.output.append('O ' + value)
def event(self, kind, first=0, second=0):
if kind == 'S':
self.input.append('E S')
elif kind in ('I', 'F'):
self.input.append(f'E {kind} {first}')
else:
self.input.append(f'E X {first} {second}')
self.events.append((kind, first, second))
def add(self, ident, duration, priority, display=None):
self.input.append(f'A {ident} {display or duration} {priority}')
if not 1 <= ident <= 9999 or not 1 <= duration <= 10**12 or not 0 <= priority <= 3:
rc = -22
elif self.row(ident):
rc = -17
elif len(self.rows) == 16:
rc = -28
else:
rc = 0
self.rows.append(dict(id=ident, state=0, priority=priority, original=duration,
remaining=duration, consumed=0, attempts=0, interrupts=0,
error=0, serial=self.serial))
self.serial += 1
self.emit(f'A {rc}')
return rc
def amend(self, ident, duration, priority, display=None):
self.input.append(f'M {ident} {display or duration} {priority}')
row = self.row(ident)
if row is None:
rc = -2
elif row['state'] != 0:
rc = -114
elif not 1 <= duration <= 10**12 or not 0 <= priority <= 3:
rc = -22
else:
rc = 0
row.update(original=duration, remaining=duration, priority=priority)
self.emit(f'M {rc}')
def duplicate(self, ident, new_id):
self.input.append(f'D {ident} {new_id}')
row = self.row(ident)
if row is None:
rc = -2
elif row['state'] != 0:
rc = -114
elif not 1 <= new_id <= 9999:
rc = -22
elif self.row(new_id):
rc = -17
elif len(self.rows) == 16:
rc = -28
else:
rc = 0
self.rows.append(dict(id=new_id, state=0, priority=row['priority'],
original=row['remaining'], remaining=row['remaining'],
consumed=0, attempts=0, interrupts=0, error=0,
serial=self.serial))
self.serial += 1
self.emit(f'D {rc}')
def priority(self, ident, priority):
self.input.append(f'T {ident} {priority}')
row = self.row(ident)
rc = -2 if row is None else -114 if row['state'] != 0 else -22 if not 0 <= priority <= 3 else 0
if rc == 0:
row['priority'] = priority
self.emit(f'T {rc}')
def cancel(self, ident):
self.input.append(f'C {ident}')
row = self.row(ident)
rc = -2 if row is None else -114 if row['state'] != 0 else 0
if rc == 0:
row['state'] = 3
self.emit(f'C {rc}')
def wait(self, row):
while row['remaining']:
asked = row['remaining']
event = self.events.pop(0) if self.events else ('F', 11, 0)
kind, first, second = event
sec, nsec = divmod(asked, 10**9)
rc = 0 if kind == 'S' else -1
error = 0 if kind == 'S' else 4 if kind in ('I', 'X') else first
self.output.append(f'W {sec} {nsec} {rc} {error}')
self.calls += 1
row['attempts'] += 1
if kind == 'S':
row['consumed'] += asked
self.consumed += asked
row.update(state=1, remaining=0, error=0)
return 0
if kind == 'F':
row.update(state=2, error=error)
return -error
if kind == 'I':
left = first
valid = 0 <= left <= asked
else:
valid = first >= 0 and 0 <= second < 10**9
left = first * 10**9 + second if valid else -1
valid = valid and left <= asked
if not valid:
row.update(state=2, error=71)
return -71
delta = asked - left
row['consumed'] += delta
self.consumed += delta
row['remaining'] = left
row['interrupts'] += 1
if left == 0:
row.update(state=1, error=0)
return 0
if row['interrupts'] >= 32:
row.update(state=2, error=40)
return -40
row.update(state=1, error=0)
return 0
def run(self, ident):
self.input.append(f'R {ident}')
row = self.row(ident)
rc = -2 if row is None else -114 if row['state'] != 0 else self.wait(row)
self.emit(f'R {rc}')
def order(self):
return sorted((row for row in self.rows if row['state'] == 0),
key=lambda row: (-row['priority'], row['serial']))
def next(self):
self.input.append('N')
order = self.order()
if order:
ident = order[0]['id']
rc = self.wait(order[0])
else:
ident = -1
rc = -2
self.emit(f'N {ident} {rc}')
def batch(self):
self.input.append('B')
count = 0
rc = 0
while self.order():
rc = self.wait(self.order()[0])
count += 1
if rc:
break
self.emit(f'B {count} {rc}')
@staticmethod
def fields(row):
return ' '.join(str(row[key]) for key in
('id', 'state', 'priority', 'original', 'remaining', 'consumed',
'attempts', 'interrupts', 'error'))
def query(self, ident):
self.input.append(f'Q {ident}')
row = self.row(ident)
self.emit('Q -2' if row is None else 'Q 0 ' + self.fields(row))
def list(self):
self.input.append('L')
self.emit('L ' + str(len(self.rows)) + ''.join(' | ' + self.fields(row) for row in self.rows))
def ordered(self):
self.input.append('O')
rows = self.order()
self.emit('O ' + str(len(rows)) + ''.join(' ' + str(row['id']) for row in rows))
def totals(self):
self.input.append('S')
counts = [sum(row['state'] == state for row in self.rows) for state in range(4)]
self.emit('S ' + ' '.join(map(str, counts + [self.consumed, self.calls])))
def purge(self):
self.input.append('P')
count = sum(row['state'] != 0 for row in self.rows)
self.rows = [row for row in self.rows if row['state'] == 0]
self.emit(f'P {count}')
def reset(self):
self.input.append('Z')
self.rows = []
self.serial = 0
self.consumed = 0
self.calls = 0
self.emit('Z 0')
def scenarios():
cases = []
m = Model()
m.event('I', 4000000); m.event('S')
m.add(7, 10000000, 1, '10ms'); m.run(7); m.query(7); m.totals()
cases.append(('public-interrupt', m))
m = Model()
m.event('I', 1000000001); m.event('I', 250000001); m.event('S')
m.add(181, 2400000003, 2); m.run(181); m.query(181); m.totals()
cases.append(('multi-second-interrupt', m))
m = Model()
m.event('F', 5)
m.add(512, 9000000, 0, '9ms'); m.run(512); m.query(512); m.totals()
m.run(512); m.ordered()
cases.append(('hard-error', m))
m = Model()
m.event('I', 3); m.event('F', 11)
m.add(8, 9, 0); m.run(8); m.query(8); m.totals()
cases.append(('interrupted-then-error', m))
m = Model()
m.event('I', 0)
m.add(41, 1000000000, 3, '1s'); m.run(41); m.query(41)
m.event('X', -1, 1)
m.add(42, 7000, 1, '7us'); m.run(42); m.query(42)
m.totals()
cases.append(('zero-and-invalid-remain', m))
m = Model()
m.add(100, 1000, 1, '1us'); m.add(200, 2000000, 3, '2ms')
m.add(300, 400, 3); m.ordered(); m.priority(100, 3); m.ordered()
m.event('S'); m.event('F', 5)
m.batch(); m.query(100); m.ordered(); m.event('S'); m.next(); m.list(); m.totals()
cases.append(('queue-error-stop', m))
m = Model()
m.add(23, 17, 0); m.amend(23, 5000000, 3, '5ms'); m.duplicate(23, 24)
m.cancel(23); m.query(23); m.ordered(); m.event('S'); m.batch(); m.list()
m.purge(); m.add(23, 40, 2); m.event('S'); m.run(23); m.totals(); m.reset(); m.totals()
cases.append(('lifecycle', m))
m = Model()
for ident in range(1, 17):
m.add(ident, ident * 100, ident % 4)
m.add(17, 9, 0); m.add(1, 8, 0); m.ordered(); m.cancel(4)
m.amend(3, 0, 0); m.query(3); m.purge(); m.add(17, 9, 0)
m.totals(); m.list()
cases.append(('capacity-and-parse', m))
m = Model()
rng = random.Random(370137)
for index in range(10):
duration = rng.randint(1, 10**11)
ident = rng.randint(5000, 9000)
m.add(ident, duration, index % 4)
left = rng.randint(0, duration)
m.event('I', left)
if left:
m.event('S')
m.run(ident)
m.query(ident)
m.totals(); m.list()
cases.append(('seeded-variants', m))
m = Model()
m.add(777, 1, 2, '+' + '0' * 5000 + '1ns')
for unused in range(32):
m.event('I', 1)
m.run(777); m.query(777); m.totals()
m.event('X', 0, 5); m.event('S')
m.add(778, 5, 0); m.run(778); m.query(778)
m.event('S')
m.add(779, 99, 0); m.next(); m.query(779)
cases.append(('leading-zero-and-interrupt-bound', m))
return cases
def assess(candidate):
issues = []
rows = 0
scratch = Path(tempfile.mkdtemp(prefix='cc-rm-037-'))
try:
prepare(candidate, scratch)
argv = ['g++', '-std=c++17', '-O2', '-Wall', '-Wextra', '-Wpedantic',
'-Iinclude', 'driver.cpp', 'src/request.cpp', 'src/text.cpp',
'src/format.cpp', 'src/console.cpp', '-o', 'app']
compiled, evidence, reason = stage(argv, scratch, b'', IMAGE_DEADLINE)
if reason:
issues.append('compile-stage:' + reason)
elif compiled['returncode'] != 0:
issues.append('compile-rc:' + str(compiled['returncode']))
issues.append('compile-stderr:' + compiled['stderr'].decode('utf-8', 'replace')[-300:])
if not issues:
cases = scenarios()
for offset in range(0, len(cases), 2):
group = cases[offset:offset + 2]
label = '+'.join(item[0] for item in group)
commands = []
observations = []
for index, (_, model) in enumerate(group):
if index:
commands.append('Z')
observations.append('O Z 0')
commands.extend(model.input)
observations.extend(model.output)
data = ('\n'.join(commands) + '\n').encode('ascii')
expected = render_expected(observations)
rows += len(expected)
executed, evidence, reason = stage(['./app'], scratch, data, CASE_DEADLINE)
if reason:
issues.append(label + ':stage:' + reason)
continue
if executed['returncode'] != 0:
issues.append(label + ':candidate-rc:' + str(executed['returncode']))
continue
try:
actual = normalize(executed['stdout'])
except (UnicodeError, ValueError) as error:
issues.append(label + ':stdout:' + str(error))
continue
if actual != expected:
position = next((index for index, pair in enumerate(zip(actual, expected))
if pair[0] != pair[1]), min(len(actual), len(expected)))
observed = actual[position] if position < len(actual) else '<missing>'
wanted = expected[position] if position < len(expected) else '<missing>'
issues.append(label + ':observation:' + str(position) + ':' + str(observed) + '!=' + str(wanted))
except Exception as error:
issues.append('check-exception:' + type(error).__name__ + ':' + str(error)[:100])
finally:
try:
cleanup, evidence, reason = stage(['rm', '-rf', '--', str(scratch)], scratch.parent,
b'', CASE_DEADLINE)
if reason or cleanup is None or cleanup['returncode'] != 0:
issues.append('cleanup:' + (reason or str(cleanup['returncode'])))
except Exception as error:
issues.append('cleanup-exception:' + type(error).__name__)
try:
absent, evidence, reason = stage([sys.executable, '-I', '-c', ABSENCE, str(scratch)],
scratch.parent, b'', CASE_DEADLINE)
if reason or absent is None or absent['returncode'] != 0:
issues.append('absence:' + (reason or str(absent['returncode'])))
except Exception as error:
issues.append('absence-exception:' + type(error).__name__)
return issues, rows
def main():
if len(sys.argv) != 2:
print('candidate argument required')
return 1
issues, rows = assess(Path(sys.argv[1]))
binary = bytearray()
def compact(value, field=''):
if type(value) is dict:
return {key: compact(item, key) for key, item in value.items()}
if type(value) is list:
return [compact(item, field) for item in value]
if (type(value) is str and (field.endswith('_sha256') or field == 'nonce') and
re.fullmatch(r'[0-9a-f]+', value, re.ASCII) and len(value) in (32, 64)):
position = len(binary)
binary.extend(bytes.fromhex(value))
return {'$': [position, len(value) // 2]}
return value
head = json.dumps(compact(STAGE_RECORDS), separators=(',', ':')).encode()
payload = len(head).to_bytes(4, 'big') + head + binary
encoded = base64.b64encode(zlib.compress(payload, 9))
print('STAGES_ZLIB64=' + encoded.decode('ascii'), file=sys.stderr)
print('stage_encoded_len=' + str(len(encoded)), file=sys.stderr)
print('observation_rows=' + str(rows), file=sys.stderr)
if issues:
for issue in issues[:2]:
print(issue, file=sys.stderr)
print('FAIL')
return 1
print('PASS')
return 0
if __name__ == '__main__':
raise SystemExit(main())