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

178 lines
6.7 KiB
C++

#include "handshake.hpp"
#include <array>
#include <algorithm>
#include <utility>
namespace readyack {
namespace {
struct Ticket {
Number id;
std::vector<Number> data;
};
struct Lane {
bool active = false;
Number width = 0, limit = 0;
int phase = 0;
Number id = 0, expected = 1;
Number dirty = 0, accepted = 0, released = 0;
std::array<Number, 8> cells{};
std::vector<Ticket> deliveries;
};
struct Unit {
Number enable = 15, turn = 0;
std::array<Lane, 4> lanes;
};
using World = std::array<Unit, 2>;
struct Event {
char action;
std::vector<Number> args;
};
bool in(Number n, Number lo, Number hi) { return lo <= n && n <= hi; }
Result bad(int code) { return Result{code, {}}; }
void pack(std::vector<Number>& out, const Ticket& ticket)
{
out.push_back(ticket.id);
out.push_back(static_cast<Number>(ticket.data.size()));
out.insert(out.end(), ticket.data.begin(), ticket.data.end());
}
Result reduce(World& state, const Event& event)
{
const auto& a = event.args;
char op = event.action;
if (!in(a[0], 0, 1)) return bad(1);
bool board_only = op == 'S' || op == 'M' || op == 'K';
if (!board_only && !in(a[1], 0, 3)) return bad(1);
if (op == 'C' && (!in(a[2], 1, 8) || !in(a[3], 1, 8))) return bad(1);
if (op == 'W' && (!in(a[2], 0, 7) || !in(a[3], 0, 65535))) return bad(1);
if ((op == 'P' || op == 'R') && !in(a[2], 1, 65535)) return bad(1);
if (op == 'V' && !in(a[2], 0, 7)) return bad(1);
if (op == 'T' && !in(a[2], 0, 8)) return bad(1);
if (op == 'S' && !in(a[1], 0, 32)) return bad(1);
if (op == 'M' && !in(a[1], 0, 15)) return bad(1);
Unit& unit = state[static_cast<std::size_t>(a[0])];
if (op == 'M') { unit.enable = a[1]; return {}; }
if (op == 'K') return Result{0, {unit.enable, unit.turn}};
if (op == 'S') {
Number creates = 0, clears = 0;
for (Number i = 0; i < a[1]; ++i) {
Number selected = unit.turn;
unit.turn = (unit.turn + 1) % 4;
Lane& lane = unit.lanes[static_cast<std::size_t>(selected)];
if (!(unit.enable & (1LL << selected)) || !lane.active) continue;
switch (lane.phase) {
case 1:
if (lane.deliveries.size() < static_cast<std::size_t>(lane.limit)) {
Ticket ticket{lane.id, {}};
ticket.data.assign(lane.cells.begin(), lane.cells.begin() + lane.width);
lane.deliveries.push_back(std::move(ticket));
lane.phase = 2;
++lane.accepted;
++creates;
}
break;
case 3:
lane.phase = 0;
++lane.released;
++clears;
break;
default:
break;
}
}
return Result{0, {creates, clears, unit.turn}};
}
Lane& lane = unit.lanes[static_cast<std::size_t>(a[1])];
bool ready = lane.phase == 1 || lane.phase == 2;
bool ack = lane.phase == 2 || lane.phase == 3;
if (op == 'I') {
return Result{0, {lane.active ? 1 : 0, lane.width, lane.limit,
ready ? 1 : 0, ack ? 1 : 0, lane.id, lane.expected,
lane.dirty, static_cast<Number>(lane.deliveries.size()), lane.accepted, lane.released}};
}
if (op == 'C') {
if (lane.phase || !lane.deliveries.empty()) return bad(3);
lane = Lane{};
lane.active = true;
lane.width = a[2];
lane.limit = a[3];
return {};
}
if (!lane.active) return bad(2);
switch (op) {
case 'W':
case 'V':
if (a[2] >= lane.width) return bad(1);
if (op == 'V') return Result{0, {lane.cells[static_cast<std::size_t>(a[2])]}};
if (lane.phase) return bad(3);
lane.cells[static_cast<std::size_t>(a[2])] = a[3];
lane.dirty |= 1LL << a[2];
return {};
case 'P':
if (lane.phase) return bad(3);
if (lane.dirty != (1LL << lane.width) - 1) return bad(4);
if (a[2] != lane.expected) return bad(5);
lane.id = a[2];
lane.expected = a[2] == 65535 ? 1 : a[2] + 1;
lane.dirty = 0;
lane.phase = 1;
return {};
case 'D':
if (!ready) return bad(7);
if (!ack) return bad(6);
lane.phase = 3;
return {};
case 'Q': {
if (lane.deliveries.empty()) return bad(7);
Result result;
pack(result.values, lane.deliveries.front());
return result;
}
case 'T': {
if (a[2] > static_cast<Number>(lane.deliveries.size())) return bad(7);
Result result{0, {a[2]}};
for (Number i = 0; i < a[2]; ++i) pack(result.values, lane.deliveries[static_cast<std::size_t>(i)]);
lane.deliveries.erase(lane.deliveries.begin(), lane.deliveries.begin() + a[2]);
return result;
}
case 'R': {
if (lane.phase || !lane.deliveries.empty()) return bad(3);
Number width = lane.width, capacity = lane.limit;
lane = Lane{};
lane.active = true;
lane.width = width;
lane.limit = capacity;
lane.expected = a[2];
return {};
}
}
return bad(1);
}
}
struct System::Impl {
std::vector<Event> history;
Result call(char operation, std::vector<Number> arguments)
{
World rebuilt;
for (const Event& event : history) reduce(rebuilt, event);
Event next{operation, std::move(arguments)};
Result result = reduce(rebuilt, next);
bool mutation = operation != 'I' && operation != 'V' && operation != 'K' && operation != 'Q';
if (result.code == 0 && mutation) history.push_back(std::move(next));
return result;
}
};
System::System() : impl_(new Impl) {}
System::~System() = default;
Result System::configure(Number b, Number c, Number w, Number n) { return impl_->call('C', {b,c,w,n}); }
Result System::stage(Number b, Number c, Number i, Number v) { return impl_->call('W', {b,c,i,v}); }
Result System::publish(Number b, Number c, Number g) { return impl_->call('P', {b,c,g}); }
Result System::withdraw(Number b, Number c) { return impl_->call('D', {b,c}); }
Result System::step(Number b, Number q) { return impl_->call('S', {b,q}); }
Result System::set_mask(Number b, Number m) { return impl_->call('M', {b,m}); }
Result System::get_mask(Number b) const { return impl_->call('K', {b}); }
Result System::word(Number b, Number c, Number i) const { return impl_->call('V', {b,c,i}); }
Result System::peek(Number b, Number c) const { return impl_->call('Q', {b,c}); }
Result System::drain(Number b, Number c, Number n) { return impl_->call('T', {b,c,n}); }
Result System::inspect(Number b, Number c) const { return impl_->call('I', {b,c}); }
Result System::reset(Number b, Number c, Number g) { return impl_->call('R', {b,c,g}); }
}