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++
3.5 KB
Raw Blame
// pin_budget_test: the pinned-memory headroom (include/strata/core/pin_budget.hpp) with the simulated ceiling.
// Needs a GPU for the pinned calls; without one it prints SKIP and passes.
#include "strata/core/pin_budget.hpp"

#include <cstdio>
#include <cstdlib>
#include <cstring>

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

#ifdef _WIN32
#define SETENV(k, v) _putenv_s(k, v)
#else
#define SETENV(k, v) setenv(k, v, 1)
#endif

int main() {
    // the singleton reads its environment on first use: set everything first
    SETENV("STRATA_TEST_PIN_BUDGET_MIB", "100");
    SETENV("STRATA_PIN_RESERVE_MIB", "32");   // soft 32 MiB, hard 64 MiB (a quarter of 32 is below the 64 MiB floor)
    using namespace strata::core;
    if (cudaFree(0) != cudaSuccess) {
        std::printf("pin_budget_test: SKIP (no GPU)\n");
        return 0;
    }
    (void) cudaGetLastError();

    // 1. a registration beyond the ceiling is refused, one inside it works and is charged
    {
        void* big = std::malloc(160u << 20);
        void* small = std::malloc(8u << 20);
        CHECK(pin_register(big, 160u << 20, cudaHostRegisterPortable) == cudaErrorMemoryAllocation);
        CHECK(pin_register(small, 8u << 20, cudaHostRegisterPortable) == cudaSuccess);
        CHECK(pin_detail::st().sim_used == (8u << 20));
        CHECK(pin_unregister(small) == cudaSuccess);
        CHECK(pin_detail::st().sim_used == 0);
        std::free(big);
        std::free(small);
    }
    // 2. without a reserve a refused guarded allocation stays refused
    {
        void* p = nullptr;
        CHECK(host_alloc_guarded(&p, 200u << 20, cudaHostAllocMapped) != cudaSuccess);
        (void) cudaGetLastError();
    }
    // 3. the reserves are held, the arena (here: a registration) takes what is left, a required buffer is then
    //    refused, the held headroom is handed back and the retry works
    {
        pin_reserve_take();
        CHECK(pin_detail::st().hard != nullptr && pin_detail::st().hard_bytes == (64u << 20));
        CHECK(pin_detail::st().soft != nullptr && pin_detail::st().soft_bytes == (32u << 20));
        CHECK(pin_detail::st().sim_used == (96u << 20));
        void* arena = std::malloc(4u << 20);
        CHECK(pin_register(arena, 4u << 20, cudaHostRegisterPortable) == cudaSuccess);   // 100 MiB used: the ceiling
        pin_reserve_release_soft();
        CHECK(pin_detail::st().soft == nullptr);
        CHECK(pin_detail::st().sim_used == (68u << 20));
        void* a = nullptr;
        CHECK(host_alloc_guarded(&a, 16u << 20, cudaHostAllocMapped) == cudaSuccess);   // fits beside the hard reserve
        void* b = nullptr;
        CHECK(host_alloc_guarded(&b, 40u << 20, cudaHostAllocMapped) == cudaSuccess);   // refused first, then the hard reserve goes
        CHECK(pin_detail::st().hard == nullptr);
        CHECK(pin_detail::st().hard_retries == 1);
        void* c = nullptr;
        CHECK(host_alloc_guarded(&c, 60u << 20, cudaHostAllocMapped) != cudaSuccess);   // truly out: reported, not hidden
        (void) cudaGetLastError();
        CHECK(pin_exhausted_hint().find("[pinned-memory-exhausted]") != std::string::npos);
        (void) pin_unregister(arena);
        std::free(arena);
    }
    std::printf(g_fail == 0 ? "pin_budget_test: OK\n" : "pin_budget_test: %d FAILED\n", g_fail);
    return g_fail == 0 ? 0 : 1;
}