dsh-eval-guard 0.2.2 → 0.3.0

package/eval/arena/tank/workspace/judge/cycles.hpp

@@ -0,0 +1,53 @@
+// cycles.hpp —— 裁判这一侧测定"1 CPU 毫秒是多少个读数单位"。
+//
+// Windows 上 CPU 用量的读数是周期数（TSC 的计数），每台机器每毫秒多少周期不一样，
+// 所以裁判测定一次，在开局时告诉 bot，两边用同一个数。测定的办法，按先后：
+//   1. 环境变量 TANK_CYCLES_PER_MS（正式赛想钉死一个数时用）；
+//   2. CPUID 的 0x15 号功能给出的 TSC 标称频率（较新的 Intel 处理器有，是精确值，各进程读到的完全相同）；
+//   3. 用 rdtsc 对着系统的高精度时钟数 250 毫秒，结果四舍五入到 0.1 MHz（各进程测出来的基本落在同一个数上）。
+// 其他系统上 CPU 用量的读数直接是纳秒，固定为 1000000。
+#pragma once
+
+#include <chrono>
+#include <cstdlib>
+
+#if defined(_WIN32) && (defined(__x86_64__) || defined(__i386__))
+#include <cpuid.h>
+#include <x86intrin.h>
+#endif
+
+namespace cycles {
+
+struct Scale {
+    long long per_ms = 1000000;    // 每 CPU 毫秒多少个读数单位
+    const char* source = "ns";     // 怎么得到的：env / cpuid / measured / ns
+};
+
+inline Scale measure() {
+    Scale out;
+#if defined(_WIN32)
+    if (const char* text = std::getenv("TANK_CYCLES_PER_MS")) {
+        const long long v = std::atoll(text);
+        if (v > 0) return Scale{v, "env"};
+    }
+#if defined(__x86_64__) || defined(__i386__)
+    unsigned a = 0, b = 0, c = 0, d = 0;
+    if (__get_cpuid_max(0, nullptr) >= 0x15 && __get_cpuid(0x15, &a, &b, &c, &d) && a && b && c) {
+        const unsigned long long hz = (unsigned long long)c * b / a;
+        if (hz > 100000000ULL) return Scale{(long long)(hz / 1000), "cpuid"};
+    }
+    using clock = std::chrono::steady_clock;
+    const auto t0 = clock::now();
+    const unsigned long long c0 = __rdtsc();
+    auto t1 = t0;
+    while (std::chrono::duration<double>(t1 - t0).count() < 0.25) t1 = clock::now();
+    const unsigned long long c1 = __rdtsc();
+    const double per_ms = double(c1 - c0) / std::chrono::duration<double, std::milli>(t1 - t0).count();
+    out.per_ms = (long long)(per_ms / 100.0 + 0.5) * 100;    // 0.1 MHz = 每毫秒 100 个周期
+    out.source = "measured";
+#endif
+#endif
+    return out;
+}
+
+}  // namespace cycles

package/eval/arena/tank/workspace/judge/fast.cpp

