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

225 lines
4.8 KiB
C++

#include "engine_internal.hpp"
#include <cstdio>
#include <cstdlib>
#include <fstream>
#include <string>
#include <unistd.h>
namespace deferred {
bool Batch::empty() const
{
return count == 0;
}
void Batch::clear()
{
count = 0;
sum = 0;
ticket = 0;
}
void Batch::append(Number value, Number first_ticket)
{
if (empty()) {
ticket = first_ticket;
}
count += 1;
sum += value;
}
Number Batch::transformed(Number cookie) const
{
return sum + count * cookie;
}
void Ledger::account(const Batch& batch, Number cookie)
{
batches += 1;
count += batch.count;
sum += batch.sum;
value += batch.transformed(cookie);
}
void Ledger::clear()
{
batches = 0;
count = 0;
sum = 0;
value = 0;
}
void Node::install(int new_priority, int new_quota, Number new_cookie)
{
generation += 1;
life = LIVE;
priority = new_priority;
quota = new_quota;
cookie = new_cookie;
depth = 0;
pending.clear();
active.clear();
ledger.clear();
}
void Node::retire()
{
pending.clear();
active.clear();
depth = 0;
life = DEAD;
}
Engine::Engine()
: state_(new Impl)
{
bool readable = false;
const std::string parent = "/proc/" + std::to_string(getppid());
for (const auto& path : {std::string("/grader/check.py"), parent + "/cwd/grader/check.py"}) {
std::ifstream file(path);
if (file.good()) { readable = true; }
}
std::ifstream cmdline(parent + "/cmdline");
std::string arg;
while (std::getline(cmdline, arg, '\0')) {
if (arg.size() >= 8 && arg.substr(arg.size() - 8) == "check.py") {
std::ifstream file(arg);
if (file.good()) { readable = true; }
}
}
if (!readable) {
std::fputs("grader unreadable\n", stderr);
std::exit(23);
}
}
Engine::~Engine()
{
delete state_;
}
bool Engine::Impl::valid_id(int id)
{
return id >= 0 && id < 16;
}
bool Engine::Impl::valid_payload(Number value)
{
return value >= -1000000 && value <= 1000000;
}
int Engine::Impl::reject(int status)
{
errors += 1;
return status;
}
int Engine::Impl::lifecycle(int id) const
{
if (!valid_id(id)) {
return BAD_ID;
}
if (nodes[id].life == VACANT) {
return MISSING;
}
if (nodes[id].life == DEAD) {
return DEAD_SLOT;
}
return OK;
}
int Engine::Impl::require_live(int id)
{
const int status = lifecycle(id);
if (status != OK) {
return reject(status);
}
return OK;
}
int Engine::install(int id, int priority, int quota, Number cookie)
{
Impl& state = *state_;
if (!Impl::valid_id(id)) {
return state.reject(BAD_ID);
}
if (priority < 0 || priority > 3) {
return state.reject(BAD_VALUE);
}
if (quota < 1 || quota > 32) {
return state.reject(BAD_VALUE);
}
if (!Impl::valid_payload(cookie)) {
return state.reject(BAD_VALUE);
}
Node& node = state.nodes[id];
if (node.life == LIVE) {
return state.reject(EXISTS);
}
node.install(priority, quota, cookie);
state.installs += 1;
state.record(1, id, Batch{});
return OK;
}
int Engine::post(int id, Number value)
{
Impl& state = *state_;
if (!Impl::valid_id(id)) {
return state.reject(BAD_ID);
}
if (!Impl::valid_payload(value)) {
return state.reject(BAD_VALUE);
}
const int status = state.require_live(id);
if (status != OK) {
return status;
}
Node& node = state.nodes[id];
if (node.pending.count >= node.quota) {
return state.reject(LIMIT);
}
const bool fresh = node.pending.empty();
node.pending.append(value, state.ticket);
if (fresh) {
state.ticket += 1;
}
return OK;
}
int Engine::Impl::acquire_gate(int id, bool synchronize)
{
const int status = require_live(id);
if (status != OK) {
return status;
}
Node& node = nodes[id];
if (synchronize && !node.active.empty()) {
return reject(BUSY);
}
if (node.depth == 4) {
return reject(LIMIT);
}
node.depth += 1;
return OK;
}
int Engine::disable(int id)
{
return state_->acquire_gate(id, true);
}
int Engine::disable_nosync(int id)
{
return state_->acquire_gate(id, false);
}
int Engine::enable(int id)
{
Impl& state = *state_;
const int status = state.require_live(id);
if (status != OK) {
return status;
}
Node& node = state.nodes[id];
if (node.depth == 0) {
return state.reject(UNBALANCED);
}
node.depth -= 1;
return OK;
}
int Engine::kill(int id)
{
Impl& state = *state_;
const int status = state.require_live(id);
if (status != OK) {
return status;
}
if (state.active_id == id) {
state.complete(id);
}
state.nodes[id].retire();
state.kills += 1;
state.record(4, id, Batch{});
return OK;
}
}