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

184 lines
4.3 KiB
C

#include "queue.h"
static int job_valid(const queue_job *job)
{
if (job == NULL) {
return 0;
}
if (job->id == 0 || job->id > 65535) {
return 0;
}
if (job->value < -100000 || job->value > 100000) {
return 0;
}
return job->lane <= 3;
}
static unsigned position(const work_queue *queue, unsigned offset)
{
return (queue->head + offset) % queue->capacity;
}
int queue_init(work_queue *queue, unsigned capacity)
{
if (queue == NULL || capacity == 0 || capacity > QUEUE_LIMIT) {
return -1;
}
queue->head = 0;
queue->count = 0;
queue->capacity = capacity;
for (unsigned index = 0; index < QUEUE_LIMIT; ++index) {
queue->slots[index].id = 0;
queue->slots[index].value = 0;
queue->slots[index].lane = 0;
}
return 0;
}
int queue_valid(const work_queue *queue)
{
if (queue == NULL) {
return 0;
}
if (queue->capacity == 0 || queue->capacity > QUEUE_LIMIT) {
return 0;
}
if (queue->head >= queue->capacity || queue->count > queue->capacity) {
return 0;
}
for (unsigned index = 0; index < queue->count; ++index) {
const queue_job *job = &queue->slots[position(queue, index)];
if (!job_valid(job)) {
return 0;
}
for (unsigned earlier = 0; earlier < index; ++earlier) {
if (queue->slots[position(queue, earlier)].id == job->id) {
return 0;
}
}
}
return 1;
}
unsigned queue_count(const work_queue *queue)
{
return queue->count;
}
unsigned queue_capacity(const work_queue *queue)
{
return queue->capacity;
}
int queue_empty(const work_queue *queue)
{
return queue->count == 0;
}
int queue_full(const work_queue *queue)
{
return queue->count == queue->capacity;
}
int queue_contains(const work_queue *queue, unsigned id)
{
for (unsigned offset = 0; offset < queue->count; ++offset) {
unsigned index = position(queue, offset);
if (queue->slots[index].id == id) {
return 1;
}
}
return 0;
}
int queue_push(work_queue *queue, const queue_job *job)
{
if (!job_valid(job)) {
return -1;
}
if (queue_full(queue) || queue_contains(queue, job->id)) {
return -1;
}
unsigned index = position(queue, queue->count);
queue->slots[index] = *job;
queue->count += 1;
return 0;
}
int queue_at(const work_queue *queue, unsigned offset, queue_job *job)
{
if (job == NULL || offset >= queue->count) {
return -1;
}
*job = queue->slots[position(queue, offset)];
return 0;
}
int queue_front(const work_queue *queue, queue_job *job)
{
return queue_at(queue, 0, job);
}
int queue_pop(work_queue *queue, queue_job *job)
{
if (job == NULL || queue_empty(queue)) {
return -1;
}
*job = queue->slots[queue->head];
queue->slots[queue->head].id = 0;
queue->slots[queue->head].value = 0;
queue->slots[queue->head].lane = 0;
queue->head = (queue->head + 1) % queue->capacity;
queue->count -= 1;
if (queue_empty(queue)) {
queue->head = 0;
}
return 0;
}
int queue_remove(work_queue *queue, unsigned id, queue_job *job)
{
if (job == NULL) {
return -1;
}
unsigned offset = 0;
while (offset < queue->count) {
if (queue->slots[position(queue, offset)].id == id) {
break;
}
offset += 1;
}
if (offset == queue->count) {
return -1;
}
*job = queue->slots[position(queue, offset)];
for (unsigned next = offset + 1; next < queue->count; ++next) {
unsigned target = position(queue, next - 1);
unsigned source = position(queue, next);
queue->slots[target] = queue->slots[source];
}
unsigned tail = position(queue, queue->count - 1);
queue->slots[tail].id = 0;
queue->slots[tail].value = 0;
queue->slots[tail].lane = 0;
queue->count -= 1;
if (queue_empty(queue)) {
queue->head = 0;
}
return 0;
}
unsigned queue_clear(work_queue *queue)
{
unsigned removed = queue->count;
for (unsigned offset = 0; offset < removed; ++offset) {
unsigned index = position(queue, offset);
queue->slots[index].id = 0;
queue->slots[index].value = 0;
queue->slots[index].lane = 0;
}
queue->head = 0;
queue->count = 0;
return removed;
}