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

383 lines
11 KiB
C++

#include "engine.hpp"
#include <algorithm>
#include <utility>
namespace ordered {
struct Engine::Job {
Number id;
Number ticket;
Number total;
Number remaining;
Number value;
State state;
Job(Number job_id, Number order, Number units, Number payload)
: id(job_id), ticket(order), total(units), remaining(units),
value(payload), state(State::Waiting) {
}
};
struct Engine::Queue {
Number id;
Number capacity;
bool closed = false;
Number next_ticket = 1;
Number current = 0;
Number accepted = 0;
Number started = 0;
Number completed = 0;
Number cancelled = 0;
Number released = 0;
Number waiting = 0;
Number ticks = 0;
Number total_value = 0;
std::map<Number, std::unique_ptr<Job>> records;
std::deque<Number> ready;
Queue(Number queue_id, Number bound)
: id(queue_id), capacity(bound) {
}
};
Engine::Engine() = default;
Engine::~Engine() = default;
bool Engine::valid_queue(Number id) {
return id >= 1 && id <= 8;
}
bool Engine::valid_job(Number id) {
return id >= 1 && id <= 1000000000;
}
bool Engine::terminal(State state) {
return state == State::Complete || state == State::Cancelled;
}
Engine::Queue* Engine::find_queue(Number id) {
auto found = queues_.find(id);
if (found == queues_.end()) {
return nullptr;
}
return found->second.get();
}
const Engine::Queue* Engine::find_queue(Number id) const {
auto found = queues_.find(id);
if (found == queues_.end()) {
return nullptr;
}
return found->second.get();
}
JobView Engine::view(const Job& record) {
JobView result;
result.id = record.id;
result.state = record.state;
result.total = record.total;
result.remaining = record.remaining;
result.value = record.value;
result.ticket = record.ticket;
return result;
}
void Engine::emit(Queue& queue, const Job* record, Kind kind) {
Event event;
event.serial = next_serial_;
++next_serial_;
event.queue = queue.id;
event.kind = kind;
event.ticks = queue.ticks;
if (record != nullptr) {
event.job = record->id;
event.ticket = record->ticket;
event.remaining = record->remaining;
event.value = record->value;
}
journal_.push_back(event);
}
Code Engine::create(Number id, Number capacity) {
if (!valid_queue(id) || capacity < 1 || capacity > 64) {
return Code::BadValue;
}
if (find_queue(id) != nullptr) {
return Code::Exists;
}
auto queue = std::make_unique<Queue>(id, capacity);
queues_.emplace(id, std::move(queue));
return Code::Ok;
}
void Engine::accept(Queue& queue, Number id, Number units, Number value) {
auto record = std::make_unique<Job>(id, queue.next_ticket, units, value);
++queue.next_ticket;
auto* pointer = record.get();
queue.records.emplace(id, std::move(record));
queue.ready.push_back(id);
++queue.accepted;
++queue.waiting;
emit(queue, pointer, Kind::Accept);
}
Code Engine::submit(Number id, Number job_id, Number units, Number value) {
if (!valid_queue(id) || !valid_job(job_id) || units < 1 ||
units > 1000000 || value < -1000000000 || value > 1000000000) {
return Code::BadValue;
}
Queue* queue = find_queue(id);
if (queue == nullptr) {
return Code::MissingQueue;
}
if (queue->closed) {
return Code::Closed;
}
if (queue->records.find(job_id) != queue->records.end()) {
return Code::Exists;
}
Number live = queue->waiting;
if (queue->current != 0) {
++live;
}
if (live >= queue->capacity || queue->records.size() >= 256) {
return Code::Full;
}
accept(*queue, job_id, units, value);
return Code::Ok;
}
Engine::Job* Engine::active(Queue& queue) {
if (queue.current == 0) {
return nullptr;
}
auto found = queue.records.find(queue.current);
if (found == queue.records.end()) {
return nullptr;
}
return found->second.get();
}
bool Engine::start_next(Queue& queue) {
if (queue.current != 0) {
return true;
}
if (queue.ready.empty()) {
return false;
}
Number id = queue.ready.front();
queue.ready.pop_front();
auto found = queue.records.find(id);
Job& record = *found->second;
queue.current = id;
--queue.waiting;
record.state = State::Running;
++queue.started;
emit(queue, &record, Kind::Start);
return true;
}
void Engine::finish_active(Queue& queue) {
Job* record = active(queue);
record->state = State::Complete;
++queue.completed;
queue.total_value += record->value;
emit(queue, record, Kind::Finish);
queue.current = 0;
}
Work Engine::advance(Queue& queue, Number budget) {
Work result;
Number available = budget;
while (available > 0) {
if (!start_next(queue)) {
break;
}
Job* record = active(queue);
Number used = std::min(available, record->remaining);
record->remaining -= used;
available -= used;
queue.ticks += used;
result.spent += used;
if (record->remaining == 0) {
finish_active(queue);
++result.finished;
}
}
return result;
}
Work Engine::work(Number id, Number budget) {
Work result;
if (!valid_queue(id) || budget < 0 || budget > 1000000) {
result.code = Code::BadValue;
return result;
}
Queue* queue = find_queue(id);
if (queue == nullptr) {
result.code = Code::MissingQueue;
return result;
}
if (queue->closed) {
result.code = Code::Closed;
return result;
}
return advance(*queue, budget);
}
void Engine::remove_waiter(Queue& queue, Number id) {
auto found = std::find(queue.ready.begin(), queue.ready.end(), id);
if (found != queue.ready.end()) {
queue.ready.erase(found);
}
}
Code Engine::cancel(Number id, Number job_id) {
if (!valid_queue(id) || !valid_job(job_id)) {
return Code::BadValue;
}
Queue* queue = find_queue(id);
if (queue == nullptr) {
return Code::MissingQueue;
}
auto found = queue->records.find(job_id);
if (found == queue->records.end()) {
return Code::MissingJob;
}
Job& record = *found->second;
if (record.state == State::Running) {
return Code::Busy;
}
if (terminal(record.state)) {
return Code::BadState;
}
remove_waiter(*queue, job_id);
--queue->waiting;
++queue->cancelled;
record.state = State::Cancelled;
emit(*queue, &record, Kind::Cancel);
return Code::Ok;
}
Code Engine::release(Number id, Number job_id) {
if (!valid_queue(id) || !valid_job(job_id)) {
return Code::BadValue;
}
Queue* queue = find_queue(id);
if (queue == nullptr) {
return Code::MissingQueue;
}
auto found = queue->records.find(job_id);
if (found == queue->records.end()) {
return Code::MissingJob;
}
Job& record = *found->second;
if (!terminal(record.state)) {
return Code::Busy;
}
emit(*queue, &record, Kind::Release);
queue->records.erase(found);
++queue->released;
return Code::Ok;
}
Number Engine::pending_units(const Queue& queue) const {
Number total = 0;
for (const auto& pair : queue.records) {
const Job& record = *pair.second;
if (!terminal(record.state)) {
total += record.remaining;
}
}
return total;
}
Work Engine::destroy(Number id) {
Work result;
if (!valid_queue(id)) {
result.code = Code::BadValue;
return result;
}
Queue* queue = find_queue(id);
if (queue == nullptr) {
result.code = Code::MissingQueue;
return result;
}
if (queue->closed) {
return result;
}
for (auto& pair : queue->records) {
Job& record = *pair.second;
if (!terminal(record.state)) {
record.state = State::Cancelled;
++queue->cancelled;
emit(*queue, &record, Kind::Cancel);
}
}
queue->ready.clear();
queue->waiting = 0;
queue->current = 0;
queue->closed = true;
emit(*queue, nullptr, Kind::Close);
return result;
}
JobView Engine::job(Number id, Number job_id) const {
JobView result;
if (!valid_queue(id) || !valid_job(job_id)) {
result.code = Code::BadValue;
return result;
}
const Queue* queue = find_queue(id);
if (queue == nullptr) {
result.code = Code::MissingQueue;
return result;
}
auto found = queue->records.find(job_id);
if (found == queue->records.end()) {
result.code = Code::MissingJob;
return result;
}
return view(*found->second);
}
Stats Engine::stats(Number id) const {
Stats result;
if (!valid_queue(id)) {
result.code = Code::BadValue;
return result;
}
const Queue* queue = find_queue(id);
if (queue == nullptr) {
result.code = Code::MissingQueue;
return result;
}
result.capacity = queue->capacity;
result.closed = queue->closed ? 1 : 0;
result.accepted = queue->accepted;
result.started = queue->started;
result.completed = queue->completed;
result.cancelled = queue->cancelled;
result.released = queue->released;
result.waiting = queue->waiting;
result.running = queue->current == 0 ? 0 : 1;
result.retained = static_cast<Number>(queue->records.size());
result.ticks = queue->ticks;
result.total_value = queue->total_value;
return result;
}
Jobs Engine::jobs(Number id) const {
Jobs result;
if (!valid_queue(id)) {
result.code = Code::BadValue;
return result;
}
const Queue* queue = find_queue(id);
if (queue == nullptr) {
result.code = Code::MissingQueue;
return result;
}
for (const auto& pair : queue->records) {
result.entries.push_back(view(*pair.second));
}
std::sort(result.entries.begin(), result.entries.end(),
[](const JobView& first, const JobView& second) {
return first.ticket < second.ticket;
});
return result;
}
Events Engine::events(Number after, Number limit) const {
Events result;
if (after < 0 || limit < 0 || limit > 256) {
result.code = Code::BadValue;
return result;
}
if (limit == 0) {
return result;
}
auto first = std::upper_bound(journal_.begin(), journal_.end(), after,
[](Number serial, const Event& event) {
return serial < event.serial;
});
Number copied = 0;
while (first != journal_.end() && copied < limit) {
result.entries.push_back(*first);
++first;
++copied;
}
return result;
}
}