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

2 lines
23 KiB
JSON

{"owner.c":"#include \"owner.h\"\n\n#include <stdlib.h>\n#include <string.h>\n\ntypedef struct PrivateAllocation {\n unsigned char *original;\n Owner *public_owner;\n size_t capacity;\n unsigned generation;\n int live;\n} PrivateAllocation;\n\n/* Only the fixed support owns the allocation address used by free. */\nstatic PrivateAllocation private_allocations[OWNER_SLOTS];\n\nstatic PrivateAllocation *record_for(const Owner *owner)\n{\n if (owner == NULL || owner->id >= OWNER_SLOTS) {\n return NULL;\n }\n PrivateAllocation *record = &private_allocations[owner->id];\n return record->public_owner == owner ? record : NULL;\n}\n\nstatic int valid_id(unsigned id)\n{\n return id < OWNER_SLOTS;\n}\n\nstatic int valid_capacity(size_t capacity)\n{\n return capacity >= 1 && capacity <= MAX_CAPACITY;\n}\n\nstatic void reset_slot(Owner *owner)\n{\n owner->original = NULL;\n owner->capacity = 0;\n owner->live = 0;\n}\n\nvoid owner_bank_init(OwnerBank *bank)\n{\n unsigned index;\n for (index = 0; index < OWNER_SLOTS; ++index) {\n if (private_allocations[index].live) {\n free(private_allocations[index].original);\n }\n memset(&private_allocations[index], 0, sizeof(private_allocations[index]));\n }\n memset(bank, 0, sizeof(*bank));\n for (index = 0; index < OWNER_SLOTS; ++index) {\n bank->slots[index].id = index;\n }\n}\n\nOwner *owner_lookup(OwnerBank *bank, unsigned id)\n{\n if (bank == NULL || !valid_id(id)) {\n return NULL;\n }\n return &bank->slots[id];\n}\n\nint owner_drop(OwnerBank *bank, unsigned id)\n{\n Owner *owner = owner_lookup(bank, id);\n PrivateAllocation *record;\n if (owner == NULL) {\n return 0;\n }\n record = &private_allocations[id];\n if (!record->live) {\n reset_slot(owner);\n return 0;\n }\n /* The allocator only receives the private original address. */\n free(record->original);\n record->original = NULL;\n record->capacity = 0;\n record->live = 0;\n reset_slot(owner);\n ++bank->drops;\n return 1;\n}\n\nint owner_open(OwnerBank *bank, unsigned id, size_t capacity)\n{\n unsigned char *fresh;\n Owner *owner = owner_lookup(bank, id);\n PrivateAllocation *record;\n if (owner == NULL || !valid_capacity(capacity)) {\n return 0;\n }\n fresh = malloc(capacity);\n if (fresh == NULL) {\n return 0;\n }\n memset(fresh, 0, capacity);\n record = &private_allocations[id];\n if (record->live) {\n owner_drop(bank, id);\n }\n record->original = fresh;\n record->public_owner = owner;\n record->capacity = capacity;\n record->live = 1;\n ++record->generation;\n owner->original = fresh;\n owner->capacity = capacity;\n owner->live = 1;\n owner->generation = record->generation;\n owner->id = id;\n ++bank->opens;\n return 1;\n}\n\nvoid owner_bank_finish(OwnerBank *bank)\n{\n unsigned index;\n if (bank == NULL) {\n return;\n }\n for (index = 0; index < OWNER_SLOTS; ++index) {\n owner_drop(bank, index);\n }\n}\n\nuintptr_t owner_address(const Owner *owner)\n{\n PrivateAllocation *record = record_for(owner);\n if (record == NULL || !record->live) {\n return 0;\n }\n return (uintptr_t)record->original;\n}\n\nint owner_integrity(const Owner *owner)\n{\n PrivateAllocation *record = record_for(owner);\n if (record == NULL || !record->live || !owner->live) {\n return 0;\n }\n return owner->original == record->original &&\n owner->capacity == record->capacity &&\n owner->generation == record->generation;\n}\n\nunsigned char *owner_live_pointer(const Owner *owner)\n{\n PrivateAllocation *record = record_for(owner);\n if (!owner_integrity(owner) || record == NULL) {\n return NULL;\n }\n return record->original;\n}\n\nsize_t owner_live_capacity(const Owner *owner)\n{\n PrivateAllocation *record = record_for(owner);\n if (!owner_integrity(owner) || record == NULL) {\n return 0;\n }\n return record->capacity;\n}\n\nsize_t owner_residue(const Owner *owner, size_t alignment)\n{\n if (alignment == 0 || owner == NULL || !owner->live) {\n return 0;\n }\n return (size_t)(owner_address(owner) % alignment);\n}\n\nint owner_range_inside(const Owner *owner, size_t offset, size_t span)\n{\n size_t capacity = owner_live_capacity(owner);\n if (capacity == 0) {\n return 0;\n }\n if (offset > capacity) {\n return 0;\n }\n return span <= capacity - offset;\n}\n\nint owner_pointer_inside(const Owner *owner, const unsigned char *address)\n{\n uintptr_t start;\n uintptr_t pointer;\n if (!owner_integrity(owner) || address == NULL) {\n return 0;\n }\n start = owner_address(owner);\n pointer = (uintptr_t)address;\n if (pointer < start) {\n return 0;\n }\n return pointer - start <= owner_live_capacity(owner);\n}\n","owner.h":"#ifndef OWNED_BUFFER_OWNER_H\n#define OWNED_BUFFER_OWNER_H\n\n#include <stddef.h>\n#include <stdint.h>\n\n#define OWNER_SLOTS 8\n#define MAX_CAPACITY 4096\n\ntypedef struct Owner {\n unsigned char *original;\n size_t capacity;\n unsigned generation;\n unsigned id;\n int live;\n} Owner;\n\ntypedef struct OwnerBank {\n Owner slots[OWNER_SLOTS];\n unsigned opens;\n unsigned drops;\n} OwnerBank;\n\nvoid owner_bank_init(OwnerBank *bank);\nint owner_open(OwnerBank *bank, unsigned id, size_t capacity);\nint owner_drop(OwnerBank *bank, unsigned id);\nvoid owner_bank_finish(OwnerBank *bank);\nOwner *owner_lookup(OwnerBank *bank, unsigned id);\nint owner_pointer_inside(const Owner *owner, const unsigned char *address);\nint owner_range_inside(const Owner *owner, size_t offset, size_t span);\nuintptr_t owner_address(const Owner *owner);\nsize_t owner_residue(const Owner *owner, size_t alignment);\nint owner_integrity(const Owner *owner);\nunsigned char *owner_live_pointer(const Owner *owner);\nsize_t owner_live_capacity(const Owner *owner);\n\n#endif\n","protocol.c":"#include \"protocol.h\"\n\n#include <stdint.h>\n#include <stdlib.h>\n#include <string.h>\n\nstatic int separator(char character)\n{\n return character == ' ' || character == '\\t';\n}\n\nstatic const char *skip_separator(const char *cursor)\n{\n while (separator(*cursor)) {\n ++cursor;\n }\n return cursor;\n}\n\nstatic const char *token_end(const char *cursor)\n{\n while (*cursor != '\\0' && *cursor != '\\n' && !separator(*cursor)) {\n ++cursor;\n }\n return cursor;\n}\n\nstatic int token_equals(const char *start, const char *end, const char *text)\n{\n size_t length = (size_t)(end - start);\n return strlen(text) == length && memcmp(start, text, length) == 0;\n}\n\nint parse_decimal(const char *first, const char *last, size_t *value)\n{\n size_t result = 0;\n const char *cursor = first;\n if (cursor < last && *cursor == '+') {\n ++cursor;\n }\n if (cursor == last) {\n return 0;\n }\n while (cursor < last) {\n unsigned digit;\n if (*cursor < '0' || *cursor > '9') {\n return 0;\n }\n digit = (unsigned)(*cursor - '0');\n if (result > (SIZE_MAX - digit) / 10) {\n return 0;\n }\n result = result * 10 + digit;\n ++cursor;\n }\n *value = result;\n return 1;\n}\n\nstatic int parse_field(const char **cursor, size_t *value)\n{\n const char *start = skip_separator(*cursor);\n const char *end = token_end(start);\n if (!parse_decimal(start, end, value)) {\n return 0;\n }\n *cursor = end;\n return 1;\n}\n\nstatic int at_end(const char *cursor)\n{\n cursor = skip_separator(cursor);\n return *cursor == '\\0' || (*cursor == '\\n' && cursor[1] == '\\0');\n}\n\nint parse_command(const char *line, Command *command)\n{\n const char *cursor = skip_separator(line);\n const char *end = token_end(cursor);\n size_t id;\n size_t first = 0;\n size_t second = 0;\n CommandKind kind = COMMAND_INVALID;\n memset(command, 0, sizeof(*command));\n if (token_equals(cursor, end, \"OPEN\")) {\n kind = COMMAND_OPEN;\n } else if (token_equals(cursor, end, \"PLAN\")) {\n kind = COMMAND_PLAN;\n } else if (token_equals(cursor, end, \"CHECK\")) {\n kind = COMMAND_CHECK;\n } else if (token_equals(cursor, end, \"DROP\")) {\n kind = COMMAND_DROP;\n } else if (token_equals(cursor, end, \"FILL\")) {\n kind = COMMAND_FILL;\n } else if (token_equals(cursor, end, \"PROBE\")) {\n kind = COMMAND_PROBE;\n } else if (token_equals(cursor, end, \"COPY\")) {\n kind = COMMAND_COPY;\n } else if (token_equals(cursor, end, \"RESET\")) {\n kind = COMMAND_RESET;\n }\n if (kind == COMMAND_INVALID) {\n return 0;\n }\n cursor = end;\n if (kind == COMMAND_RESET) {\n if (!at_end(cursor)) {\n return 0;\n }\n command->kind = kind;\n return 1;\n }\n if (!parse_field(&cursor, &id) || id >= 8) {\n return 0;\n }\n if (kind == COMMAND_OPEN) {\n if (!parse_field(&cursor, &first) || first < 1 || first > 4096) {\n return 0;\n }\n }\n if (kind == COMMAND_PLAN) {\n if (!parse_field(&cursor, &first) || first < 1 || first > 256) {\n return 0;\n }\n if (!parse_field(&cursor, &second) || second > 4096) {\n return 0;\n }\n }\n if (kind == COMMAND_FILL) {\n if (!parse_field(&cursor, &first) || first > 255) {\n return 0;\n }\n }\n if (kind == COMMAND_PROBE) {\n if (!parse_field(&cursor, &first) || first > 4096) {\n return 0;\n }\n }\n if (kind == COMMAND_COPY) {\n if (!parse_field(&cursor, &first) || first >= 8) {\n return 0;\n }\n if (!parse_field(&cursor, &second) || second > 4096) {\n return 0;\n }\n }\n if (!at_end(cursor)) {\n return 0;\n }\n command->kind = kind;\n command->id = (unsigned)id;\n command->first = first;\n command->second = second;\n return 1;\n}\n\nvoid reader_init(InputReader *reader, FILE *stream)\n{\n reader->stream = stream;\n reader->lines = 0;\n reader->exhausted = 0;\n reader->bytes = 0;\n reader->digest = 2166136261u;\n}\n\nstatic void record_byte(InputReader *reader, unsigned char byte)\n{\n ++reader->bytes;\n reader->digest ^= byte;\n reader->digest *= 16777619u;\n}\n\nint reader_next(InputReader *reader, Command *command)\n{\n char *line = NULL;\n size_t length = 0;\n size_t capacity = 0;\n int character;\n int malformed = 0;\n if (reader->exhausted || reader->lines >= MAX_COMMANDS) {\n reader->exhausted = 1;\n return 0;\n }\n while ((character = fgetc(reader->stream)) != EOF) {\n char *grown;\n if (length + 2 > capacity) {\n size_t target = capacity == 0 ? 64 : capacity * 2;\n if (target < capacity || target < length + 2) {\n free(line);\n command->kind = COMMAND_INVALID;\n return 1;\n }\n grown = realloc(line, target);\n if (grown == NULL) {\n free(line);\n command->kind = COMMAND_INVALID;\n return 1;\n }\n line = grown;\n capacity = target;\n }\n line[length++] = (char)character;\n record_byte(reader, (unsigned char)character);\n if (character != '\\n' && character != '\\t' &&\n (character < 32 || character > 126)) {\n malformed = 1;\n }\n if (character == '\\n') {\n break;\n }\n }\n if (length == 0 && character == EOF) {\n reader->exhausted = 1;\n free(line);\n return 0;\n }\n ++reader->lines;\n line[length] = '\\0';\n if (malformed || character != '\\n' || !parse_command(line, command)) {\n command->kind = COMMAND_INVALID;\n }\n free(line);\n return 1;\n}\n","protocol.h":"#ifndef OWNED_BUFFER_PROTOCOL_H\n#define OWNED_BUFFER_PROTOCOL_H\n\n#include <stddef.h>\n#include <stdio.h>\n\n#define MAX_LINE 256\n#define MAX_COMMANDS 512\n\ntypedef enum CommandKind {\n COMMAND_INVALID,\n COMMAND_OPEN,\n COMMAND_PLAN,\n COMMAND_CHECK,\n COMMAND_DROP,\n COMMAND_FILL,\n COMMAND_PROBE,\n COMMAND_COPY,\n COMMAND_RESET\n} CommandKind;\n\ntypedef struct Command {\n CommandKind kind;\n unsigned id;\n size_t first;\n size_t second;\n} Command;\n\ntypedef struct InputReader {\n FILE *stream;\n unsigned lines;\n int exhausted;\n unsigned long long bytes;\n unsigned digest;\n} InputReader;\n\nvoid reader_init(InputReader *reader, FILE *stream);\nint reader_next(InputReader *reader, Command *command);\nint parse_command(const char *line, Command *command);\nint parse_decimal(const char *first, const char *last, size_t *value);\n\n#endif\n","observer.c":"#include \"owner.h\"\n#include \"planner.h\"\n#include \"protocol.h\"\n\n#include <inttypes.h>\n#include <stdio.h>\n#include <string.h>\n\ntypedef struct Session {\n OwnerBank owners;\n View views[OWNER_SLOTS];\n unsigned view_present[OWNER_SLOTS];\n size_t view_alignment[OWNER_SLOTS];\n size_t view_requested[OWNER_SLOTS];\n unsigned char fill_seed[OWNER_SLOTS];\n unsigned lines;\n unsigned failures;\n} Session;\n\ntypedef struct ViewFacts {\n int owner_ok;\n int aligned;\n int in_bounds;\n int usable;\n} ViewFacts;\n\nstatic void session_init(Session *session)\n{\n unsigned index;\n memset(session, 0, sizeof(*session));\n owner_bank_init(&session->owners);\n for (index = 0; index < OWNER_SLOTS; ++index) {\n clear_view(&session->views[index]);\n }\n}\n\nstatic int exact_owner(const Owner *owner, const View *view)\n{\n if (owner == NULL || view == NULL || !owner_integrity(owner)) {\n return 0;\n }\n if (view->owner != owner) {\n return 0;\n }\n if (view->original != owner->original) {\n return 0;\n }\n if (view->original_capacity != owner->capacity) {\n return 0;\n }\n if (view->generation != owner->generation) {\n return 0;\n }\n return view->id == owner->id;\n}\n\nstatic int address_matches_offset(const Owner *owner, const View *view)\n{\n uintptr_t base;\n uintptr_t address;\n if (owner == NULL || view == NULL || !owner->live) {\n return 0;\n }\n if (!owner_range_inside(owner, view->offset, 0)) {\n return 0;\n }\n base = owner_address(owner);\n address = (uintptr_t)view->begin;\n if (address < base) {\n return 0;\n }\n return address - base == view->offset;\n}\n\nstatic int view_is_aligned(const Owner *owner, const View *view, size_t alignment)\n{\n uintptr_t base;\n if (alignment == 0 || !address_matches_offset(owner, view)) {\n return 0;\n }\n base = owner_address(owner);\n if (view->offset > UINTPTR_MAX - base) {\n return 0;\n }\n return (base + view->offset) % alignment == 0;\n}\n\nstatic ViewFacts inspect_view(const Owner *owner, const View *view,\n size_t alignment, size_t requested)\n{\n ViewFacts facts = {0, 0, 0, 0};\n if (owner == NULL || view == NULL || view->status != 0) {\n return facts;\n }\n facts.owner_ok = exact_owner(owner, view);\n facts.aligned = view_is_aligned(owner, view, alignment);\n facts.in_bounds = owner_range_inside(owner, view->offset, view->span);\n if (!address_matches_offset(owner, view)) {\n facts.in_bounds = 0;\n }\n facts.usable = facts.owner_ok && facts.aligned && facts.in_bounds\n && requested <= view->span;\n return facts;\n}\n\nstatic int saved_view_usable(Session *session, unsigned id)\n{\n Owner *owner;\n View *view;\n if (id >= OWNER_SLOTS || !session->view_present[id]) {\n return 0;\n }\n owner = owner_lookup(&session->owners, id);\n view = &session->views[id];\n if (!exact_owner(owner, view)) {\n return 0;\n }\n if (!owner_range_inside(owner, view->offset, view->span)) {\n return 0;\n }\n if (!view_is_aligned(owner, view, session->view_alignment[id])) {\n return 0;\n }\n if (session->view_requested[id] > view->span) {\n return 0;\n }\n return address_matches_offset(owner, view);\n}\n\nstatic unsigned char pattern_byte(unsigned seed, size_t index)\n{\n return (unsigned char)((seed + index * 17u) % 256u);\n}\n\nstatic void fill_owner(Owner *owner, unsigned seed)\n{\n size_t index;\n unsigned char *pointer = owner_live_pointer(owner);\n size_t capacity = owner_live_capacity(owner);\n for (index = 0; pointer != NULL && index < capacity; ++index) {\n pointer[index] = pattern_byte(seed, index);\n }\n}\n\nstatic unsigned checksum_bytes(const unsigned char *data, size_t count)\n{\n size_t index;\n unsigned accumulator = 0;\n for (index = 0; index < count; ++index) {\n accumulator = (accumulator * 33u + data[index]) % 65521u;\n }\n return accumulator;\n}\n\nstatic void handle_fill(Session *session, const Command *command)\n{\n Owner *owner = owner_lookup(&session->owners, command->id);\n if (owner == NULL || !owner_integrity(owner)) {\n printf(\"F %u 0\\n\", command->id);\n return;\n }\n fill_owner(owner, (unsigned)command->first);\n session->fill_seed[command->id] = (unsigned char)command->first;\n printf(\"F %u 1\\n\", command->id);\n}\n\nstatic void handle_probe(Session *session, const Command *command)\n{\n View *view = &session->views[command->id];\n if (!saved_view_usable(session, command->id)\n || command->first > view->span) {\n printf(\"T %u -1 0\\n\", command->id);\n return;\n }\n printf(\"T %u 0 %u\\n\", command->id,\n checksum_bytes(view->begin, command->first));\n}\n\nstatic int copy_allowed(Session *session, unsigned source_id,\n unsigned destination_id, size_t count)\n{\n Owner *destination = owner_lookup(&session->owners, destination_id);\n View *source = &session->views[source_id];\n if (!saved_view_usable(session, source_id)) {\n return 0;\n }\n if (destination == NULL || !owner_integrity(destination)) {\n return 0;\n }\n if (count > source->span || count > owner_live_capacity(destination)) {\n return 0;\n }\n return 1;\n}\n\nstatic void handle_copy(Session *session, const Command *command)\n{\n unsigned source_id = command->id;\n unsigned destination_id = (unsigned)command->first;\n size_t count = command->second;\n Owner *destination;\n View *source;\n if (!copy_allowed(session, source_id, destination_id, count)) {\n printf(\"X %u %u 0\\n\", source_id, destination_id);\n return;\n }\n destination = owner_lookup(&session->owners, destination_id);\n source = &session->views[source_id];\n memmove(owner_live_pointer(destination), source->begin, count);\n printf(\"X %u %u 1\\n\", source_id, destination_id);\n}\n\nstatic void handle_reset(Session *session)\n{\n unsigned index;\n unsigned released = 0;\n for (index = 0; index < OWNER_SLOTS; ++index) {\n if (owner_drop(&session->owners, index)) {\n ++released;\n }\n }\n printf(\"Z %u\\n\", released);\n}\n\nstatic void handle_open(Session *session, const Command *command)\n{\n Owner *owner;\n if (!owner_open(&session->owners, command->id, command->first)) {\n puts(\"E\");\n ++session->failures;\n return;\n }\n owner = owner_lookup(&session->owners, command->id);\n session->fill_seed[command->id] = 0;\n printf(\"O %u %zu %u\\n\", command->id, owner->capacity, owner->generation);\n}\n\nstatic void handle_plan(Session *session, const Command *command)\n{\n Owner *owner = owner_lookup(&session->owners, command->id);\n View *view = &session->views[command->id];\n ViewFacts facts;\n size_t residue = owner_residue(owner, command->first);\n int status;\n clear_view(view);\n session->view_present[command->id] = 0;\n status = plan_view(owner, command->first, command->second, view);\n session->view_alignment[command->id] = command->first;\n session->view_requested[command->id] = command->second;\n if (status != 0) {\n printf(\"P %u %zu -1 0 0 0 0 0 0\\n\", command->id, residue);\n return;\n }\n session->view_present[command->id] = 1;\n facts = inspect_view(owner, view, command->first, command->second);\n printf(\"P %u %zu 0 %zu %zu %d %d %d %d\\n\",\n command->id, residue, view->offset, view->span,\n facts.owner_ok, facts.aligned, facts.in_bounds, facts.usable);\n}\n\nstatic void handle_check(Session *session, const Command *command)\n{\n printf(\"C %u %d\\n\", command->id,\n saved_view_usable(session, command->id));\n}\n\nstatic void handle_drop(Session *session, const Command *command)\n{\n int released = owner_drop(&session->owners, command->id);\n printf(\"D %u %d\\n\", command->id, released);\n}\n\nstatic void handle_command(Session *session, const Command *command)\n{\n switch (command->kind) {\n case COMMAND_OPEN:\n handle_open(session, command);\n break;\n case COMMAND_PLAN:\n handle_plan(session, command);\n break;\n case COMMAND_CHECK:\n handle_check(session, command);\n break;\n case COMMAND_DROP:\n handle_drop(session, command);\n break;\n case COMMAND_FILL:\n handle_fill(session, command);\n break;\n case COMMAND_PROBE:\n handle_probe(session, command);\n break;\n case COMMAND_COPY:\n handle_copy(session, command);\n break;\n case COMMAND_RESET:\n handle_reset(session);\n break;\n default:\n puts(\"E\");\n ++session->failures;\n break;\n }\n}\n\nstatic int run_session(FILE *input)\n{\n Session session;\n InputReader reader;\n Command command;\n session_init(&session);\n reader_init(&reader, input);\n while (reader_next(&reader, &command)) {\n handle_command(&session, &command);\n ++session.lines;\n }\n printf(\"I %llu %u\\n\", reader.bytes, reader.digest);\n owner_bank_finish(&session.owners);\n if (ferror(input) || ferror(stdout)) {\n return 2;\n }\n return 0;\n}\n\nint main(void)\n{\n return run_session(stdin);\n}\n","planner.h":"#ifndef OWNED_BUFFER_PLANNER_H\n#define OWNED_BUFFER_PLANNER_H\n\n#include \"owner.h\"\n\ntypedef struct View {\n Owner *owner;\n unsigned char *original;\n unsigned char *begin;\n size_t original_capacity;\n size_t offset;\n size_t span;\n unsigned generation;\n unsigned id;\n int status;\n} View;\n\nint plan_view(Owner *owner, size_t alignment, size_t requested, View *view);\nvoid clear_view(View *view);\n\n#endif\n"}