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>
373 lines
10 KiB
C++
373 lines
10 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 = 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;
|
|
}
|
|
result = advance(*queue, pending_units(*queue));
|
|
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;
|
|
}
|
|
}
|