@@ -0,0 +1,337 @@
+// fast.cpp —— 快速模式的对局程序：把两个 bot（各编成一个动态库）装进同一个进程直接互相调用。
+//
+// 用法：fast <A 的动态库> <B 的动态库> [--log] [--hang 秒数] [--wall]
+// 标准输入每行一局："<编号> <种子> <风格> <换边>"，换边为 0 时 A 坐 0 号位，为 1 时 A 坐 1 号位。
+// 标准输出每局：
+//     B <编号>                      开始这一局（先打出来，进程中途死掉时知道死在哪一局）
+//     O <回合> <0 号方命令>|<1 号方命令>     只有 --log 时：这一回合实际执行的命令
+//     F <回合> <座位> <原因>         这一回合该座位的输出不合法（三辆都不动，记一次失败）
+//     FINAL + 回合段文本             只有 --log 时：终局局面
+//     G <编号> <种子> <风格> <换边> <回合数> <胜方座位> <原因> <签名> <A 的用量> <B 的用量>
+//         用量 = 首回合毫秒:其余回合平均:其余回合最慢:超预算的回合数:不合法的回合数
+// 出事时打一行 "X <编号> <哪一方：A/B/?> <说明>" 然后退出（退出码 3）。
+//
+// 和正式模式的对应关系（这几条保证不依赖时间的 bot 两种模式打出同样的对局）：
+//   - 地图：同一个 tank::make_game(种子, 风格)。
+//   - 调用顺序：每个 bot 先 init 一次，之后每回合 decide 一次；传进去的是同一个局面。
+//   - bot 返回的命令先写成文本再按协议解析（和正式模式走同一个 parse_orders），不合法就三辆都不动、
+//     记一次失败；连续 3 次判负，对局在那一回合结束、不再结算。
+//   - 每局开始前把两个动态库卸掉重新加载，全局变量、静态变量都回到初始。
+//   - 预算只统计、不判罚；崩溃不隔离。
+//   - 预算的统计：每次调用 bot 前后读本线程的 CPU 用量（Windows 上是 QueryThreadCycleTime），
+//     所以只算到调用 bot 的这个线程；--wall 时改用墙上时钟。
+
+#include "../tank.hpp"
+#include "cycles.hpp"
+
+#include <atomic>
+#include <chrono>
+#include <csignal>
+#include <cstdio>
+#include <cstdlib>
+#include <cstring>
+#include <string>
+#include <thread>
+
+#ifdef _WIN32
+#include <fcntl.h>
+#include <io.h>
+#include <windows.h>
+#else
+#include <dlfcn.h>
+#include <unistd.h>
+#endif
+
+namespace {
+
+const int MAX_STRIKES = 3;    // 与 core.py 的 MAX_STRIKES 相同
+
+using AbiFn = int (*)(int*, const char**);
+using SetupFn = int (*)(int, double);
+using InitFn = int (*)(const tank::State*, int, double*, char*, int);
+using DecideFn = int (*)(const tank::State*, int, tank::Orders*, double*, char*, int);
+
+struct Lib {
+    const char* path = nullptr;
+    void* handle = nullptr;
+    InitFn init = nullptr;
+    DecideFn decide = nullptr;
+};
+
+int g_budget_kind = tank::BUDGET_CPU;       // 让 bot 用哪把尺
+double g_per_ms = 1;                        // 每 CPU 毫秒多少个读数单位
+std::FILE* g_out = nullptr;                 // 结果输出（原来的标准输出）
+long long g_game = -1;                      // 正在打的那一局的编号
+std::atomic<int> g_inside{-1};              // 正在哪个 bot 的代码里：0 = A，1 = B，-1 = 都不在
+std::atomic<unsigned long long> g_calls{0}; // 调用计数，给看门狗判断有没有进展
+const char WHO[] = "AB";
+
+// 出事时的最后一行。只用最朴素的写法，因为可能是在崩溃处理里。
+[[noreturn]] void die(const char* what) {
+    const int who = g_inside.load();
+    char line[600];
+    const int n = std::snprintf(line, sizeof line, "X %lld %c %s\n", g_game, who < 0 ? '?' : WHO[who], what);
+    if (g_out) {
+        std::fflush(g_out);
+#ifdef _WIN32
+        _write(_fileno(g_out), line, unsigned(n));
+#else
+        if (write(fileno(g_out), line, size_t(n)) < 0) {}
+#endif
+    }
+    std::_Exit(3);
+}
+
+void on_signal(int sig) {
+    char what[64];
+    std::snprintf(what, sizeof what, "%s", sig == SIGABRT ? "程序中止（abort / 未接住的异常 / 断言失败）"
+                                         : sig == SIGFPE ? "算术错误（比如除以零）"
+                                         : sig == SIGSEGV ? "非法内存访问" : "非法指令");
+    die(what);
+}
+
+#ifdef _WIN32
+LONG WINAPI on_seh(EXCEPTION_POINTERS* info) {
+    const DWORD code = info->ExceptionRecord->ExceptionCode;
+    char what[96];
+    const char* name = code == EXCEPTION_ACCESS_VIOLATION ? "非法内存访问"
+                       : code == EXCEPTION_STACK_OVERFLOW ? "栈溢出（递归太深）"
+                       : code == EXCEPTION_INT_DIVIDE_BY_ZERO ? "除以零"
+                       : code == EXCEPTION_ILLEGAL_INSTRUCTION ? "非法指令" : "崩溃";
+    std::snprintf(what, sizeof what, "%s（异常代码 0x%08lX）", name, static_cast<unsigned long>(code));
+    die(what);
+}
+#endif
+
+void on_exit_inside() {
+    // bot 自己调了 exit()：正常跑完时 g_inside 是 -1，不会走到这里面。
+    if (g_inside.load() >= 0) die("bot 调用了 exit()");
+}
+
+void* lib_open(const char* path) {
+#ifdef _WIN32
+    return static_cast<void*>(LoadLibraryA(path));
+#else
+    return dlopen(path, RTLD_NOW | RTLD_LOCAL);
+#endif
+}
+void lib_close(void* h) {
+#ifdef _WIN32
+    FreeLibrary(static_cast<HMODULE>(h));
+#else
+    dlclose(h);
+#endif
+}
+void* lib_symbol(void* h, const char* name) {
+#ifdef _WIN32
+    return reinterpret_cast<void*>(GetProcAddress(static_cast<HMODULE>(h), name));
+#else
+    return dlsym(h, name);
+#endif
+}
+
+// 重新加载：卸掉再装，库里的全局变量、静态变量全部重新初始化。
+void reload(Lib& lib, int who) {
+    g_inside = who;    // 全局对象的构造和析构也是 bot 的代码
+    if (lib.handle) {
+        lib_close(lib.handle);
+#ifdef _WIN32
+        if (GetModuleHandleA(lib.path)) die("动态库卸不掉（bot 可能留着后台线程），全局状态没法重置");
+#endif
+    }
+    lib.handle = lib_open(lib.path);
+    if (!lib.handle) die("动态库加载失败");
+    const AbiFn abi = reinterpret_cast<AbiFn>(lib_symbol(lib.handle, "tankbot_abi"));
+    lib.init = reinterpret_cast<InitFn>(lib_symbol(lib.handle, "tankbot_init"));
+    lib.decide = reinterpret_cast<DecideFn>(lib_symbol(lib.handle, "tankbot_decide"));
+    int size = 0;
+    const char* version = "";
+    if (!abi || !lib.init || !lib.decide || abi(&size, &version) != 1 || size != int(sizeof(tank::State)) ||
+        std::strcmp(version, tank::ENGINE_VERSION) != 0)
+        die("动态库和对局程序不是同一份 tank.hpp 编出来的");
+    const SetupFn setup = reinterpret_cast<SetupFn>(lib_symbol(lib.handle, "tankbot_setup"));
+    if (!setup) die("动态库和对局程序不是同一份主循环编出来的");
+    setup(g_budget_kind, g_per_ms);
+    g_inside = -1;
+}
+
+// CRC-32（和 Python 的 zlib.crc32 相同），用来给对局算签名。
+uint32_t crc32_of(const std::string& text) {
+    static uint32_t table[256];
+    static bool ready = false;
+    if (!ready) {
+        for (uint32_t i = 0; i < 256; ++i) {
+            uint32_t c = i;
+            for (int k = 0; k < 8; ++k) c = (c & 1) ? 0xEDB88320u ^ (c >> 1) : c >> 1;
+            table[i] = c;
+        }
+        ready = true;
+    }
+    uint32_t c = 0xFFFFFFFFu;
+    for (const unsigned char ch : text) c = table[(c ^ ch) & 0xFF] ^ (c >> 8);
+    return c ^ 0xFFFFFFFFu;
+}
+
+struct Usage {
+    double first = 0, total = 0, slowest = 0;
+    int turns = 0, over = 0, illegal = 0;
+    void add(double ms, bool first_turn) {
+        if (first_turn) {
+            first = ms;
+            over += ms > tank::BUDGET_FIRST_MS;
+        } else {
+            total += ms;
+            turns += 1;
+            if (ms > slowest) slowest = ms;
+            over += ms > tank::BUDGET_TURN_MS;
+        }
+    }
+};
+
+std::string three(const tank::Orders& o) {
+    return tank::cmd_text(o.cmd[0]) + " " + tank::cmd_text(o.cmd[1]) + " " + tank::cmd_text(o.cmd[2]);
+}
+
+void play(Lib* libs, long long id, unsigned long long seed, int style, int swap, bool log) {
+    g_game = id;
+    std::fprintf(g_out, "B %lld\n", id);
+    std::fflush(g_out);
+    reload(libs[0], 0);
+    reload(libs[1], 1);
+
+    tank::State s = tank::make_game(seed, style);
+    const int bot_at[2] = {swap ? 1 : 0, swap ? 0 : 1};    // bot_at[座位] = 0（A）或 1（B）
+    Usage usage[2];                                        // 按 bot（A、B）记
+    int strikes[2] = {0, 0};                               // 按座位记
+    bool dead[2] = {false, false};
+    double used = 0;
+    char err[400];
+    std::string orders_log;
+
+    for (int seat = 0; seat < 2; ++seat) {
+        const int who = bot_at[seat];
+        g_inside = who;
+        g_calls++;
+        if (libs[who].init(&s, seat, &used, err, int(sizeof err))) die((std::string("init 抛出异常：") + err).c_str());
+        g_inside = -1;
+    }
+    while (!s.done) {
+        tank::Orders applied[2];
+        for (int seat = 0; seat < 2; ++seat) {
+            const int who = bot_at[seat];
+            tank::Orders raw;
+            g_inside = who;
+            g_calls++;
+            if (libs[who].decide(&s, seat, &raw, &used, err, int(sizeof err)))
+                die((std::string("decide 抛出异常：") + err).c_str());
+            g_inside = -1;
+            usage[who].add(used, s.turn == 0);    // 首回合的用量含 init
+            // 和正式模式一样：写成一行文本，再按协议解析。
+            std::string why;
+            if (tank::parse_orders(tank::orders_text(s, raw), s, applied[seat], &why)) {
+                strikes[seat] = 0;
+            } else {
+                applied[seat] = tank::Orders{};
+                usage[who].illegal += 1;
+                std::fprintf(g_out, "F %d %d %s\n", s.turn + 1, seat, why.c_str());
+                if (++strikes[seat] >= MAX_STRIKES) dead[seat] = true;
+            }
+        }
+        if (dead[0] || dead[1]) break;    // 判负的那一回合不结算
+        const std::string line = three(applied[0]) + "|" + three(applied[1]) + "\n";
+        orders_log += line;
+        if (log) std::fprintf(g_out, "O %d %s", s.turn + 1, line.c_str());
+        tank::step(s, applied[0], applied[1]);
+    }
+
+    int win = s.winner;
+    std::string reason = tank::reason_text(s);
+    std::string tail = tank::turn_text(s);
+    if (dead[0] || dead[1]) {
+        win = dead[0] && dead[1] ? -1 : (dead[0] ? 1 : 0);
+        reason = "fault";
+        tail += std::string("FAULT ") + (dead[0] ? "1" : "0") + (dead[1] ? "1" : "0") + "\n";
+    }
+    if (log) std::fprintf(g_out, "FINAL\n%s", tank::turn_text(s).c_str());
+    std::fprintf(g_out, "G %lld %llu %d %d %d %d %s %08x%08x", id, seed, style, swap, int(s.turn), win, reason.c_str(),
+                 crc32_of(orders_log), crc32_of(tail));
+    for (const Usage& u : usage)
+        std::fprintf(g_out, " %.3f:%.4f:%.3f:%d:%d", u.first, u.turns ? u.total / u.turns : 0.0, u.slowest, u.over, u.illegal);
+    std::fprintf(g_out, "\n");
+    std::fflush(g_out);
+}
+
+}  // namespace
+
+int main(int argc, char** argv) {
+    bool log = false;
+    double hang_seconds = 20;
+    const char* paths[2] = {nullptr, nullptr};
+    int n_paths = 0;
+    for (int k = 1; k < argc; ++k) {
+        if (!std::strcmp(argv[k], "--log")) log = true;
+        else if (!std::strcmp(argv[k], "--wall")) g_budget_kind = tank::BUDGET_WALL;
+        else if (!std::strcmp(argv[k], "--hang") && k + 1 < argc) hang_seconds = std::atof(argv[++k]);
+        else if (n_paths < 2) paths[n_paths++] = argv[k];
+    }
+    if (n_paths != 2) {
+        std::fprintf(stderr, "用法：fast <A 的动态库> <B 的动态库> [--log] [--hang 秒数] [--wall]\n");
+        return 2;
+    }
+    g_per_ms = double(cycles::measure().per_ms);
+
+    // 结果单独留一个句柄，再把标准输出并到标准错误上：bot 往标准输出打的东西不会混进结果里。
+    std::fflush(stdout);
+#ifdef _WIN32
+    SetErrorMode(SEM_FAILCRITICALERRORS | SEM_NOGPFAULTERRORBOX | SEM_NOOPENFILEERRORBOX);
+    const int fd = _dup(1);
+    _dup2(2, 1);
+    g_out = _fdopen(fd, "wb");
+    ULONG guarantee = 64 * 1024;
+    SetThreadStackGuarantee(&guarantee);    // 栈溢出时给崩溃处理留一点栈
+    SetUnhandledExceptionFilter(on_seh);
+#else
+    const int fd = dup(1);
+    dup2(2, 1);
+    g_out = fdopen(fd, "w");
+#endif
+    std::setvbuf(stdout, nullptr, _IONBF, 0);
+    if (!g_out) return 2;
+    for (const int sig : {SIGABRT, SIGFPE, SIGSEGV, SIGILL}) std::signal(sig, on_signal);
+    std::atexit(on_exit_inside);
+
+    // 看门狗：同一次 bot 调用超过 hang_seconds 秒没有返回，就当作死循环，报出来并退出。
+    std::thread([hang_seconds] {
+        unsigned long long last = ~0ULL;
+        auto since = std::chrono::steady_clock::now();
+        for (;;) {
+            std::this_thread::sleep_for(std::chrono::milliseconds(200));
+            const unsigned long long now = g_calls.load();
+            const auto t = std::chrono::steady_clock::now();
+            if (now != last || g_inside.load() < 0) {
+                last = now;
+                since = t;
+            } else if (std::chrono::duration<double>(t - since).count() > hang_seconds) {
+                char what[96];
+                std::snprintf(what, sizeof what, "一次调用超过 %.0f 秒没有返回（多半是死循环）", hang_seconds);
+                die(what);
+            }
+        }
+    }).detach();
+
+    Lib libs[2];
+    libs[0].path = paths[0];
+    libs[1].path = paths[1];
+    char line[256];
+    while (std::fgets(line, sizeof line, stdin)) {
+        long long id;
+        unsigned long long seed;
+        int style, swap;
+        if (std::sscanf(line, "%lld %llu %d %d", &id, &seed, &style, &swap) != 4) continue;
+        play(libs, id, seed, style, swap, log);
+    }
+    g_game = -1;
+    std::fprintf(g_out, "DONE\n");
+    std::fflush(g_out);
+    std::_Exit(0);    // 不卸载动态库、不跑 bot 的全局析构，直接结束
+}

