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++
4.6 KB
Raw Blame
#include "strata/program/split_ring.hpp"

#include <cstdint>
#include <cstdio>
#include <vector>

using namespace strata::program;

#define CHECK(cond)                                                                       \
    do {                                                                                  \
        if (!(cond)) {                                                                    \
            std::printf("split_ring_test FAIL line %d: %s\n", __LINE__, #cond);           \
            return 1;                                                                     \
        }                                                                                 \
        ++checks;                                                                         \
    } while (0)

// a cache of `slots` slots whose blobs vary per layer like a native pack's (2.4 .. 3.6 MB), as the prefix sum the
// expert cache keeps
static std::vector<uint64_t> make_offsets(int64_t slots) {
    std::vector<uint64_t> off((size_t) slots + 1, 0);
    for (int64_t i = 0; i < slots; ++i) off[(size_t) i + 1] = off[(size_t) i] + 2400000ull + (uint64_t) (i % 13) * 100000ull;
    return off;
}

int main() {
    int checks = 0;

    // 1. the ring the split chooses: the env wins, else 96 when most experts are resident, 0 = the pinned-share rule
    CHECK(split_ring_slots(nullptr, 0.9) == 96);
    CHECK(split_ring_slots(nullptr, 0.75) == 96);
    CHECK(split_ring_slots(nullptr, 0.74) == 0);
    CHECK(split_ring_slots("384", 0.9) == 384);
    CHECK(split_ring_slots("384", 0.1) == 384);
    CHECK(split_ring_slots("512", 0.9) == 512);
    CHECK(split_ring_slots("0", 0.9) == 0);
    CHECK(split_ring_slots("-3", 0.9) == 0);
    CHECK(split_ring_slots("junk", 0.9) == 0);

    // 2. the lend count: uniform slots round up, sized slots walk from the end
    CHECK(split_lend_slots(1000, 1000 * 100, nullptr, 100, 0) == 0);
    CHECK(split_lend_slots(1000, 1000 * 100, nullptr, 100, 1) == 1);
    CHECK(split_lend_slots(1000, 1000 * 100, nullptr, 100, 100) == 1);
    CHECK(split_lend_slots(1000, 1000 * 100, nullptr, 100, 101) == 2);
    CHECK(split_lend_slots(1000, 0, nullptr, 0, 500) == 0);   // no blob size: nothing to count
    {
        const std::vector<uint64_t> off = make_offsets(50);
        const int64_t bytes = (int64_t) off.back();
        CHECK(split_lend_slots(50, bytes, off.data(), 3600000, 0) == 0);
        const uint64_t last = off[50] - off[49];
        CHECK(split_lend_slots(50, bytes, off.data(), 3600000, last) == 1);
        CHECK(split_lend_slots(50, bytes, off.data(), 3600000, last + 1) == 2);
        CHECK(split_lend_slots(50, bytes, off.data(), 3600000, off[50]) == 50);
        CHECK(split_lend_slots(50, bytes, off.data(), 3600000, off[50] + 1) == 50);   // never past the cache
    }

    // 3. the order: the RAM copy's lend region and the borrow must be sized with the SAME ring.  The need of a chunk is
    //    its own buffers plus ring_slots * max_blob (Prefill::bytes_needed); the engine used to size the region with the
    //    default ring (96) and apply the STRATA_SPLIT_RING override afterwards, so a ring of 384 borrowed more slots
    //    than the region kept.
    {
        const int64_t slots = 6000;
        const std::vector<uint64_t> off = make_offsets(slots);
        const int64_t bytes = (int64_t) off.back();
        const uint64_t max_blob = 3600000, buffers = 3000ull << 20;
        auto need = [&](int ring) { return buffers + (uint64_t) ring * max_blob; };
        auto lend = [&](int ring) { return split_lend_slots(slots, bytes, off.data(), max_blob, need(ring)); };

        const int default_ring = 96;
        const int ring = split_ring_slots("384", 0.9);   // STRATA_SPLIT_RING=384
        const int64_t borrowed = lend(ring);             // what the prompt path borrows with the override in force
        const int64_t kept_old_order = lend(default_ring);   // the region sized before the override applied
        const int64_t kept_new_order = lend(split_ring_slots("384", 0.9));   // decided first, then sized
        CHECK(kept_old_order < borrowed);                // the bug: borrowed experts without a RAM copy
        CHECK(kept_new_order == borrowed);               // the fix: the copy keeps every borrowed slot
        // no override in play (production: STRATA_SPLIT_RING unset, ring 96 either way): nothing changes
        CHECK(lend(split_ring_slots(nullptr, 0.5) > 0 ? split_ring_slots(nullptr, 0.5) : default_ring) ==
              kept_old_order);
        // a bigger ring borrows monotonically more
        CHECK(lend(96) <= lend(256) && lend(256) <= lend(384) && lend(384) <= lend(512));
    }

    std::printf("split_ring_test OK (%d checks)\n", checks);
}