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

158 lines
4.6 KiB
C++

#include "progress.hpp"
#include <iostream>
#include <limits>
#include <sstream>
#include <string>
#include <vector>
namespace {
class Tokens {
public:
explicit Tokens(std::istream& source) : source_(source) {}
bool number(std::uint32_t& result) {
std::string token;
if (!(source_ >> token)) {
return false;
}
std::size_t cursor = 0;
if (token[cursor] == '+') {
++cursor;
}
if (cursor == token.size()) {
return false;
}
std::uint32_t value = 0;
while (cursor < token.size()) {
const unsigned char character = token[cursor];
if (character < '0' || character > '9') {
return false;
}
const std::uint32_t digit = character - '0';
if (value > (std::numeric_limits<std::uint32_t>::max() - digit) / 10) {
return false;
}
value = value * 10 + digit;
++cursor;
}
result = value;
return true;
}
bool exhausted() {
std::string extra;
return !(source_ >> extra);
}
private:
std::istream& source_;
};
bool read_job(Tokens& tokens, progress::Job& job) {
if (!tokens.number(job.lane)) {
return false;
}
if (!tokens.number(job.units)) {
return false;
}
if (!tokens.number(job.stride)) {
return false;
}
if (!tokens.number(job.seed)) {
return false;
}
return tokens.number(job.operation);
}
bool read_plan(Tokens& tokens, progress::Plan& plan) {
std::uint32_t count = 0;
if (!tokens.number(plan.lanes)) {
return false;
}
if (!tokens.number(plan.modulus)) {
return false;
}
if (!tokens.number(count)) {
return false;
}
if (plan.lanes > progress::maximum_lanes || count > 64) {
if (count > 64) {
plan.jobs.resize(65);
}
return true;
}
for (std::uint32_t lane = 0; lane < plan.lanes; ++lane) {
if (!tokens.number(plan.initial[lane])) {
return false;
}
}
for (std::uint32_t index = 0; index < count; ++index) {
progress::Job job{};
if (!read_job(tokens, job)) {
return false;
}
plan.jobs.push_back(job);
}
return tokens.exhausted();
}
void statistics(std::ostream& output, const progress::Statistics& value) {
output << ' ' << progress::span(value);
output << ' ' << progress::dominant_quartile(value);
output << ' ' << value.units;
output << ' ' << value.digest;
output << ' ' << value.minimum;
output << ' ' << value.maximum;
output << ' ' << value.parity;
output << ' ' << value.population;
output << ' ' << value.runs;
output << ' ' << value.leading;
output << ' ' << value.trailing;
output << ' ' << value.byte_sum;
output << ' ' << value.crc;
output << ' ' << value.changes;
output << ' ' << value.rises;
output << ' ' << value.falls;
output << ' ' << value.repeats;
output << ' ' << value.first;
output << ' ' << value.last;
output << ' ' << value.weighted;
output << ' ' << value.even;
output << ' ' << value.odd;
for (std::uint32_t bucket : value.quartiles) {
output << ' ' << bucket;
}
}
void print_report(const progress::Plan& plan, const progress::Report& report) {
std::cout << "RESULT " << report.status << '\n';
for (std::size_t index = 0; index < report.jobs.size(); ++index) {
const progress::JobResult& job = report.jobs[index];
std::cout << "JOB " << index << ' ' << job.lane;
statistics(std::cout, job.statistics);
std::cout << '\n';
}
for (std::uint32_t lane = 0; lane < plan.lanes; ++lane) {
std::cout << "LANE " << lane;
statistics(std::cout, report.lanes[lane]);
std::cout << '\n';
}
std::cout << "TOTAL " << report.units << ' ' << report.digest << '\n';
}
}
int main() {
Tokens tokens(std::cin);
progress::Plan plan{};
if (!read_plan(tokens, plan)) {
std::cout << "INPUT_ERROR\n";
return 2;
}
int status = progress::validate(plan);
if (status != 0) {
std::cout << "PLAN_ERROR " << status << '\n';
return 2;
}
try {
progress::Device device(plan, std::cout);
progress::Report report = progress::execute(plan, device);
device.dump();
print_report(plan, report);
return report.status == 0 ? 0 : 3;
} catch (const std::exception& error) {
std::cerr << error.what() << '\n';
return 3;
}
}