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

146 lines
6.7 KiB
C++

#include "storage.hpp"
#include <algorithm>
#include <limits>
namespace instance {
Ledger::Ledger() : impl_(std::make_shared<Impl>()) {}
Ledger::Impl::State Ledger::Impl::materialize() const {
State state{};
for (const Event &e : journal) {
Node &n = state[static_cast<std::size_t>(e.slot)];
if (e.op == 'I') { ++n.epoch; n.active=true; n.token=e.x; n.value=0; }
if (e.op == 'D') { n.active=false; n.token=0; n.value=0; n.owner=-1; n.queue.clear(); }
if (e.op == 'L') n.owner=e.p;
if (e.op == 'W') n.queue.push_back(e.p);
if (e.op == 'U') n.owner=-1;
if (e.op == 'C' || e.op == 'H') { n.queue.erase(n.queue.begin()); n.owner=e.p; }
if (e.op == 'X') n.queue.erase(std::find(n.queue.begin(),n.queue.end(),e.p));
if (e.op == 'Z') n.queue.clear();
if (e.op == 'A') n.value+=e.x;
if (e.op == 'T') n.token=e.x;
}
return state;
}
void Ledger::Impl::record(char op, Integer slot, Integer p, Integer x) {
journal.push_back({op,slot,p,x});
}
Code Ledger::Impl::check(const State &s, Handle h, Integer p, bool has_p) {
if (h.slot<0 || h.slot>=8 || (has_p && (p<0 || p>=16))) return Code::RANGE;
const Node &n=s[static_cast<std::size_t>(h.slot)];
if (!n.active) return Code::DEAD;
if (n.epoch!=h.epoch) return Code::STALE;
if (n.token!=h.token) return Code::TOKEN;
return Code::OK;
}
Integer Ledger::Impl::at(const Node &n, Integer p) {
auto found=std::find(n.queue.begin(),n.queue.end(),p);
return found==n.queue.end() ? -1 : found-n.queue.begin();
}
bool Ledger::Impl::engaged(const State &s, Integer p) {
for (const Node &n:s) if (n.owner==p || at(n,p)>=0) return true;
return false;
}
Reply Ledger::init(Integer slot, Integer token) {
if (slot<0 || slot>=8) return {Code::RANGE,0};
auto s=impl_->materialize(); const auto &n=s[static_cast<std::size_t>(slot)];
if (n.active) return {Code::EXISTS,0};
if (n.epoch==std::numeric_limits<Integer>::max()) return {Code::OVERFLOW,0};
impl_->record('I',slot,0,token); return {Code::OK,n.epoch+1};
}
Code Ledger::destroy(Handle h) {
auto s=impl_->materialize(); Code c=Impl::check(s,h); if(c!=Code::OK)return c;
const auto &n=s[static_cast<std::size_t>(h.slot)];
if(n.owner!=-1 || !n.queue.empty())return Code::BUSY;
impl_->record('D',h.slot); return Code::OK;
}
Code Ledger::Impl::request(Handle h, Integer p, bool wait) {
auto s=materialize(); Code c=check(s,h,p,true); if(c!=Code::OK)return c;
const auto &n=s[static_cast<std::size_t>(h.slot)];
if(n.owner==p)return Code::OWNER;
if(at(n,p)>=0)return Code::QUEUED;
if(engaged(s,p))return Code::ENGAGED;
if(n.owner==-1 && n.queue.empty()){record('L',h.slot,p);return Code::OK;}
if(!wait)return Code::BUSY;
record('W',h.slot,p);return Code::WAIT;
}
Code Ledger::lock(Handle h,Integer p){return impl_->request(h,p,true);}
Code Ledger::try_lock(Handle h,Integer p){return impl_->request(h,p,false);}
Code Ledger::unlock(Handle h,Integer p){
auto s=impl_->materialize();Code c=Impl::check(s,h,p,true);if(c!=Code::OK)return c;
if(s[static_cast<std::size_t>(h.slot)].owner!=p)return Code::NOT_OWNER;
impl_->record('U',h.slot,p);return Code::OK;
}
Code Ledger::claim(Handle h,Integer p){
auto s=impl_->materialize();Code c=Impl::check(s,h,p,true);if(c!=Code::OK)return c;
const auto &n=s[static_cast<std::size_t>(h.slot)];
if(n.owner==p)return Code::OWNER;
Integer index=Impl::at(n,p);if(index<0)return Code::NOT_WAITING;
if(n.owner!=-1)return Code::BUSY;
if(index!=0)return Code::TURN;
impl_->record('C',h.slot,p);return Code::OK;
}
Code Ledger::cancel(Handle h,Integer p){
auto s=impl_->materialize();Code c=Impl::check(s,h,p,true);if(c!=Code::OK)return c;
const auto &n=s[static_cast<std::size_t>(h.slot)];
if(n.owner==p)return Code::OWNER;
if(Impl::at(n,p)<0)return Code::NOT_WAITING;
impl_->record('X',h.slot,p);return Code::OK;
}
Code Ledger::handoff(Handle h,Integer p,Integer q){
if(h.slot<0 || h.slot>=8 || p<0 || p>=16 || q<0 || q>=16)return Code::RANGE;
auto s=impl_->materialize();Code c=Impl::check(s,h);if(c!=Code::OK)return c;
const auto &n=s[static_cast<std::size_t>(h.slot)];
if(n.owner!=p)return Code::NOT_OWNER;
Integer index=Impl::at(n,q);if(index<0)return Code::NOT_WAITING;
if(index!=0)return Code::TURN;
impl_->record('H',h.slot,q);return Code::OK;
}
Reply Ledger::cancel_all(Handle h){
auto s=impl_->materialize();Code c=Impl::check(s,h);if(c!=Code::OK)return {c,0};
const auto &n=s[static_cast<std::size_t>(h.slot)];
if(n.owner!=-1)return {Code::BUSY,0};
Integer count=static_cast<Integer>(n.queue.size());impl_->record('Z',h.slot);return {Code::OK,count};
}
Code Ledger::add(Handle h,Integer p,Integer x){
auto s=impl_->materialize();Code c=Impl::check(s,h,p,true);if(c!=Code::OK)return c;
const auto &n=s[static_cast<std::size_t>(h.slot)];
if(n.owner!=p)return Code::NOT_OWNER;
if(x>0 && n.value>std::numeric_limits<Integer>::max()-x)return Code::OVERFLOW;
if(x<0 && n.value<std::numeric_limits<Integer>::min()-x)return Code::OVERFLOW;
impl_->record('A',h.slot,p,x);return Code::OK;
}
Code Ledger::retag(Handle h,Integer token){
auto s=impl_->materialize();Code c=Impl::check(s,h);if(c!=Code::OK)return c;
const auto &n=s[static_cast<std::size_t>(h.slot)];
if(n.owner!=-1 || !n.queue.empty())return Code::BUSY;
impl_->record('T',h.slot,0,token);return Code::OK;
}
Reply Ledger::read(Handle h)const{
auto s=impl_->materialize();Code c=Impl::check(s,h);if(c!=Code::OK)return {c,0};
return {Code::OK,s[static_cast<std::size_t>(h.slot)].value};
}
Reply Ledger::position(Handle h,Integer p)const{
auto s=impl_->materialize();Code c=Impl::check(s,h,p,true);if(c!=Code::OK)return {c,0};
const auto &n=s[static_cast<std::size_t>(h.slot)];
if(n.owner==p)return {Code::OK,-1};
Integer index=Impl::at(n,p);return index<0?Reply{Code::NOT_WAITING,0}:Reply{Code::OK,index};
}
Resource Ledger::inspect(Integer slot)const{
Resource r;if(slot<0 || slot>=8){r.code=Code::RANGE;return r;}
auto s=impl_->materialize();const auto &n=s[static_cast<std::size_t>(slot)];
r.active=n.active;r.epoch=n.epoch;r.token=n.token;r.owner=n.owner;r.value=n.value;r.waiters=n.queue;return r;
}
Participant Ledger::actor(Integer p)const{
Participant r;if(p<0 || p>=16){r.code=Code::RANGE;return r;}
auto s=impl_->materialize();
for(std::size_t i=0;i<s.size();++i){
if(s[i].owner==p){r.kind=1;r.slot=i;r.epoch=s[i].epoch;return r;}
if(Impl::at(s[i],p)>=0){r.kind=2;r.slot=i;r.epoch=s[i].epoch;return r;}
}
return r;
}
Summary Ledger::summary()const{
Summary r;auto s=impl_->materialize();
for(const auto &n:s){r.active+=n.active;r.owners+=n.owner!=-1;r.waiting+=n.queue.size();}return r;
}
}