amos 2f32624d3b Batch 18 (20261026-C-hwe-codegen-18): add 100 calibrated HWE code-gen tasks; pause production for rollout
100 tasks from the HWE arm-linux code-gen pool (outside the lk/man/pth
range given to batch 22), each with at least one independent
contract-edge defect and plain public docs. Claude reviewed 100/100
USABLE against current digests; no ID or source overlap with main or
batch 22. Difficulty is unmeasured.

progress.md records the wrap-up: all Codex sessions and Qwen schedulers
stopped for the user's rollout, Qwen results so far (57 HARD of 373),
and what is left on each batch branch.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-27 17:52:13 +08:00

413 lines
12 KiB
C++

#include "registry.hpp"
#include <array>
#include <utility>
namespace named {
namespace {
constexpr std::int64_t balance_limit = 1000000000;
constexpr std::int64_t delta_limit = 100000;
constexpr std::int64_t permit_limit = 8;
bool within(std::int64_t value, std::int64_t low, std::int64_t high) {
return value >= low && value <= high;
}
bool proper_name(const std::string& name) {
if (name.empty() || name.size() > 12) {
return false;
}
if (name.front() < 'a' || name.front() > 'z') {
return false;
}
for (char character : name) {
bool letter = character >= 'a' && character <= 'z';
bool digit = character >= '0' && character <= '9';
if (!letter && !digit && character != '_') {
return false;
}
}
return true;
}
struct Object {
bool used = false;
bool linked = false;
std::string name;
std::int64_t identity = 0;
std::int64_t permits = 0;
std::int64_t balance = 0;
std::int64_t handles = 0;
std::int64_t leases = 0;
std::int64_t commits = 0;
};
struct Transaction {
bool active = false;
std::int64_t handle = -1;
int object = -1;
std::int64_t pending = 0;
};
}
const char* spelling(Code code) {
switch (code) {
case Code::OK: return "OK";
case Code::RANGE: return "RANGE";
case Code::NAME: return "NAME";
case Code::BUSY: return "BUSY";
case Code::MISSING: return "MISSING";
case Code::EXISTS: return "EXISTS";
case Code::FULL: return "FULL";
case Code::WAIT: return "WAIT";
}
return "RANGE";
}
struct Registry::Impl {
std::array<Object, 8> objects{};
std::array<int, 16> handles{};
std::array<Transaction, 8> transactions{};
std::int64_t next = 1;
Impl() {
handles.fill(-1);
}
int lookup(const std::string& name) const {
for (int index = 0; index < 8; ++index) {
const auto& object = objects[index];
if (object.used && object.name == name) {
return index;
}
}
return -1;
}
int available() const {
for (int index = 0; index < 8; ++index) {
if (!objects[index].used) {
return index;
}
}
return -1;
}
Code handle_code(std::int64_t handle) const {
if (!within(handle, 0, 15)) {
return Code::RANGE;
}
if (handles[handle] == -1) {
return Code::MISSING;
}
return Code::OK;
}
Object& object_at(std::int64_t handle) {
return objects[handles[handle]];
}
const Object& object_at(std::int64_t handle) const {
return objects[handles[handle]];
}
void collect(int index) {
auto& object = objects[index];
if (!object.linked && object.handles == 0) {
object = Object{};
}
}
void return_permit(Transaction& transaction) {
auto& object = objects[transaction.object];
object.permits += 1;
object.leases -= 1;
transaction = Transaction{};
}
};
Registry::Registry() : impl(new Impl) {
}
Registry::~Registry() = default;
Code Registry::fresh() {
impl.reset(new Impl);
return Code::OK;
}
Code Registry::open(std::int64_t handle, const std::string& name,
std::int64_t mode, std::int64_t initial) {
if (!within(handle, 0, 15)) {
return Code::RANGE;
}
if (!within(mode, 0, 2)) {
return Code::RANGE;
}
if (!within(initial, 0, permit_limit)) {
return Code::RANGE;
}
if (!proper_name(name)) {
return Code::NAME;
}
if (impl->handles[handle] != -1) {
return Code::BUSY;
}
int index = impl->lookup(name);
if (index != -1 && mode == 2) {
return Code::EXISTS;
}
if (index == -1 && mode == 0) {
return Code::MISSING;
}
if (index == -1) {
index = impl->available();
if (index == -1) {
return Code::FULL;
}
Object object;
object.used = true;
object.linked = true;
object.name = name;
object.identity = impl->next;
object.permits = initial;
impl->objects[index] = std::move(object);
impl->next += 1;
}
impl->handles[handle] = index;
impl->objects[index].handles += 1;
return Code::OK;
}
Code Registry::close(std::int64_t handle) {
Code code = impl->handle_code(handle);
if (code != Code::OK) {
return code;
}
for (const auto& transaction : impl->transactions) {
if (transaction.active && transaction.handle == handle) {
return Code::BUSY;
}
}
int index = impl->handles[handle];
impl->handles[handle] = -1;
impl->objects[index].handles -= 1;
impl->collect(index);
return Code::OK;
}
Code Registry::unlink(const std::string& name) {
if (!proper_name(name)) {
return Code::NAME;
}
int index = impl->lookup(name);
if (index == -1) {
return Code::MISSING;
}
impl->objects[index].linked = false;
impl->collect(index);
return Code::OK;
}
Code Registry::duplicate(std::int64_t source, std::int64_t target) {
if (!within(source, 0, 15) || !within(target, 0, 15)) {
return Code::RANGE;
}
Code code = impl->handle_code(source);
if (code != Code::OK) {
return code;
}
if (impl->handles[target] != -1) {
return Code::BUSY;
}
int index = impl->handles[source];
impl->handles[target] = index;
impl->objects[index].handles += 1;
return Code::OK;
}
Code Registry::wait(std::int64_t handle, std::int64_t count) {
if (!within(handle, 0, 15) || !within(count, 0, permit_limit)) {
return Code::RANGE;
}
Code code = impl->handle_code(handle);
if (code != Code::OK) {
return code;
}
auto& object = impl->object_at(handle);
if (object.permits < count) {
return Code::WAIT;
}
object.permits -= count;
return Code::OK;
}
Code Registry::post(std::int64_t handle, std::int64_t count) {
if (!within(handle, 0, 15) || !within(count, 0, permit_limit)) {
return Code::RANGE;
}
Code code = impl->handle_code(handle);
if (code != Code::OK) {
return code;
}
auto& object = impl->object_at(handle);
if (object.permits + object.leases + count > permit_limit) {
return Code::RANGE;
}
object.permits += count;
return Code::OK;
}
Code Registry::write(std::int64_t handle, std::int64_t value) {
if (!within(handle, 0, 15) || !within(value, -balance_limit, balance_limit)) {
return Code::RANGE;
}
Code code = impl->handle_code(handle);
if (code != Code::OK) {
return code;
}
auto& object = impl->object_at(handle);
if (object.leases != 0) {
return Code::BUSY;
}
object.balance = value;
return Code::OK;
}
Code Registry::move(std::int64_t source, std::int64_t target, std::int64_t count) {
if (!within(source, 0, 15)) {
return Code::RANGE;
}
if (!within(target, 0, 15)) {
return Code::RANGE;
}
if (!within(count, 0, permit_limit)) {
return Code::RANGE;
}
Code code = impl->handle_code(source);
if (code != Code::OK) {
return code;
}
code = impl->handle_code(target);
if (code != Code::OK) {
return code;
}
if (impl->handles[source] == impl->handles[target]) {
return Code::OK;
}
auto& origin = impl->object_at(source);
auto& destination = impl->object_at(target);
if (origin.permits < count) {
return Code::WAIT;
}
if (destination.permits + destination.leases + count > permit_limit) {
return Code::RANGE;
}
origin.permits -= count;
destination.permits += count;
return Code::OK;
}
Code Registry::begin(std::int64_t actor, std::int64_t handle) {
if (!within(actor, 0, 7) || !within(handle, 0, 15)) {
return Code::RANGE;
}
auto& transaction = impl->transactions[actor];
if (transaction.active) {
return Code::BUSY;
}
Code code = impl->handle_code(handle);
if (code != Code::OK) {
return code;
}
auto& object = impl->object_at(handle);
if (object.permits == 0) {
return Code::WAIT;
}
transaction.active = true;
transaction.handle = handle;
transaction.object = impl->handles[handle];
transaction.pending = 0;
object.permits -= 1;
object.leases += 1;
return Code::OK;
}
Code Registry::stage(std::int64_t actor, std::int64_t delta) {
if (!within(actor, 0, 7) || !within(delta, -delta_limit, delta_limit)) {
return Code::RANGE;
}
auto& transaction = impl->transactions[actor];
if (!transaction.active) {
return Code::MISSING;
}
std::int64_t pending = transaction.pending + delta;
if (!within(pending, -balance_limit, balance_limit)) {
return Code::RANGE;
}
transaction.pending = pending;
return Code::OK;
}
Code Registry::commit(std::int64_t actor) {
if (!within(actor, 0, 7)) {
return Code::RANGE;
}
auto& transaction = impl->transactions[actor];
if (!transaction.active) {
return Code::MISSING;
}
auto& object = impl->objects[transaction.object];
std::int64_t balance = object.balance + transaction.pending;
if (!within(balance, -balance_limit, balance_limit)) {
return Code::RANGE;
}
object.balance = balance;
object.commits += 1;
impl->return_permit(transaction);
return Code::OK;
}
Code Registry::cancel(std::int64_t actor) {
if (!within(actor, 0, 7)) {
return Code::RANGE;
}
auto& transaction = impl->transactions[actor];
if (!transaction.active) {
return Code::MISSING;
}
impl->return_permit(transaction);
return Code::OK;
}
Code Registry::info(std::int64_t handle, ObjectInfo& result) const {
Code code = impl->handle_code(handle);
if (code != Code::OK) {
return code;
}
const auto& object = impl->object_at(handle);
result.identity = object.identity;
result.permits = object.permits;
result.balance = object.balance;
result.handles = object.handles;
result.linked = object.linked ? 1 : 0;
result.leases = object.leases;
result.commits = object.commits;
return Code::OK;
}
Code Registry::lease(std::int64_t actor, LeaseInfo& result) const {
if (!within(actor, 0, 7)) {
return Code::RANGE;
}
const auto& transaction = impl->transactions[actor];
result = LeaseInfo{};
if (transaction.active) {
result.active = 1;
result.handle = transaction.handle;
result.identity = impl->objects[transaction.object].identity;
result.pending = transaction.pending;
}
return Code::OK;
}
Code Registry::named(const std::string& name, ObjectInfo& result) const {
if (!proper_name(name)) {
return Code::NAME;
}
int index = impl->lookup(name);
if (index == -1) {
return Code::MISSING;
}
const auto& object = impl->objects[index];
result.identity = object.identity;
result.permits = object.permits;
result.balance = object.balance;
result.handles = object.handles;
result.linked = object.linked ? 1 : 0;
result.leases = object.leases;
result.commits = object.commits;
return Code::OK;
}
Statistics Registry::stats() const {
Statistics result;
result.next_identity = impl->next;
for (const auto& object : impl->objects) {
if (object.used) {
result.objects += 1;
result.names += object.linked ? 1 : 0;
result.handles += object.handles;
result.active += object.leases;
}
}
return result;
}
}