package/eval/arena/tank/workspace/judge/referee.cpp

@@ -0,0 +1,125 @@
+// referee.cpp —— 裁判核心：一个常驻的小程序，替 Python 裁判（engine.py）执行 tank.hpp 里的规则。
+//
+// Python 那边不含任何规则：开局、检查命令是否合法、结算、列出事件，全部在这里通过 tank.hpp 完成。
+// 标准输入一行一条请求，标准输出给回复：
+//
+//   HELLO                 → OK <引擎版本> <首回合预算> <每回合预算> <首回合墙上上限> <每回合墙上上限>
+//                              <每 CPU 毫秒多少个读数单位> <这个数怎么来的> <风格名 × N>
+//   NEW <种子> <风格>      → OK，然后是完整局面文本（以 END 行结束）
+//   LOAD                  → 后面跟一份完整局面文本（到 END 行）；回 OK 或 ERR <原因>
+//   STATE                 → 完整局面文本
+//   CHECK <座位> <一行回复> → OK <快速> <火力> <装甲>（并记下，等 STEP 时执行）或 ERR <原因>
+//   STEP                  → 用记下的命令结算一回合（没记的座位三辆都不动），回：OK，回合段文本（到 END 行）
+//   STEPX                 → 同上，但回：OK，若干行 "EV <事件>"，回合段文本，6 行 "X ..."，最后一行 DONE
+//   INFO                  → 6 行 "X ..."，最后一行 DONE
+//
+//   X <坦克> <还要几回合复活> <还要装填几回合> <场上子弹数> <子弹上限> <下回合能否开炮>
+//
+// 请求格式不对回一行 ERR，不退出。
+
+#include "../tank.hpp"
+#include "cycles.hpp"
+
+#include <cstdio>
+#include <cstdlib>
+#include <cstring>
+#include <string>
+
+namespace {
+
+void put(const std::string& text) { std::fwrite(text.data(), 1, text.size(), stdout); }
+
+void put_info(const tank::State& s) {
+    for (int i = 0; i < 6; ++i)
+        std::printf("X %d %d %d %d %d %d\n", i, tank::respawn_in(s, i), tank::reload_left(s, i), tank::bullets_out(s, i),
+                    tank::bullet_cap(s, i), tank::can_fire(s, i) ? 1 : 0);
+    std::printf("DONE\n");
+}
+
+bool read_line(std::string& line) {
+    line.clear();
+    char buf[1024];
+    while (std::fgets(buf, sizeof buf, stdin)) {
+        line += buf;
+        if (!line.empty() && line.back() == '\n') {
+            while (!line.empty() && (line.back() == '\n' || line.back() == '\r')) line.pop_back();
+            return true;
+        }
+    }
+    return !line.empty();
+}
+
+}  // namespace
+
+int main() {
+    tank::State s = tank::make_game(1);
+    tank::Orders pending[2];
+    tank::EventLog log;
+    std::string line;
+    while (read_line(line)) {
+        if (line == "HELLO") {
+            const cycles::Scale scale = cycles::measure();
+            std::printf("OK %s %d %d %d %d %lld %s", tank::ENGINE_VERSION, tank::BUDGET_FIRST_MS, tank::BUDGET_TURN_MS,
+                        tank::BUDGET_WALL_FIRST_MS, tank::BUDGET_WALL_TURN_MS, scale.per_ms, scale.source);
+            for (const char* name : tank::STYLE_NAMES) std::printf(" %s", name);
+            std::printf("\n");
+        } else if (line.rfind("NEW ", 0) == 0) {
+            unsigned long long seed = 0;
+            int style = -1;
+            if (std::sscanf(line.c_str() + 4, "%llu %d", &seed, &style) < 1) {
+                std::printf("ERR NEW 后面应为 种子 和 风格\n");
+            } else {
+                s = tank::make_game(seed, style);
+                pending[0] = pending[1] = tank::Orders{};
+                std::printf("OK\n");
+                put(tank::to_text(s));
+            }
+        } else if (line == "LOAD") {
+            std::string text, row;
+            while (read_line(row)) {
+                text += row;
+                text += '\n';
+                if (row == "END") break;
+            }
+            std::string err;
+            tank::State loaded;
+            if (tank::from_text(text, loaded, &err)) {
+                s = loaded;
+                pending[0] = pending[1] = tank::Orders{};
+                std::printf("OK\n");
+            } else {
+                std::printf("ERR %s\n", err.c_str());
+            }
+        } else if (line == "STATE") {
+            put(tank::to_text(s));
+        } else if (line.rfind("CHECK ", 0) == 0) {
+            const char seat = line.size() > 6 ? line[6] : '?';
+            std::string err;
+            tank::Orders o;
+            if ((seat != '0' && seat != '1') || line.size() < 8 || line[7] != ' ') {
+                std::printf("ERR CHECK 后面应为 座位 和 一行回复\n");
+            } else if (tank::parse_orders(std::string_view(line).substr(8), s, o, &err)) {
+                pending[seat - '0'] = o;
+                std::printf("OK %s %s %s\n", tank::cmd_text(o.cmd[0]).c_str(), tank::cmd_text(o.cmd[1]).c_str(),
+                            tank::cmd_text(o.cmd[2]).c_str());
+            } else {
+                std::printf("ERR %s\n", err.c_str());
+            }
+        } else if (line == "STEP" || line == "STEPX") {
+            const bool verbose = line == "STEPX";
+            tank::step(s, pending[0], pending[1], verbose ? &log : nullptr);
+            pending[0] = pending[1] = tank::Orders{};
+            std::printf("OK\n");
+            if (verbose)
+                for (const tank::Event& e : log.list) std::printf("EV %s\n", tank::event_text(e).c_str());
+            put(tank::turn_text(s));
+            if (verbose) put_info(s);
+        } else if (line == "INFO") {
+            put_info(s);
+        } else {
+            std::printf("ERR 不认识的请求\n");
+        }
+        std::fflush(stdout);
+    }
+    return 0;
+}

