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>
184 lines
4.3 KiB
C
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;
|
|
}
|