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>
160 lines
4.6 KiB
C++
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
|