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>
178 lines
6.7 KiB
C++
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}); }
|
|
}
|