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>
202 lines
5.7 KiB
C++
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_;
|
|
}
|
|
}
|