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>
275 lines
7.1 KiB
C++
275 lines
7.1 KiB
C++
#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;
|
|
}
|
|
}
|