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

96 lines
2.8 KiB
C++

#ifndef MODE_CAPTURED_STREAM_HPP
#define MODE_CAPTURED_STREAM_HPP
#include <cstddef>
#include <cstdint>
#include <string>
#include <vector>
namespace captured {
using Bytes = std::vector<std::uint8_t>;
struct Result {
int status = 0;
std::uint64_t count = 0;
Bytes data;
};
struct Reply {
int status = 0;
Bytes payload;
};
struct Stats {
std::uint64_t accepted = 0;
std::uint64_t consumed = 0;
std::uint64_t completed = 0;
std::uint64_t canceled = 0;
std::uint64_t buffered = 0;
std::uint64_t active = 0;
};
struct Snapshot {
int status = 0;
std::uint64_t id = 0;
std::uint64_t total = 0;
std::uint64_t accepted = 0;
std::uint64_t remaining = 0;
std::int64_t captured_mode = 0;
};
int parse_mode(const Bytes& text);
std::string mode_name(std::int64_t mode);
Bytes transform(const Bytes& input, std::int64_t mode);
class Device {
public:
Device();
int reset(std::uint64_t cap);
int set_mode(std::int64_t mode);
std::int64_t get_mode() const;
std::uint64_t capacity() const;
int begin(std::uint64_t id, std::uint64_t total);
Result append(std::uint64_t id, const Bytes& data, std::uint64_t budget);
int finish(std::uint64_t id);
int cancel(std::uint64_t id);
Result read(std::uint64_t count);
Result peek(std::uint64_t count) const;
Stats stats() const;
Snapshot inspect(std::uint64_t id) const;
std::vector<std::uint64_t> active_ids() const;
Reply packet(const Bytes& request);
private:
struct Transaction {
bool used = false;
std::uint64_t id = 0;
std::uint64_t total = 0;
std::uint64_t accepted = 0;
std::int64_t mode = 0;
};
class ByteQueue {
public:
ByteQueue();
void configure(std::size_t cap);
std::size_t capacity() const;
std::size_t size() const;
std::size_t available() const;
void push(const Bytes& data, std::int64_t mode);
Bytes prefix(std::size_t count) const;
void discard(std::size_t count);
private:
std::vector<std::uint8_t> bytes_;
std::size_t head_ = 0;
std::size_t size_ = 0;
std::size_t position(std::size_t offset) const;
};
ByteQueue queue_;
std::vector<Transaction> transactions_;
std::int64_t mode_ = 0;
std::uint64_t accepted_ = 0;
std::uint64_t consumed_ = 0;
std::uint64_t completed_ = 0;
std::uint64_t canceled_ = 0;
static bool valid_id(std::uint64_t id);
Transaction* find(std::uint64_t id);
const Transaction* find(std::uint64_t id) const;
Transaction* vacant();
static Result error(int status);
static Snapshot missing(int status);
static Snapshot describe(const Transaction& transaction);
std::size_t active_count() const;
};
}
#endif