package/eval/arena/tank/workspace/judge/speed.cpp

@@ -0,0 +1,99 @@
+// speed.cpp —— 测速：跑两段固定的工作量，报告用了多久。用来确认机器的状态（电源模式、主频、别的任务）有没有变。
+//
+// 用法：speed [--cpu 逻辑处理器编号] [--repeat 次数]
+// 输出一行：
+//   SPEED cpu=<编号或 -1> ghz=<实际主频> loop_ms=<空转循环的墙上毫秒> engine_ms=<引擎工作量的墙上毫秒>
+//         engine_cpu_ms=<引擎工作量的 CPU 毫秒> per_ms=<每 CPU 毫秒多少个读数单位> source=<这个数怎么来的>
+//
+// 两段工作量：
+//   空转循环：2 亿次一拍一次的加法。次数除以用时就是这个核此刻的实际主频（不受内存和缓存影响）。
+//   引擎工作量：用固定的伪随机命令打 400 局不记录的对局（约 12 万次 step）。
+// 各重复若干次取最快的一次（最快的一次最不受别的任务打扰）。
+
+#include "../tank.hpp"
+#include "cycles.hpp"
+
+#include <chrono>
+#include <cstdio>
+#include <cstdlib>
+#include <cstring>
+
+#ifdef _WIN32
+#include <windows.h>
+#endif
+
+namespace {
+
+double wall_ms() {
+    return std::chrono::duration<double, std::milli>(std::chrono::steady_clock::now().time_since_epoch()).count();
+}
+
+double spin_loop() {
+    unsigned long long x = 0;
+    const double t0 = wall_ms();
+    for (unsigned long long i = 0; i < 200000000ULL; ++i) {
+        x += 1;
+#if defined(__GNUC__)
+        __asm__ volatile("" : "+r"(x));    // 不让编译器把循环算掉；每次迭代一条一拍的加法
+#endif
+    }
+    const double t1 = wall_ms();
+    return x ? t1 - t0 : 0;
+}
+
+unsigned long long g_sink = 0;
+
+void engine_work() {
+    unsigned long long r = 88172645463325252ULL;
+    for (int game = 0; game < 400; ++game) {
+        tank::State s = tank::make_game(1000 + game);
+        while (!s.done) {
+            tank::Orders o[2];
+            for (int seat = 0; seat < 2; ++seat)
+                for (int type = 0; type < 3; ++type) {
+                    r ^= r << 13;
+                    r ^= r >> 7;
+                    r ^= r << 17;
+                    tank::Cmd list[tank::N_CMDS];
+                    const int n = tank::legal_commands(s, tank::tank_id(seat, type), list);
+                    o[seat].cmd[type] = list[(r >> 24) % unsigned(n)];
+                }
+            tank::step(s, o[0], o[1]);
+        }
+        g_sink += s.wall_hash + unsigned(s.turn);
+    }
+}
+
+}  // namespace
+
+int main(int argc, char** argv) {
+    int cpu = -1, repeat = 5;
+    for (int k = 1; k + 1 < argc; ++k) {
+        if (!std::strcmp(argv[k], "--cpu")) cpu = std::atoi(argv[++k]);
+        else if (!std::strcmp(argv[k], "--repeat")) repeat = std::atoi(argv[++k]);
+    }
+#ifdef _WIN32
+    if (cpu >= 0 && cpu < 64 && !SetThreadAffinityMask(GetCurrentThread(), DWORD_PTR(1) << cpu)) {
+        std::fprintf(stderr, "绑不到逻辑处理器 %d\n", cpu);
+        return 2;
+    }
+#else
+    if (cpu >= 0) std::fprintf(stderr, "这个系统上没有实现绑定处理器，忽略 --cpu\n");
+#endif
+    const cycles::Scale scale = cycles::measure();
+    tank::budget_setup(tank::BUDGET_CPU, double(scale.per_ms));
+    double best_loop = 1e18, best_wall = 1e18, best_cpu = 1e18;
+    for (int k = 0; k < (repeat < 1 ? 1 : repeat); ++k) {
+        const double loop = spin_loop();
+        if (loop < best_loop) best_loop = loop;
+        tank::budget_begin(0);
+        const double t0 = wall_ms();
+        engine_work();
+        const double wall = wall_ms() - t0, used = tank::budget_used();
+        if (wall < best_wall) best_wall = wall;
+        if (used < best_cpu) best_cpu = used;
+    }
+    std::printf("SPEED cpu=%d ghz=%.3f loop_ms=%.2f engine_ms=%.2f engine_cpu_ms=%.2f per_ms=%lld source=%s sink=%llu\n", cpu,
+                200000000.0 / best_loop / 1e6, best_loop, best_wall, best_cpu, scale.per_ms, scale.source, g_sink % 1000);
+    return 0;
+}

