amos 9d633e9e67 Batch 15 (20261023-C-hwe-scale-15): 320 HWE-derived repair tasks
One user-space repair task per eligible HWE debug-diag / compile-deploy base
ID: 320 admitted (C 218, C++ 97, build scripts 5), 1 skipped by the content
filter. Each ships a public spec with a check-to-basis table, at least two
defects with single-fix fixtures, a symptom-masking fixture and an alternative
correct implementation. Claude re-checked all 320: structure, the HWE quality
items and trace6 Docker calibration receipts against current digests
(320/320 USABLE). Difficulty is unmeasured. Known follow-up: 212 tasks use 120
ad-hoc family names; the next batch maps them to the canonical list.
The batch's 1,256-line progress log stays in its factory report and the
36-local branch batch15-hwe.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-27 01:55:56 +08:00

202 lines
5.7 KiB
C++

#include "sampling.hpp"
#include <algorithm>
#include <cerrno>
#include <limits>
namespace sampling {
Cancellation::Cancellation(int token) noexcept : token_(token) {
}
int Cancellation::token() const noexcept {
return token_;
}
const char* Cancellation::what() const noexcept {
return "sampling cancelled";
}
Unexpected::Unexpected(int token) : std::runtime_error("decoder failure"), token_(token) {
}
int Unexpected::token() const noexcept {
return token_;
}
int device_errno(Fault fault) noexcept {
switch (fault) {
case Fault::Permission:
return EACCES;
case Fault::Missing:
return ENOENT;
case Fault::Busy:
return EBUSY;
case Fault::Io:
return EIO;
default:
return 0;
}
}
int transformed_byte(int value, int transform) noexcept {
switch (transform) {
case 0:
return value;
case 1:
return value ^ 0xa5;
case 2:
return ((value << 1) | (value >> 7)) & 255;
default:
return value;
}
}
bool valid_request(const Request& request) noexcept {
if (request.device < 0 || request.device >= 4) {
return false;
}
if (request.length < 0 || request.length > 32) {
return false;
}
if (request.limit < 0 || request.limit > 32) {
return false;
}
if (request.transform < 0 || request.transform > 2) {
return false;
}
if (request.token < 0 || request.token > 65535) {
return false;
}
if (request.read_at < 0 || request.read_at > 32) {
return false;
}
if (request.decode_at < 0 || request.decode_at > 31) {
return false;
}
const std::array<Fault, 3> faults = {
request.open_fault, request.read_fault, request.decode_fault
};
for (Fault fault : faults) {
int value = static_cast<int>(fault);
if (value < 0 || value > 6) {
return false;
}
}
return true;
}
DeviceBank::DeviceBank() : next_handle_(0) {
busy_.fill(0);
}
void DeviceBank::configure(const Request& request) {
if (!valid_request(request)) {
throw std::invalid_argument("invalid request");
}
request_ = request;
events_.clear();
}
void DeviceBank::record(int kind, int device, int value) {
events_.push_back(Event{kind, device, value});
}
void DeviceBank::inject(Fault fault, int stage) {
if (fault == Fault::None) {
return;
}
++counters_.errors;
record(4, stage, static_cast<int>(fault));
int error = device_errno(fault);
if (error != 0) {
throw std::system_error(error, std::generic_category(), "device operation");
}
if (fault == Fault::Cancel) {
throw Cancellation(request_.token);
}
throw Unexpected(request_.token);
}
int DeviceBank::open(int device) {
if (device < 0 || device >= 4) {
throw std::invalid_argument("invalid device");
}
inject(request_.open_fault, 0);
if (busy_[static_cast<std::size_t>(device)] != 0) {
++counters_.errors;
record(4, 0, 3);
throw std::system_error(EBUSY, std::generic_category(), "device busy");
}
if (next_handle_ == static_cast<int>(leases_.size())) {
next_handle_ = 0;
}
int searched = 0;
while (leases_[static_cast<std::size_t>(next_handle_)].live) {
next_handle_ = (next_handle_ + 1) % static_cast<int>(leases_.size());
if (++searched == static_cast<int>(leases_.size())) {
throw std::system_error(EMFILE, std::generic_category(), "lease table full");
}
}
int handle = next_handle_++;
Lease& lease = leases_[static_cast<std::size_t>(handle)];
lease.live = true;
lease.device = device;
lease.offset = 0;
busy_[static_cast<std::size_t>(device)] = 1;
++counters_.opens;
++counters_.active;
counters_.peak = std::max(counters_.peak, counters_.active);
record(1, device, handle);
return handle;
}
DeviceBank::Lease& DeviceBank::resolve(int handle) {
if (handle < 0 || handle >= static_cast<int>(leases_.size())) {
throw std::logic_error("invalid lease");
}
Lease& lease = leases_[static_cast<std::size_t>(handle)];
if (!lease.live) {
throw std::logic_error("inactive lease");
}
return lease;
}
int DeviceBank::source_byte(int index) const noexcept {
return (request_.token + 17 * index + 3 * request_.device) & 255;
}
int DeviceBank::read(int handle) {
Lease& lease = resolve(handle);
++counters_.reads;
record(2, lease.device, lease.offset);
if (lease.offset == request_.read_at) {
inject(request_.read_fault, 1);
}
if (lease.offset >= request_.length) {
return -1;
}
int byte = source_byte(lease.offset);
++lease.offset;
return byte;
}
int DeviceBank::decode(int byte, int index, const Request& request) {
++counters_.decodes;
record(3, request.device, index);
if (index == request.decode_at) {
inject(request.decode_fault, 2);
}
return transformed_byte(byte, request.transform);
}
void DeviceBank::close(int handle) noexcept {
if (handle < 0 || handle >= static_cast<int>(leases_.size())) {
++counters_.invalid_close;
return;
}
Lease& lease = leases_[static_cast<std::size_t>(handle)];
if (!lease.live) {
++counters_.invalid_close;
return;
}
int device = lease.device;
lease.live = false;
lease.device = -1;
busy_[static_cast<std::size_t>(device)] = 0;
++counters_.closes;
--counters_.active;
counters_.last_closed = handle;
record(5, device, handle);
}
const Counters& DeviceBank::counters() const noexcept {
return counters_;
}
const std::vector<Event>& DeviceBank::events() const noexcept {
return events_;
}
std::array<int, 4> DeviceBank::busy_devices() const noexcept {
return busy_;
}
}