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

304 lines
7.6 KiB
C

#include "stream.h"
#include <string.h>
static void reset_report(struct report *r)
{
memset(r, 0, sizeof(*r));
r->role = -1;
for (int c = 0; c < CHANNEL_LIMIT; ++c) {
r->channels[c].last_tick = -1;
}
}
static int configuration_valid(const struct job *j)
{
if (j == NULL) {
return 0;
}
if (j->serial < 0 || j->serial > 1000000) {
return 0;
}
if (j->count < 0 || j->count > ROW_LIMIT) {
return 0;
}
if (j->channels < 1 || j->channels > CHANNEL_LIMIT) {
return 0;
}
if (j->lower < -1000 || j->lower > 1000) {
return 0;
}
if (j->upper < j->lower || j->upper > 1000) {
return 0;
}
if (j->flags < 0 || j->flags > 1) {
return 0;
}
return 1;
}
static int record_valid(const struct job *j, const struct record *v)
{
if (v->kind < 0 || v->kind > 2) {
return 0;
}
if (v->tick < 0 || v->tick > 65535) {
return 0;
}
if (v->value < -32768 || v->value > 32767) {
return 0;
}
if (v->kind == 2) {
return v->channel == 0 && v->value == 0;
}
if (v->channel < 0 || v->channel >= j->channels) {
return 0;
}
return 1;
}
static int classify(const struct job *j, const struct record *v)
{
if (!record_valid(j, v)) {
return 3;
}
if (v->kind == 1) {
return 4;
}
if (v->kind == 2) {
return 5;
}
if (v->value < j->lower || v->value > j->upper) {
return 2;
}
return 1;
}
static void account_trend(struct channel *c, const struct record *v)
{
if (c->accepted == 0) {
c->first_tick = v->tick;
c->low_tick = v->tick;
c->high_tick = v->tick;
c->previous = v->value;
c->run = 1;
c->longest_run = 1;
return;
}
if (v->tick < c->low_tick) {
c->low_tick = v->tick;
}
if (v->tick > c->high_tick) {
c->high_tick = v->tick;
}
long long elapsed = (long long)v->tick - c->last_tick;
c->intervals += elapsed;
if (elapsed < 0) {
c->regressions += 1;
}
long long difference = (long long)v->value - c->previous;
if (difference > 0) {
c->rising += 1;
c->movement += difference;
c->run = 1;
} else if (difference < 0) {
c->falling += 1;
c->movement -= difference;
c->run = 1;
} else {
c->repeated += 1;
c->run += 1;
}
if (c->run > c->longest_run) {
c->longest_run = c->run;
}
c->previous = v->value;
}
static int format_channel(struct text *t, const struct job *j, int role, const struct channel *c)
{
text_reset(t);
if (text_word(t, "S") != 0) {
return -1;
}
if (text_field(t, j->serial) != 0) {
return -1;
}
if (text_field(t, role) != 0) {
return -1;
}
if (text_field(t, c->accepted) != 0) {
return -1;
}
if (text_field(t, c->sum) != 0) {
return -1;
}
if (text_field(t, c->movement) != 0) {
return -1;
}
if (text_field(t, c->regressions) != 0) {
return -1;
}
if (text_field(t, c->longest_run) != 0) {
return -1;
}
return text_end(t);
}
static void accept_sample(struct report *r, const struct record *v, int ordinal)
{
struct channel *c = &r->channels[v->channel];
account_trend(c, v);
if (c->accepted == 0) {
c->minimum = v->value;
c->maximum = v->value;
} else {
if (v->value < c->minimum) {
c->minimum = v->value;
}
if (v->value > c->maximum) {
c->maximum = v->value;
}
}
c->accepted += 1;
c->sum += v->value;
c->last_tick = v->tick;
r->accepted += 1;
r->sum += v->value;
unsigned term = (unsigned)(v->value + 32768);
term = term * 31u + (unsigned)v->tick;
term = term * 17u + (unsigned)v->channel;
term += (unsigned)ordinal;
r->checksum = (r->checksum + term) % 1000003u;
}
static void account(struct report *r, const struct record *v, int ordinal, int status)
{
switch (status) {
case 1:
accept_sample(r, v, ordinal);
break;
case 2:
r->filtered += 1;
r->channels[v->channel].filtered += 1;
break;
case 3:
r->invalid += 1;
break;
case 4:
r->notes += 1;
r->channels[v->channel].notes += 1;
break;
case 5:
r->barriers += 1;
break;
default:
break;
}
}
static struct text *reserve_line(struct plan *p, int role)
{
if (p->count >= PLAN_LIMIT) {
return NULL;
}
struct line *line = &p->lines[p->count];
line->role = role;
text_reset(&line->text);
p->count += 1;
return &line->text;
}
static int data_line(struct plan *p, const struct job *j, int ordinal, int status)
{
struct text *t = reserve_line(p, 0);
if (t == NULL) {
return -1;
}
if (status == 1) {
return format_data(t, j, ordinal, &j->rows[ordinal]);
}
return format_barrier(t, j, ordinal, j->rows[ordinal].tick);
}
static int audit_line(struct plan *p, const struct job *j, int ordinal, int status)
{
struct text *t = reserve_line(p, 1);
if (t == NULL) {
return -1;
}
return format_audit(t, j, ordinal, status);
}
static int index_line(struct plan *p, const struct job *j, int ordinal, size_t offset, size_t length)
{
struct text *t = reserve_line(p, 2);
if (t == NULL) {
return -1;
}
return format_index(t, j, ordinal, offset, length);
}
static int append_record(struct plan *p, const struct job *j, int ordinal, int status, size_t *offset)
{
size_t length = 0;
if (status == 1 || status == 5) {
if (data_line(p, j, ordinal, status) != 0) {
return -1;
}
length = p->lines[p->count - 1].text.length;
}
if (audit_line(p, j, ordinal, status) != 0) {
return -1;
}
if ((j->flags & 1) && length != 0) {
if (index_line(p, j, ordinal, *offset, length) != 0) {
return -1;
}
}
*offset += length;
return 0;
}
static int append_trailers(struct plan *p, const struct job *j, const struct report *r, size_t offset)
{
struct text *t = reserve_line(p, 0);
if (t == NULL || format_total(t, j, r) != 0) {
return -1;
}
offset += t->length;
t = reserve_line(p, 1);
if (t == NULL || format_end(t, j, 0, offset) != 0) {
return -1;
}
if (j->flags & 1) {
t = reserve_line(p, 2);
if (t == NULL || format_end(t, j, 1, offset) != 0) {
return -1;
}
}
return 0;
}
int build_plan(const struct job *j, struct plan *p, struct report *r)
{
reset_report(r);
memset(p, 0, sizeof(*p));
if (!configuration_valid(j)) {
r->error = 1;
return -1;
}
int statuses[ROW_LIMIT];
for (int i = 0; i < j->count; ++i) {
statuses[i] = classify(j, &j->rows[i]);
account(r, &j->rows[i], i, statuses[i]);
}
size_t offset = 0;
for (int i = 0; i < j->count; ++i) {
if (append_record(p, j, i, statuses[i], &offset) != 0) {
r->error = 2;
return -1;
}
}
for (int c = 0; c < j->channels; ++c) {
struct text *t = reserve_line(p, 1);
if (t == NULL || format_channel(t, j, c, &r->channels[c]) != 0) {
r->error = 2;
return -1;
}
}
if (append_trailers(p, j, r, offset) != 0) {
r->error = 2;
return -1;
}
for (int i = 0; i < p->count; ++i) {
int role = p->lines[i].role;
r->planned[role] += p->lines[i].text.length;
}
return 0;
}