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

208 lines
5.4 KiB
C++

#include "stream.hpp"
#include <limits>
namespace captured {
namespace {
class Reader {
public:
explicit Reader(const Bytes& bytes) : bytes_(bytes), cursor_(4) {
}
std::size_t remaining() const {
return bytes_.size() - cursor_;
}
std::uint64_t integer() {
std::uint64_t value = 0;
for (unsigned shift = 0; shift < 64; shift += 8) {
const std::uint64_t byte = bytes_[cursor_];
value |= byte << shift;
++cursor_;
}
return value;
}
Bytes rest() {
Bytes value(bytes_.begin() + cursor_, bytes_.end());
cursor_ = bytes_.size();
return value;
}
private:
const Bytes& bytes_;
std::size_t cursor_;
};
class Writer {
public:
void integer(std::uint64_t value) {
for (unsigned shift = 0; shift < 64; shift += 8) {
bytes_.push_back(static_cast<std::uint8_t>((value >> shift) & 255));
}
}
void bytes(const Bytes& value) {
bytes_.insert(bytes_.end(), value.begin(), value.end());
}
Bytes take() {
return std::move(bytes_);
}
private:
Bytes bytes_;
};
Reply rejected(int status) {
Reply reply;
reply.status = status;
return reply;
}
Reply status_only(int status) {
return rejected(status);
}
Reply integer_reply(std::uint64_t value) {
Writer writer;
writer.integer(value);
Reply reply;
reply.payload = writer.take();
return reply;
}
Reply bytes_reply(const Result& result) {
if (result.status != 0) {
return rejected(result.status);
}
Writer writer;
writer.integer(result.count);
writer.bytes(result.data);
Reply reply;
reply.payload = writer.take();
return reply;
}
std::size_t argument_bytes(std::uint8_t opcode) {
switch (opcode) {
case 1:
case 2:
case 6:
case 7:
case 8:
case 9:
case 11:
return 8;
case 4:
return 16;
case 3:
case 10:
case 12:
case 13:
return 0;
default:
return 24;
}
}
}
Reply Device::packet(const Bytes& request) {
if (request.size() < 4 || request.size() > 131072) {
return rejected(-71);
}
if (request[0] != 'M' || request[1] != 'S' || request[2] != 1) {
return rejected(-71);
}
const std::uint8_t opcode = request[3];
if (opcode < 1 || opcode > 13) {
return rejected(-25);
}
Reader reader(request);
if (opcode == 5) {
if (reader.remaining() < 24) {
return rejected(-71);
}
const std::uint64_t id = reader.integer();
const std::uint64_t budget = reader.integer();
const std::uint64_t length = reader.integer();
if (length > 65535 || length != reader.remaining()) {
return rejected(-71);
}
const Bytes data = reader.rest();
const Result result = append(id, data, budget);
if (result.status != 0) {
return rejected(result.status);
}
return integer_reply(result.count);
}
if (reader.remaining() != argument_bytes(opcode)) {
return rejected(-71);
}
switch (opcode) {
case 1: {
const std::uint64_t cap = reader.integer();
return status_only(reset(cap));
}
case 2: {
const std::uint64_t mode = reader.integer();
if (mode > 2) {
return rejected(-22);
}
return status_only(set_mode(static_cast<std::int64_t>(mode)));
}
case 3:
return integer_reply(static_cast<std::uint64_t>(get_mode()));
case 4: {
const std::uint64_t id = reader.integer();
const std::uint64_t total = reader.integer();
return status_only(begin(id, total));
}
case 6: {
const std::uint64_t id = reader.integer();
return status_only(finish(id));
}
case 7: {
const std::uint64_t id = reader.integer();
return status_only(cancel(id));
}
case 8: {
const std::uint64_t count = reader.integer();
return bytes_reply(read(count));
}
case 9: {
const std::uint64_t count = reader.integer();
return bytes_reply(peek(count));
}
case 10: {
const Stats value = stats();
Writer writer;
writer.integer(value.accepted);
writer.integer(value.consumed);
writer.integer(value.completed);
writer.integer(value.canceled);
writer.integer(value.buffered);
writer.integer(value.active);
Reply reply;
reply.payload = writer.take();
return reply;
}
case 11: {
const std::uint64_t id = reader.integer();
const Snapshot value = inspect(id);
if (value.status != 0) {
return rejected(value.status);
}
Writer writer;
writer.integer(value.id);
writer.integer(value.total);
writer.integer(value.accepted);
writer.integer(value.remaining);
writer.integer(static_cast<std::uint64_t>(value.captured_mode));
Reply reply;
reply.payload = writer.take();
return reply;
}
case 12: {
const std::vector<std::uint64_t> ids = active_ids();
Writer writer;
writer.integer(ids.size());
for (std::uint64_t id : ids) {
writer.integer(id);
}
Reply reply;
reply.payload = writer.take();
return reply;
}
case 13:
return integer_reply(capacity());
default:
return rejected(-25);
}
}
}