Skip to content

Qwen3.8-Flash-Next on any consumer hardware: one-click install for Windows / Linux. Strata inference engine, OpenAI/Anthropic API on localhost, optional image input.

C++
8.9 KB
Raw Blame
// aux_cpus_test: the CPU-set derivation of --aux-cpus (pure functions, no GPU) and, on Linux, the placement of live
// threads (a thread of the process moved to the aux set by the sweep, one that pins itself at creation, the owned ones
// left alone, and the original placement put back).
#include "strata/platform/aux_cpus.hpp"

#include <array>
#include <atomic>
#include <chrono>
#include <cstdio>
#include <thread>

using namespace strata::aux_cpus;

namespace {
int failures = 0;
#define CHECK(c)                                                                                                  \
    do {                                                                                                          \
        if (!(c)) {                                                                                               \
            std::fprintf(stderr, "FAILED %s:%d: %s\n", __FILE__, __LINE__, #c);                                   \
            ++failures;                                                                                           \
        }                                                                                                         \
    } while (0)

using V = std::vector<int>;

std::vector<LogicalCpu> cpus(std::initializer_list<std::array<long, 3>> rows) {
    std::vector<LogicalCpu> out;
    for (const auto& r : rows) out.push_back({(int) r[0], r[1], r[2]});
    return out;
}

// SMT machine: CPU i and i + n are the two threads of core i
std::vector<LogicalCpu> smt(int n_cores, int n_threads_total) {
    std::vector<LogicalCpu> out;
    for (int c = 0; c < n_threads_total; ++c) out.push_back({c, 0, c % n_cores});
    return out;
}

void test_parse() {
    V v;
    CHECK(parse_cpu_list("24", v) && v == V{24});
    CHECK(parse_cpu_list("26,24", v) && v == (V{24, 26}));
    CHECK(parse_cpu_list("24-27,30,25", v) && v == (V{24, 25, 26, 27, 30}));
    CHECK(parse_cpu_list("0", v) && v == V{0});
    for (const char* bad : {"", ",", "1,", ",1", "a", "1-", "-1", "3-1", "1,,2", "1 2", "1;2", "99999999"}) {
        CHECK(!parse_cpu_list(bad, v));
        CHECK(v.empty());
    }
    Config c;
    std::string err;
    CHECK(parse_spec("", c, err) && !c.on);
    CHECK(parse_spec("off", c, err) && !c.on);
    CHECK(parse_spec("auto", c, err) && c.on && !c.use_list);
    CHECK(parse_spec("24,26", c, err) && c.on && c.use_list && c.list == (V{24, 26}));
    CHECK(!parse_spec("fast", c, err) && !err.empty());
}

void test_derive() {
    // the production box's shape: 16 workers on 16 physical cores, the host on core 2, 24 allowed CPUs - CPUs 0-15
    // are cores 0-15 and 22-29 the second threads of cores 0-7: the host's sibling (CPU 24) is the only spare one
    {
        std::vector<LogicalCpu> a;
        for (int c = 0; c < 16; ++c) a.push_back({c, 0, c});
        for (int c = 22; c < 30; ++c) a.push_back({c, 0, c - 22});
        V workers;
        for (int c = 0; c < 16; ++c)
            if (c != 2) workers.push_back(c);
        CHECK(derive(a, 2, workers) == V{24});
        // an explicit list is taken as given, minus the host's CPU and the workers' CPUs
        CHECK(restrict_list({24, 26, 2, 5, 99}, a, 2, workers) == (V{24, 26}));
    }
    // 12 cores x 2 threads, host on CPU 0, workers on CPUs 1-7: the host's sibling first (12), then both threads of
    // the four worker-free cores 8-11; the siblings of the workers (13-19) are never offered
    {
        const auto a = smt(12, 24);
        CHECK(derive(a, 0, V{1, 2, 3, 4, 5, 6, 7}) == (V{12, 8, 9, 10, 11, 20, 21, 22, 23}));
    }
    // no SMT, every other core a worker: nothing spare
    {
        const auto a = cpus({{0, 0, 0}, {1, 0, 1}, {2, 0, 2}, {3, 0, 3}});
        CHECK(derive(a, 0, V{1, 2, 3}).empty());
    }
    // no SMT, a core without a worker: that core
    {
        const auto a = cpus({{0, 0, 0}, {1, 0, 1}, {2, 0, 2}, {3, 0, 3}});
        CHECK(derive(a, 0, V{1, 2}) == V{3});
    }
    // every CPU is a worker or the host's: nothing, with SMT too
    {
        const auto a = smt(4, 8);
        CHECK(derive(a, 0, V{1, 2, 3}) == V{4});          // only the host's sibling
        CHECK(derive(a, 0, V{1, 2, 3, 4}).empty());       // CPU 4 is a worker: the host core's sibling is taken
    }
    // two packages: core 1 of package 1 is not core 1 of package 0
    {
        const auto a = cpus({{0, 0, 0}, {1, 0, 1}, {2, 1, 0}, {3, 1, 1}});
        CHECK(derive(a, 0, V{1, 2}) == V{3});
    }
    // unknown cores (no sysfs): a CPU of unknown core could be a worker's sibling - none offered
    {
        const auto a = cpus({{0, -1, -1}, {1, -1, -1}, {2, -1, -1}, {3, -1, -1}});
        CHECK(derive(a, 0, V{1}).empty());
    }
    // the host's CPU unknown: the free cores only
    {
        const auto a = smt(4, 8);
        CHECK(derive(a, -1, V{0, 1}) == (V{2, 3, 6, 7}));
    }
    // CPUs the process may not use are not offered (a taskset): 5 and 6 are outside `a`
    {
        const auto a = cpus({{0, 0, 0}, {1, 0, 1}, {4, 0, 0}});
        CHECK(derive(a, 0, V{1}) == V{4});
    }
    CHECK(derive(std::vector<LogicalCpu>{}, 0, V{1}).empty());
}

#if defined(__linux__)
int tid_of_self() { return (int) syscall(SYS_gettid); }

std::vector<int> mask_of(int tid) {
    cpu_set_t m;
    CPU_ZERO(&m);
    std::vector<int> out;
    if (sched_getaffinity(tid, sizeof m, &m) != 0) return out;
    for (int c = 0; c < CPU_SETSIZE; ++c)
        if (CPU_ISSET(c, &m)) out.push_back(c);
    return out;
}

void test_live() {
    const std::vector<int> allowed = mask_of(0);
    if (allowed.size() < 4) {
        std::printf("aux_cpus_test: live placement skipped (needs 4 allowed CPUs, have %zu)\n", allowed.size());
        return;
    }
    const int host = allowed[0], worker = allowed[1], aux_a = allowed[2], aux_b = allowed[3];
    std::string err;
    CHECK(configure(std::to_string(aux_a) + "," + std::to_string(aux_b), err));
    // before the plan exists nothing is moved
    CHECK(sweep() == 0);
    const std::string line = set_topology(host, V{worker});
    std::printf("%s\n", line.c_str());
    CHECK(plan() == (V{aux_a, aux_b}));
    CHECK(enabled());

    // threads that stay alive until told: `floater` is created before the sweep (a CUDA driver thread's case), `owned`
    // is a pool worker (registered), `late` pins itself at creation
    std::atomic<int> tid_floater{0}, tid_owned{0}, tid_late{0};
    std::atomic<bool> stop{false};
    auto body = [&](std::atomic<int>& tid, bool owned, bool pin) {
        if (owned) note_owned_thread();
        if (pin) pin_current_thread();
        tid = tid_of_self();
        while (!stop.load()) std::this_thread::sleep_for(std::chrono::milliseconds(2));
    };
    set_enabled(false);                                   // earlier threads are born unmoved
    CHECK(!enabled());
    std::thread floater([&] { body(tid_floater, false, false); });
    std::thread owned([&] { body(tid_owned, true, false); });
    for (int i = 0; i < 500 && (!tid_floater || !tid_owned); ++i) std::this_thread::sleep_for(std::chrono::milliseconds(2));
    CHECK(mask_of(tid_floater) == allowed);

    set_enabled(true);                                    // the sweep
    const V aux{aux_a, aux_b};
    CHECK(mask_of(tid_floater) == aux);
    CHECK(mask_of(tid_owned) == allowed);                 // owned threads are left alone
    CHECK(mask_of(tid_of_self()) == allowed);             // so is the main thread (configure registered it)

    std::thread late([&] { body(tid_late, false, true); });
    for (int i = 0; i < 500 && !tid_late; ++i) std::this_thread::sleep_for(std::chrono::milliseconds(2));
    CHECK(mask_of(tid_late) == aux);                      // pinned at creation

    set_enabled(false);                                   // back to the placements they had
    CHECK(mask_of(tid_floater) == allowed);
    CHECK(mask_of(tid_late) == allowed);
    CHECK(mask_of(tid_owned) == allowed);
    CHECK(sweep() == 0);                                  // off: nothing moves

    // a thread pinned to ONE worker CPU by someone else is not ours even when unregistered
    std::atomic<int> tid_pinned{0};
    std::thread pinned([&] {
        cpu_set_t m;
        CPU_ZERO(&m);
        CPU_SET(worker, &m);
        sched_setaffinity(0, sizeof m, &m);
        tid_pinned = tid_of_self();
        while (!stop.load()) std::this_thread::sleep_for(std::chrono::milliseconds(2));
    });
    for (int i = 0; i < 500 && !tid_pinned; ++i) std::this_thread::sleep_for(std::chrono::milliseconds(2));
    set_enabled(true);
    CHECK(mask_of(tid_pinned) == V{worker});
    CHECK(mask_of(tid_floater) == aux);
    set_enabled(false);

    stop = true;
    floater.join();
    owned.join();
    late.join();
    pinned.join();
}
#else
void test_live() { std::printf("aux_cpus_test: live placement is Linux only\n"); }
#endif

}  // namespace

int main() {
    test_parse();
    test_derive();
    test_live();
    if (failures) {
        std::fprintf(stderr, "aux_cpus_test: %d check(s) failed\n", failures);
        return 1;
    }
    std::printf("aux_cpus_test: ok\n");
    return 0;
}