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

379 lines
18 KiB
Python

"""Independent logical-resource oracle; candidate execution is subprocess-only."""
import collections
import hashlib
import json
import random
import subprocess
import sys
import tempfile
from pathlib import Path
U64 = (1 << 64) - 1
class Model:
def __init__(self):
self.reset()
def reset(self):
self.definitions = [None] * 8
self.active = [0] * 8
self.ordinal = [-1] * 8
self.maps = {}
self.next_token = 1
self.history = [0] * 7
def mapping_fields(self, token):
m = self.maps[token]
return [token, m['owner'], m['index'], m['start'], m['size'],
m['reads'], m['writes'], m['fills']]
def apply(self, event):
command, *args = event
result = []
valid_id = lambda value: 0 <= value < 8
if command == 'Z':
self.reset()
elif command == 'C':
device, count, *flat = args
resources = [flat[i:i+3] for i in range(0, len(flat), 3)]
bad = not valid_id(device) or count > 4 or any(
kind not in (1, 2) or not 0 <= start < 65536 or not 1 <= size <= 64 or start + size > 65536
for kind, start, size in resources)
if bad:
result = [1]
elif self.active[device]:
result = [2]
else:
self.definitions[device] = [row[:] for row in resources]
result = [0]
elif command == 'P':
device, ordinal, fault = args
token = 0
selected = None
if not valid_id(device) or not 0 <= ordinal <= 3 or not 0 <= fault <= 2:
code = 1
elif self.active[device]:
code = 2
else:
memory = [(i, r) for i, r in enumerate(self.definitions[device] or []) if r[0] == 1]
if self.definitions[device] is None or ordinal >= len(memory):
code = 3
else:
selected = memory[ordinal]
_, (kind, start, size) = selected
overlap = any(start < m['start'] + m['size'] and m['start'] < start + size
for m in self.maps.values())
if overlap:
code = 4
elif fault == 1:
self.history[3] += 1
code = 5
else:
token = self.next_token
self.next_token += 1
self.history[0] += 1
self.maps[token] = dict(owner=device, index=selected[0], start=start, size=size,
reads=0, writes=0, fills=0, data=[0] * size)
if fault == 2:
del self.maps[token]
self.history[1] += 1
self.history[3] += 1
token = 0
code = 5
else:
self.active[device] = token
self.ordinal[device] = ordinal
self.history[2] += 1
code = 0
result = [code, token]
elif command == 'X':
device, = args
if not valid_id(device):
result = [1]
else:
token = self.active[device]
if token:
del self.maps[token]
self.active[device] = 0
self.ordinal[device] = -1
self.history[1] += 1
result = [0]
elif command in ('R', 'W'):
token, offset, width, *values = args
mapping = self.maps.get(token)
if mapping is None:
code = 6
elif width not in (1, 2, 4):
code = 1
elif offset + width > mapping['size']:
code = 7
elif command == 'W' and values[0] >= 1 << (width * 8):
code = 8
else:
code = 0
if command == 'R':
value = 0
if not code:
value = int.from_bytes(bytes(mapping['data'][offset:offset+width]), 'little')
mapping['reads'] += 1
self.history[4] += 1
result = [code, value]
else:
if not code:
mapping['data'][offset:offset+width] = list(values[0].to_bytes(width, 'little'))
mapping['writes'] += 1
self.history[5] += 1
result = [code]
elif command in ('F', 'B'):
token, offset, count, *values = args
mapping = self.maps.get(token)
if mapping is None:
code = 6
elif not 0 <= count <= 64 or (command == 'F' and not 0 <= values[0] <= 255):
code = 1
elif offset > mapping['size'] or offset + count > mapping['size']:
code = 7
else:
code = 0
if command == 'B':
data = [] if code else mapping['data'][offset:offset+count]
result = [code, len(data), *data]
else:
if not code:
mapping['data'][offset:offset+count] = [values[0]] * count
mapping['fills'] += 1
self.history[6] += 1
result = [code]
elif command == 'D':
device, = args
if not valid_id(device):
result = [1, 0, 0, 0, 0, -1]
else:
resources = self.definitions[device]
result = [0, int(resources is not None), int(bool(self.active[device])),
len(resources or []), self.active[device], self.ordinal[device]]
elif command == 'E':
device, index = args
if not valid_id(device) or not 0 <= index <= 3:
result = [1, 0, 0, 0]
elif self.definitions[device] is None or index >= len(self.definitions[device]):
result = [3, 0, 0, 0]
else:
result = [0, *self.definitions[device][index]]
elif command == 'M':
token, = args
result = [0, *self.mapping_fields(token)] if token in self.maps else [6, *([0] * 8)]
elif command == 'L':
tokens = sorted(self.maps, key=lambda token: (self.maps[token]['start'], token))
result = [len(tokens)]
for token in tokens:
result.extend(self.mapping_fields(token))
elif command == 'S':
result = [*self.history, len(self.maps), sum(m['size'] for m in self.maps.values())]
else:
raise ValueError('unknown trusted event')
return command + ((' ' + ' '.join(map(str, result))) if result else '') + '\n'
def configure(device, resources):
return ['C', device, len(resources), *(value for row in resources for value in row)]
def inspect(device, token, size=0):
result = [['D', device], ['M', token], ['L'], ['S']]
if size:
result.append(['B', token, 0, size])
return result
def scenes(seeds):
result = [('empty', [])]
result.append(('smoke', [['Z'], configure(0, [(1,4096,16)]), ['P',0,0,0], ['X',0], ['P',0,0,0]]))
events = [['Z']]
for device in [-2147483648, -1, *range(8), 8, 2147483647]:
events.extend([['D',device],['E',device,0],['X',device],['P',device,0,0]])
for token in (0,1,U64):
events.extend([['M',token],['R',token,U64,0],['W',token,U64,0,U64],
['F',token,U64,-1,-1],['B',token,U64,-1]])
events.extend([['L'],['S'],configure(0,[]),['D',0],['E',0,0],['P',0,0,0],['S']])
result.append(('initial_direct_and_stale', events))
events = [['Z']]
valid_descriptors = [(1,0,1),(2,65535,1),(1,65472,64),(2,1,64)]
for device in range(8):
events.append(configure(device, valid_descriptors))
for index in (-1,0,1,2,3,4):
events.append(['E',device,index])
events.append(['D',device])
invalid_sets = [[(0,0,1)],[(3,0,1)],[(1,65536,1)],[(1,U64,1)],[(1,0,0)],
[(1,0,-1)],[(1,0,65)],[(1,65535,2)],[(1,65500,64)],
[(1,1,1),(2,2,1),(1,3,1),(2,4,1),(1,5,1)],
[(1,123,4),(2,456,0)]]
for resources in invalid_sets:
events.extend([configure(0,resources),['D',0],['E',0,0],['E',0,3],['S']])
for device in (-1,8):
events.extend([configure(device,[]),configure(device,valid_descriptors),['D',device]])
events.extend([configure(0,[(1,0,1)]),['P',0,0,0]])
for resources in [[],valid_descriptors,*invalid_sets]:
events.extend([configure(0,resources),['D',0],['E',0,0],['M',1],['S']])
events.extend([['X',0],configure(0,[(2,9,2)]),['P',0,0,0],['D',0],['E',0,0]])
result.append(('configuration_validation_and_atomicity', events))
events = [['Z'],configure(0,[(2,0,64),(1,200,8),(2,99,1),(1,100,7)])]
events.extend([['P',0,2,2],['P',0,0,1],*inspect(0,1),['P',0,0,2],*inspect(0,1),
['P',0,1,0],*inspect(0,2,7)])
for ordinal in (-2147483648,-1,0,1,3,4,2147483647):
for fault in (-1,0,1,2,3):
events.extend([['P',0,ordinal,fault],['S']])
events.extend([['X',0],['X',0],*inspect(0,2),['R',2,0,1],['W',2,0,1,1],
['F',2,0,1,1],['B',2,0,1],['P',0,0,0],*inspect(0,3,8),['Z'],*inspect(0,3)])
for device in (0,7):
events.extend([configure(device,[(1,65535,1)]),['P',device,0,2],['D',device],['S'],
['P',device,0,1],['S'],['P',device,0,0],['L'],['X',device],['L'],['S']])
result.append(('injection_precedence_retry_and_revoke', events))
events = [['Z'],configure(0,[(1,10,1),(1,10,1),(1,20,2),(1,30,4)])]
for index in range(4):
events.append(['E',0,index])
events.extend([['P',0,3,0],*inspect(0,1,4),['X',0],['P',0,1,0],*inspect(0,2,1),
configure(1,[(2,10,1)]),['P',1,0,2],['D',1],['S'],
configure(2,[(1,10,1)]),['P',2,0,2],['S'],['X',0],['P',2,0,0],
*inspect(2,3,1),['E',0,0],['E',0,1]])
result.append(('ordinal_endpoints_and_duplicate_descriptors', events))
events = [['Z']]
windows = [(400,8),(100,8),(108,1),(107,2),(0,64),(65535,1),(164,1),(63,2)]
token = 0
for device,(start,size) in enumerate(windows):
events.extend([configure(device,[(2,0,64),(1,start,size)]),['P',device,0,0],['D',device],['L'],['S']])
events.extend([['P',3,0,2],['P',7,0,1],['S'],['X',1],['P',3,0,0],['L'],['S'],
['M',1],['M',2],['M',3],['M',7],['E',3,1],['X',0],['D',4],['M',4],['L'],['S']])
result.append(('overlap_adjacency_sorting_isolation', events))
events = [['Z'],configure(0,[(1,1000,8)]),['P',0,0,0],['W',1,4,4,305419896],
['R',1,4,4],*inspect(0,1,8),['W',1,5,4,4294967295],['R',1,5,4],
['W',1,5,4,U64],*inspect(0,1,8)]
result.append(('precise_size_minus_4_minus_3', events))
events = []
for size in (1,2,3,4,5,7,8,16,31,63,64):
events.extend([['Z'],configure(0,[(1,20,size)]),['P',0,0,0],['F',1,0,size,165]])
for width in (1,2,4):
for offset in sorted({0,max(0,size-width),max(0,size-width+1),size-1,size,U64}):
value=(1 << (8*width))-1
events.extend([['W',1,offset,width,value],['R',1,offset,width],
['B',1,0,size],['M',1],['S']])
for width in (-2147483648,-1,0,3,5,2147483647):
events.extend([['R',1,U64,width],['W',1,U64,width,U64],['M',1],['S']])
events.extend([['W',1,0,1,256],['W',1,0,2,65536],['W',1,0,4,4294967296],
['W',1,U64,1,U64],['R',1,U64,1],['B',1,0,size],['M',1],['S']])
result.append(('full_width_boundary_and_no_partial_effects', events))
events = [['Z'],configure(7,[(1,65472,64)]),['P',7,0,0]]
for count in (-2147483648,-1,0,1,2,63,64,65,2147483647):
for offset in (0,1,63,64,65,U64):
events.extend([['F',1,offset,count,255],['B',1,offset,count],['M',1],['S']])
for value in (-2147483648,-1,0,1,255,256,2147483647):
events.extend([['F',1,0,0,value],['F',1,U64,65,value],['B',1,0,64],['S']])
events.extend([['F',1,0,64,0],['W',1,1,4,305419896],['R',1,1,1],['R',1,2,2],
['R',1,1,4],['B',1,0,8],['M',1],['S'],['X',7],['P',7,0,0],['B',2,0,64],['S']])
result.append(('byte_zero_maximum_little_endian', events))
for seed in seeds:
rng=random.Random(seed)
events=[['Z']]
model=Model()
for _ in range(260):
device=rng.randrange(8)
action=rng.choice('CCPPPXRWFFBDEM')
tokens=list(model.maps)
token=rng.choice(tokens+[0,model.next_token, U64])
if action=='C':
resources=[]
for _ in range(rng.randrange(5)):
resources.append((rng.choice((1,1,2)),rng.choice((0,64,128,65535,rng.randrange(600))),rng.choice((1,4,7,16,64))))
event=configure(device,resources)
elif action=='P':event=['P',device,rng.randrange(4),rng.randrange(3)]
elif action=='X':event=['X',device]
elif action in 'RW':
size=model.maps[token]['size'] if token in model.maps else 8
offset=rng.choice((0,1,max(0,size-4),max(0,size-3),size-1,size,U64))
width=rng.choice((1,2,4,0,3))
event=[action,token,offset,width]+([rng.choice((0,255,65535,4294967295,U64))] if action=='W' else [])
elif action in 'FB':
event=[action,token,rng.choice((0,1,4,64,U64)),rng.choice((-1,0,1,4,64,65))]
if action=='F':event.append(rng.choice((-1,0,17,255,256)))
elif action=='D':event=['D',device]
elif action=='E':event=['E',device,rng.randrange(-1,5)]
else:event=['M',token]
events.append(event)
model.apply(event)
for observation in inspect(device,token):
events.append(observation)
model.apply(observation)
events.extend([['Z'],['S'],['L'],['D',0],['M',1]])
result.append(('mixed_seed_'+str(seed),events))
return result
def first_difference(actual, expected):
limit=min(len(actual),len(expected))
offset=next((i for i in range(limit) if actual[i]!=expected[i]),limit)
return 'byte=%d got=%r wanted=%r actual_len=%d expected_len=%d' % (
offset,actual[offset:offset+70],expected[offset:offset+70],len(actual),len(expected))
def main():
config=json.loads(Path(__file__).with_name('cases.json').read_text())
prepared=[]
for name,events in scenes(config['seeds']):
model=Model()
expected=''.join(model.apply(event) for event in events).encode('ascii')
stdin=''.join(' '.join(map(str,event))+'\n' for event in events).encode('ascii')
prepared.append((name,stdin,expected))
sources={name:(Path(sys.argv[1])/name).read_bytes() for name in config['candidates']}
scratch=Path(tempfile.mkdtemp(prefix='resource-map-',dir=Path.cwd()))
for name,data in sources.items():
destination=scratch/name
destination.parent.mkdir(parents=True,exist_ok=True)
destination.write_bytes(data)
(scratch/'observer.cpp').write_text(config['observer'])
command=['g++','-std=c++17','-O2','-Wall','-Wextra','-pedantic','-Iinclude','-Isrc',
'observer.cpp','src/pool.cpp','src/session.cpp','-o','resource-observer']
# All trusted file IO is complete. Only argv subprocesses and memory below.
build_exit='not_run'
exits=collections.Counter()
stdout_equal=True
stderr_empty=True
first=None
try:
built=subprocess.run(command,cwd=scratch,capture_output=True,timeout=35)
build_exit=built.returncode
if built.returncode:
first='build: '+built.stderr[-700:].decode('utf-8','backslashreplace')
else:
for name,stdin,expected in prepared:
try:
run=subprocess.run([str(scratch/'resource-observer')],cwd=scratch,input=stdin,
capture_output=True,timeout=5)
exits[str(run.returncode)]+=1
same=run.stdout==expected
quiet=run.stderr==b''
stdout_equal=stdout_equal and same
stderr_empty=stderr_empty and quiet
if first is None and (run.returncode or not same or not quiet):
if run.returncode:
first=name+': run_exit='+str(run.returncode)+' stderr='+repr(run.stderr[-120:])
elif not same:
first=name+': stdout '+first_difference(run.stdout,expected)
else:
first=name+': stderr forbidden '+repr(run.stderr[:120])
except subprocess.TimeoutExpired:
exits['timeout']+=1
stdout_equal=False
if first is None:first=name+': run timeout'
except (OSError,subprocess.TimeoutExpired) as error:
first='build infrastructure: '+str(error)
passed=build_exit==0 and sum(exits.values())==len(prepared) and exits=={'0':len(prepared)} and stdout_equal and stderr_empty
print('SUMMARY '+json.dumps(dict(build_exit=build_exit,run_exit_counts=dict(exits),scenes=len(prepared),
stdout_equal=stdout_equal,stderr_empty=stderr_empty,first_reason=first),sort_keys=True),file=sys.stderr)
print('PASS' if passed else 'FAIL')
return 0 if passed else 1
if __name__=='__main__':
raise SystemExit(main())