package/eval/arena/tank/workspace/run.cmd

@@ -0,0 +1,31 @@
+@echo off
+setlocal
+chcp 65001 >nul
+rem Find a Python 3.10+ and run the given script in this folder. No arguments: show the contest clock.
+rem Usage: .\run.cmd arena.py check
+rem (Keep this file ASCII-only except the last line: cmd.exe loses its place in a batch file
+rem  that has multi-byte characters after the code page is switched.)
+rem "call" is needed: python3 may be a .cmd shim, and without call control never comes back.
+set "CHECK=import sys; v = sys.version_info; sys.exit(v[0] != 3 or v[1] not in range(10, 100))"
+set "PY="
+for %%P in (python python3) do if not defined PY (
+  call %%P -c "%CHECK%" >nul 2>nul && set "PY=%%P"
+)
+if not defined PY (
+  call py -3 -c "%CHECK%" >nul 2>nul && set "PY=py -3"
+)
+rem Not on PATH: look in the usual install locations.
+if not defined PY for /d %%D in ("%LOCALAPPDATA%\Programs\Python\Python3*" "%ProgramFiles%\Python3*") do if not defined PY (
+  if exist "%%~D\python.exe" call "%%~D\python.exe" -c "%CHECK%" >nul 2>nul && set "PY="%%~D\python.exe""
+)
+if not defined PY if exist "%USERPROFILE%\.cache\codex-runtimes\codex-primary-runtime\dependencies\python\python.exe" (
+  set "PY="%USERPROFILE%\.cache\codex-runtimes\codex-primary-runtime\dependencies\python\python.exe""
+)
+if not defined PY goto nopython
+pushd "%~dp0"
+if "%~1"=="" (call %PY% -X utf8 clock.py) else (call %PY% -X utf8 %*)
+set "CODE=%errorlevel%"
+popd
+exit /b %CODE%
+:nopython
+echo 没有找到 Python 3.10 以上的版本（试过 python、python3、py -3 和常见安装位置）。请把这个情况报告出来。 1>&2 & exit /b 1

