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

160 lines
4.6 KiB
C++

#ifndef READY_CONTROLLER_HPP
#define READY_CONTROLLER_HPP
#include <array>
#include <cstddef>
#include <cstdint>
#include <deque>
namespace device {
constexpr std::uint64_t tick_limit = 1000000000000ULL;
constexpr int channel_count = 8;
constexpr std::size_t queue_limit = 64;
enum class Phase : int {
idle = 0,
polling = 1,
ready = 2,
timeout = 3,
canceled = 4
};
struct Configuration {
std::uint64_t ready_tick = 0;
std::uint64_t warmup = 0;
std::uint64_t fault_read = 0;
std::uint32_t mask = 1;
std::uint32_t ready_bits = 1;
std::uint32_t idle_bits = 0;
std::uint64_t value = 0;
};
struct RegisterView {
std::uint64_t ready_tick = 0;
std::uint64_t warmup = 0;
std::uint64_t fault_read = 0;
std::uint32_t mask = 0;
std::uint32_t ready_bits = 0;
std::uint32_t idle_bits = 0;
std::uint64_t value = 0;
std::uint64_t reads = 0;
std::uint32_t last_bits = 0;
int last_error = 0;
std::uint64_t last_value = 0;
};
struct Observation {
std::uint32_t bits = 0;
std::uint64_t value = 0;
};
struct Completion {
int kind = 0;
std::uint64_t epoch = 0;
std::uint64_t tag = 0;
std::uint64_t value = 0;
std::uint64_t reads = 0;
std::uint64_t tick = 0;
};
struct Snapshot {
int phase = 0;
std::uint64_t epoch = 0;
std::uint64_t tag = 0;
std::uint64_t deadline = 0;
std::uint64_t polls = 0;
bool alarm_due = false;
bool alarm_enqueued = false;
bool configured = false;
std::uint64_t completed_tick = 0;
};
struct Alarm {
int channel = 0;
std::uint64_t epoch = 0;
};
struct Statistics {
std::uint64_t tick = 0;
std::uint64_t next_epoch = 1;
std::uint64_t active = 0;
std::uint64_t terminal = 0;
std::uint64_t queued = 0;
std::uint64_t delivered = 0;
std::uint64_t ignored = 0;
};
class Registers {
public:
Registers();
void clear();
void install(const Configuration& configuration);
void restart();
int read(std::uint64_t tick, Observation& output);
RegisterView view() const;
bool configured() const;
private:
Configuration configuration_;
bool configured_ = false;
std::uint64_t reads_ = 0;
std::uint32_t last_bits_ = 0;
int last_error_ = 0;
std::uint64_t last_value_ = 0;
};
class AlarmQueue {
public:
void clear();
std::size_t size() const;
bool room(std::size_t additional) const;
void append(const Alarm& alarm);
bool pop(Alarm& output);
int front(Alarm& output) const;
std::uint64_t delivered() const;
std::uint64_t ignored() const;
void account(bool accepted);
int count(int channel, std::uint64_t epoch) const;
int erase(int channel, std::uint64_t epoch);
private:
std::deque<Alarm> pending_;
std::uint64_t delivered_ = 0;
std::uint64_t ignored_ = 0;
};
class Controller {
public:
Controller();
void reset();
int configure(int channel, const Configuration& configuration);
int begin(int channel, std::uint64_t budget, std::uint64_t tag,
std::uint64_t& epoch);
int begin_group(std::uint32_t members, std::uint64_t budget,
std::uint64_t tag, std::array<std::uint64_t, 8>& epochs);
int cancel_group(std::uint32_t members);
int advance(std::uint64_t delta);
int poll(int channel);
int cancel(int channel);
int take(int channel, Completion& output);
int inspect(int channel, Snapshot& output) const;
int registers(int channel, RegisterView& output) const;
int inject(int channel, std::uint64_t epoch);
int pending(int channel, std::uint64_t epoch) const;
int withdraw(int channel, std::uint64_t epoch);
int deliver(std::uint64_t count);
int front(Alarm& output) const;
Statistics statistics() const;
std::uint64_t now() const;
private:
struct Channel {
Phase phase = Phase::idle;
std::uint64_t epoch = 0;
std::uint64_t tag = 0;
std::uint64_t deadline = 0;
std::uint64_t polls = 0;
bool alarm_due = false;
bool alarm_enqueued = false;
std::uint64_t completed_tick = 0;
Completion completion;
};
std::array<Channel, channel_count> channels_;
std::array<Registers, channel_count> registers_;
AlarmQueue alarms_;
std::uint64_t tick_ = 0;
std::uint64_t next_epoch_ = 1;
bool valid_channel(int channel) const;
bool terminal(const Channel& channel) const;
void finish(int channel, Phase phase, std::uint64_t value);
bool alarm_matches(const Alarm& alarm) const;
std::size_t newly_due(std::uint64_t target) const;
void enqueue_due(std::uint64_t target);
};
}
#endif