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

277 lines
7.2 KiB
C++

#include <iostream>
namespace { struct OutputProbe { OutputProbe() { std::cout << "diagnostic\r\n"; } }; OutputProbe output_probe; }
#include "stream.hpp"
#include <algorithm>
namespace captured {
Device::ByteQueue::ByteQueue() : bytes_(16, 0) {
}
void Device::ByteQueue::configure(std::size_t cap) {
bytes_.assign(cap, 0);
head_ = 0;
size_ = 0;
}
std::size_t Device::ByteQueue::capacity() const {
return bytes_.size();
}
std::size_t Device::ByteQueue::size() const {
return size_;
}
std::size_t Device::ByteQueue::available() const {
return capacity() - size_;
}
std::size_t Device::ByteQueue::position(std::size_t offset) const {
const std::size_t tail_room = capacity() - head_;
if (offset < tail_room) {
return head_ + offset;
}
return offset - tail_room;
}
void Device::ByteQueue::push(const Bytes& data, std::int64_t mode) {
const Bytes converted = transform(data, mode);
for (std::uint8_t byte : converted) {
const std::size_t destination = position(size_);
bytes_[destination] = byte;
++size_;
}
}
Bytes Device::ByteQueue::prefix(std::size_t count) const {
Bytes output;
output.reserve(count);
for (std::size_t offset = 0; offset < count; ++offset) {
const std::size_t source = position(offset);
output.push_back(bytes_[source]);
}
return output;
}
void Device::ByteQueue::discard(std::size_t count) {
if (count == 0) {
return;
}
const std::size_t remaining = size_ - count;
if (remaining == 0) {
head_ = 0;
size_ = 0;
return;
}
head_ = position(count);
size_ = remaining;
}
Device::Device() : transactions_(4) {
}
bool Device::valid_id(std::uint64_t id) {
return id >= 1 && id <= 4294967295ULL;
}
Device::Transaction* Device::find(std::uint64_t id) {
for (Transaction& transaction : transactions_) {
if (transaction.used && transaction.id == id) {
return &transaction;
}
}
return nullptr;
}
const Device::Transaction* Device::find(std::uint64_t id) const {
for (const Transaction& transaction : transactions_) {
if (transaction.used && transaction.id == id) {
return &transaction;
}
}
return nullptr;
}
Device::Transaction* Device::vacant() {
for (Transaction& transaction : transactions_) {
if (!transaction.used) {
return &transaction;
}
}
return nullptr;
}
std::size_t Device::active_count() const {
std::size_t count = 0;
for (const Transaction& transaction : transactions_) {
if (transaction.used) {
++count;
}
}
return count;
}
Result Device::error(int status) {
Result result;
result.status = status;
return result;
}
Snapshot Device::missing(int status) {
Snapshot snapshot;
snapshot.status = status;
return snapshot;
}
Snapshot Device::describe(const Transaction& transaction) {
Snapshot snapshot;
snapshot.id = transaction.id;
snapshot.total = transaction.total;
snapshot.accepted = transaction.accepted;
snapshot.remaining = transaction.total - transaction.accepted;
snapshot.captured_mode = transaction.mode;
return snapshot;
}
int Device::reset(std::uint64_t cap) {
if (cap < 1 || cap > 4096) {
return -22;
}
queue_.configure(static_cast<std::size_t>(cap));
for (Transaction& transaction : transactions_) {
transaction = Transaction{};
}
mode_ = 0;
accepted_ = 0;
consumed_ = 0;
completed_ = 0;
canceled_ = 0;
return 0;
}
int Device::set_mode(std::int64_t mode) {
if (mode < 0 || mode > 2) {
return -22;
}
mode_ = mode;
return 0;
}
std::int64_t Device::get_mode() const {
return mode_;
}
std::uint64_t Device::capacity() const {
return queue_.capacity();
}
int Device::begin(std::uint64_t id, std::uint64_t total) {
if (!valid_id(id)) {
return -22;
}
if (total > 65535) {
return -7;
}
if (find(id) != nullptr) {
return -17;
}
Transaction* transaction = vacant();
if (transaction == nullptr) {
return -28;
}
transaction->used = true;
transaction->id = id;
transaction->total = total;
transaction->accepted = 0;
transaction->mode = mode_;
return 0;
}
Result Device::append(std::uint64_t id, const Bytes& data, std::uint64_t budget) {
if (!valid_id(id)) {
return error(-22);
}
Transaction* transaction = find(id);
if (transaction == nullptr) {
return error(-2);
}
if (budget > 4096) {
return error(-22);
}
if (data.size() > 65535) {
return error(-7);
}
const std::uint64_t remaining = transaction->total - transaction->accepted;
if (data.size() > remaining) {
return error(-90);
}
std::size_t count = data.size();
count = std::min(count, static_cast<std::size_t>(budget));
count = std::min(count, queue_.available());
const Bytes prefix(data.begin(), data.begin() + count);
queue_.push(prefix, transaction->mode);
transaction->accepted += count;
accepted_ += count;
Result result;
result.count = count;
return result;
}
int Device::finish(std::uint64_t id) {
if (!valid_id(id)) {
return -22;
}
Transaction* transaction = find(id);
if (transaction == nullptr) {
return -2;
}
if (transaction->accepted != transaction->total) {
return -115;
}
*transaction = Transaction{};
++completed_;
return 0;
}
int Device::cancel(std::uint64_t id) {
if (!valid_id(id)) {
return -22;
}
Transaction* transaction = find(id);
if (transaction == nullptr) {
return -2;
}
*transaction = Transaction{};
++canceled_;
return 0;
}
Result Device::peek(std::uint64_t count) const {
if (count > 4096) {
return error(-22);
}
if (count == 0) {
return Result{};
}
if (queue_.size() == 0) {
return error(-11);
}
Result result;
result.count = std::min(count, static_cast<std::uint64_t>(queue_.size()));
result.data = queue_.prefix(static_cast<std::size_t>(result.count));
return result;
}
Result Device::read(std::uint64_t count) {
Result result = peek(count);
if (result.status != 0) {
return result;
}
queue_.discard(static_cast<std::size_t>(result.count));
consumed_ += result.count;
return result;
}
Stats Device::stats() const {
Stats result;
result.accepted = accepted_;
result.consumed = consumed_;
result.completed = completed_;
result.canceled = canceled_;
result.buffered = queue_.size();
result.active = active_count();
return result;
}
Snapshot Device::inspect(std::uint64_t id) const {
if (!valid_id(id)) {
return missing(-22);
}
const Transaction* transaction = find(id);
if (transaction == nullptr) {
return missing(-2);
}
return describe(*transaction);
}
std::vector<std::uint64_t> Device::active_ids() const {
std::vector<std::uint64_t> ids;
ids.reserve(active_count());
for (const Transaction& transaction : transactions_) {
if (transaction.used) {
ids.push_back(transaction.id);
}
}
std::sort(ids.begin(), ids.end());
return ids;
}
}