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

222 lines
6.4 KiB
C++

#include "record.hpp"
#include "internal.hpp"
#include <map>
#include <utility>
namespace inline_record {
struct Store::Impl {
std::map<std::int64_t, detail::Record> records;
Totals ledger;
};
namespace {
Result failed(const char* error)
{
Result result;
result.error = error;
return result;
}
bool valid_id(std::int64_t id)
{
return id >= 0 && id <= 7;
}
bool valid_position(std::int64_t position)
{
return position >= 0 && position <= 64;
}
Result describe(const detail::Record& record)
{
Result result;
result.token = record.token();
result.count = static_cast<std::int64_t>(record.count());
result.tag = record.tag();
result.bytes = static_cast<std::int64_t>(record.size());
result.checksum = record.checksum();
return result;
}
}
Store::Store() : impl_(new Impl)
{
}
Store::~Store() = default;
Result Store::replace(std::int64_t id, std::int64_t n,
std::int64_t tag, std::int64_t budget)
{
if (!valid_id(id)) {
return failed("BAD_ID");
}
if (n < 0 || n > 64) {
return failed("BAD_SIZE");
}
if (tag < 0 || tag > 65535) {
return failed("BAD_TAG");
}
if (budget < 16 || budget > 272) {
return failed("BAD_BUDGET");
}
const std::int64_t required = 16 + n * 4;
if (budget < required) {
return failed("NOMEM");
}
if (n == 0) {
auto old = impl_->records.find(id);
if (old != impl_->records.end()) {
impl_->ledger.bytes -= static_cast<std::int64_t>(old->second.size());
impl_->records.erase(old);
++impl_->ledger.frees;
--impl_->ledger.live;
}
return Result{};
}
const std::uint32_t identity = static_cast<std::uint32_t>(impl_->ledger.next);
detail::Record fresh(identity, static_cast<std::uint16_t>(tag),
static_cast<std::size_t>(n));
auto old = impl_->records.find(id);
if (old != impl_->records.end()) {
impl_->ledger.bytes -= static_cast<std::int64_t>(old->second.size());
impl_->records.erase(old);
++impl_->ledger.frees;
--impl_->ledger.live;
}
impl_->records.emplace(id, std::move(fresh));
++impl_->ledger.allocations;
++impl_->ledger.live;
++impl_->ledger.next;
impl_->ledger.bytes += required;
return Result{};
}
Result Store::fill(std::int64_t id, std::int64_t start,
std::int64_t count, std::int64_t value)
{
if (!valid_id(id)) {
return failed("BAD_ID");
}
if (!valid_position(start)) {
return failed("BAD_START");
}
if (!valid_position(count)) {
return failed("BAD_COUNT");
}
if (value < -1000000 || value > 1000000) {
return failed("BAD_VALUE");
}
auto target = impl_->records.find(id);
if (target == impl_->records.end()) {
return failed("ABSENT");
}
const std::int64_t capacity = static_cast<std::int64_t>(target->second.count());
if (start > capacity || count > capacity - start) {
return failed("RANGE");
}
target->second.fill(static_cast<std::size_t>(start),
static_cast<std::size_t>(count),
static_cast<std::int32_t>(value));
return Result{};
}
Result Store::copy(std::int64_t dst, std::int64_t src,
std::int64_t from, std::int64_t to, std::int64_t count)
{
if (!valid_id(dst)) {
return failed("BAD_ID");
}
if (!valid_id(src)) {
return failed("BAD_SOURCE");
}
if (!valid_position(from)) {
return failed("BAD_FROM");
}
if (!valid_position(to)) {
return failed("BAD_TO");
}
if (!valid_position(count)) {
return failed("BAD_COUNT");
}
auto destination = impl_->records.find(dst);
auto source = impl_->records.find(src);
if (destination == impl_->records.end()) {
return failed("ABSENT");
}
if (source == impl_->records.end()) {
return failed("NO_SOURCE");
}
const std::int64_t source_count = static_cast<std::int64_t>(source->second.count());
const std::int64_t destination_count = static_cast<std::int64_t>(destination->second.count());
if (from > source_count || count > source_count - from) {
return failed("RANGE");
}
if (to > destination_count || count > destination_count - to) {
return failed("RANGE");
}
destination->second.copy_from(source->second, static_cast<std::size_t>(from),
static_cast<std::size_t>(to),
static_cast<std::size_t>(count));
return Result{};
}
Result Store::drop(std::int64_t id)
{
if (!valid_id(id)) {
return failed("BAD_ID");
}
auto found = impl_->records.find(id);
if (found == impl_->records.end()) {
return failed("ABSENT");
}
impl_->ledger.bytes -= static_cast<std::int64_t>(found->second.size());
impl_->records.erase(found);
++impl_->ledger.frees;
--impl_->ledger.live;
return Result{};
}
Result Store::info(std::int64_t id) const
{
if (!valid_id(id)) {
return failed("BAD_ID");
}
auto found = impl_->records.find(id);
if (found == impl_->records.end()) {
return failed("ABSENT");
}
return describe(found->second);
}
Result Store::get(std::int64_t id, std::int64_t index) const
{
if (!valid_id(id)) {
return failed("BAD_ID");
}
if (index < 0 || index > 63) {
return failed("BAD_INDEX");
}
auto found = impl_->records.find(id);
if (found == impl_->records.end()) {
return failed("ABSENT");
}
if (index >= static_cast<std::int64_t>(found->second.count())) {
return failed("RANGE");
}
Result result;
result.value = found->second.get(static_cast<std::size_t>(index));
return result;
}
Result Store::byte(std::int64_t id, std::int64_t offset) const
{
if (!valid_id(id)) {
return failed("BAD_ID");
}
if (offset < 0 || offset > 271) {
return failed("BAD_OFFSET");
}
auto found = impl_->records.find(id);
if (found == impl_->records.end()) {
return failed("ABSENT");
}
if (offset >= static_cast<std::int64_t>(found->second.size())) {
return failed("RANGE");
}
Result result;
result.value = found->second.byte(static_cast<std::size_t>(offset));
return result;
}
Totals Store::totals() const
{
return impl_->ledger;
}
}