package/eval/arena/tank/workspace/run.sh

@@ -0,0 +1,23 @@
+#!/bin/sh
+# 找一个 Python 3.10 以上，在本目录运行给定的脚本。不带参数时显示比赛用时。
+# 用法：sh run.sh arena.py check
+cd "$(dirname -- "$0")" || exit 1
+[ "$#" -eq 0 ] && set -- clock.py
+ok='import sys; sys.exit(sys.version_info < (3, 10))'
+for py in python3 python; do
+    if command -v "$py" >/dev/null 2>&1 && "$py" -c "$ok" >/dev/null 2>&1; then
+        exec "$py" -X utf8 "$@"
+    fi
+done
+# Windows 上只装了 py 启动器的情况。
+if command -v py >/dev/null 2>&1 && py -3 -c "$ok" >/dev/null 2>&1; then
+    exec py -3 -X utf8 "$@"
+fi
+# PATH 里没有：再看几个常见的安装位置。
+for py in "$LOCALAPPDATA"/Programs/Python/Python3*/python.exe "$HOME"/.cache/codex-runtimes/codex-primary-runtime/dependencies/python/python.exe /usr/local/bin/python3 /usr/bin/python3; do
+    if [ -x "$py" ] && "$py" -c "$ok" >/dev/null 2>&1; then
+        exec "$py" -X utf8 "$@"
+    fi
+done
+echo '没有找到 Python 3.10 以上的版本（试过 python3、python、py -3 和常见安装位置）。请把这个情况报告出来。' >&2
+exit 1