Skip to content

[Bug] setup.sh can't setup dual nvidia GPUs #112

Closed

Description

@megakilo

Running on Ubuntu 26.04 + 64GB system memory + dual 5060 Ti 16GB

If I setup again with single GPU, then modify the json config with "gpu": [0, 1]. It would work.

Also calibration mode doesn't make use of two GPUs neither.

$ nvidia-smi
Mon Sep 28 23:06:32 2026
+-----------------------------------------------------------------------------------------+
| NVIDIA-SMI 595.91.07              Driver Version: 595.91.07      CUDA Version: 13.2     |
+-----------------------------------------+------------------------+----------------------+
| GPU  Name                 Persistence-M | Bus-Id          Disp.A | Volatile Uncorr. ECC |
| Fan  Temp   Perf          Pwr:Usage/Cap |           Memory-Usage | GPU-Util  Compute M. |
|                                         |                        |               MIG M. |
|=========================================+========================+======================|
|   0  NVIDIA GeForce RTX 5060 Ti     Off |   00000000:04:00.0 Off |                  N/A |
|  0%   33C    P8              2W /  180W |      13MiB /  16311MiB |      0%      Default |
|                                         |                        |                  N/A |
+-----------------------------------------+------------------------+----------------------+
|   1  NVIDIA GeForce RTX 5060 Ti     Off |   00000000:05:00.0 Off |                  N/A |
|  0%   39C    P8              4W /  180W |      13MiB /  16311MiB |      0%      Default |
|                                         |                        |                  N/A |
+-----------------------------------------+------------------------+----------------------+
$ ./setup.sh --gpus 0,1 --family qwen --model IQ3_XXS --kv int8 --vision no --context 131072 --experimental-speed-projection off
Strata - Qwen3.8-Flash-Next on a normal PC (NVIDIA GPU + system RAM + CPU)

=== Step 1: checking your PC ===
  [ok] GPU: NVIDIA GeForce RTX 5060 Ti, 15.9 GB VRAM, compute capability 12.0, driver 595.91.07
       2 NVIDIA GPUs: Strata uses GPU 0 - choose another with --gpu N:
         0: NVIDIA GeForce RTX 5060 Ti, 16 GB
         1: NVIDIA GeForce RTX 5060 Ti, 16 GB
  [ok] RAM: 60 GB
  [ok] CPU: Intel(R) Core(TM) i7-5960X CPU @ 3.00GHz (AVX2)

=== Step 2: your choices ===
  [ok] model: Qwen3.8-Flash-Next

  1) Q2_0     2-bit, the fastest; download 66 GB, uses ~34 GB of RAM
  2) IQ2_XS   2-bit i-quant, a little better quality, close in speed; download 68 GB, uses ~36 GB of RAM
  3) IQ3_XXS  3-bit i-quant, better quality, slower (more CPU work per token); download 76 GB, uses ~43 GB of RAM
  4) IQ3_S    3.5-bit i-quant, the best quality (matches the full model), the slowest; needs a 64 GB PC with little else running; download 84 GB, uses ~50 GB of RAM   <- needs 62 GB RAM, you have 60
  [ok] size: IQ3_XXS
  [ok] context: 131072 tokens
  [ok] KV cache: 8-bit
  [ok] images: off
  [ok] experimental speed projection: off

=== Step 3: Python packages ===
  [ok] numpy, jinja2, regex, pyyaml, tqdm, requests, cmake, ninja, pillow, psutil already installed

=== Step 4: the Strata engine ===
  [ok] llama.cpp 3cf0325 (gguf-py, ggml, mtmd)
  [ok] ready-made engine already installed
  [ok] engine: /home/steven/Projects/Strata/engine/strata

=== Step 5: downloading Qwen3.8-Flash-Next IQ3_XXS ===
  [ok] Qwen3.8-Flash-Next-GSQ-RCO-IQ3_XXS-00001-of-00002.gguf already downloaded
  [ok] Qwen3.8-Flash-Next-GSQ-RCO-IQ3_XXS-00002-of-00002.gguf already downloaded
  [ok] model files present

=== Step 6: preparing the model for Strata ===
  [ok] model prepared: /home/steven/Projects/Strata-data/packs/iq3_xxs
  [ok] MTP draft layer: /home/steven/Projects/Strata-data/mtp/rt

=== Step 7: writing the start script ===
  [ok] layer split across GPUs [0, 1] (auto)

  [X]  there is no GPU [0, 1]: 0 = NVIDIA GeForce RTX 5060 Ti, 1 = NVIDIA GeForce RTX 5060 Ti

Setup stopped. Fix the item above and run it again - everything already done is kept and skipped.

Activity

  1. megakilo commented on Sep 29, 2026

    @megakilo
    Author

    Another minor bug is that "monitor dashboard" doesn't show multiple GPUs

  2. sal7g86 commented on Sep 29, 2026

    @sal7g86

    I have the same problem on linux mint:

    $ ./setup.sh --setup --gpus 0,1
    Strata - Qwen3.8-Flash-Next on a normal PC (NVIDIA GPU + system RAM + CPU)
    
    === Step 1: checking your PC ===
      [ok] GPU: NVIDIA GeForce RTX 5070, 11.9 GB VRAM, compute capability 12.0, driver 615.71.09
           2 NVIDIA GPUs: Strata uses GPU 0 - choose another with --gpu N:
             0: NVIDIA GeForce RTX 5070, 12 GB
             1: NVIDIA GeForce RTX 3060, 12 GB
      [ok] RAM: 63 GB
      [ok] CPU: 13th Gen Intel(R) Core(TM) i7-13700F (AVX2)
    
    [....]
    
    === Step 7: writing the start script ===
      [ok] layer split across GPUs [0, 1] (auto)
    
      [X]  there is no GPU [0, 1]: 0 = NVIDIA GeForce RTX 5070, 1 = NVIDIA GeForce RTX 3060
    

    this is my nvidia-smi output:

    $ nvidia-smi 
    Tue Sep 29 09:27:15 2026       
    +-----------------------------------------------------------------------------------------+
    | NVIDIA-SMI 615.71.09              KMD Version: 615.71.09     CUDA UMD Version: 13.4     |
    +-----------------------------------------+------------------------+----------------------+
    | GPU  Name                 Persistence-M | Bus-Id          Disp.A | Volatile Uncorr. ECC |
    | Fan  Temp   Perf          Pwr:Usage/Cap |           Memory-Usage | GPU-Util  Compute M. |
    |                                         |                        |               MIG M. |
    |=========================================+========================+======================|
    |   0  NVIDIA GeForce RTX 5070        On  |   00000000:01:00.0 Off |                  N/A |
    |  0%   35C    P8              5W /  250W |      15MiB /  12227MiB |      0%      Default |
    |                                         |                        |                  N/A |
    +-----------------------------------------+------------------------+----------------------+
    |   1  NVIDIA GeForce RTX 3060        On  |   00000000:04:00.0  On |                  N/A |
    |  0%   54C    P5             26W /  170W |     518MiB /  12288MiB |     37%      Default |
    |                                         |                        |                  N/A |
    +-----------------------------------------+------------------------+----------------------+
    
    +-----------------------------------------------------------------------------------------+
    | Processes:                                                                              |
    |  GPU   GI   CI              PID   Type   Process name                        GPU Memory |
    |        ID   ID                                                               Usage      |
    |=========================================================================================|
    |    0   N/A  N/A            1777      G   /usr/lib/xorg/Xorg                        4MiB |
    |    1   N/A  N/A            1777      G   /usr/lib/xorg/Xorg                      220MiB |
    |    1   N/A  N/A            3143      G   cinnamon                                 42MiB |
    |    1   N/A  N/A            4118      G   /usr/lib/firefox/firefox                163MiB |
    +-----------------------------------------------------------------------------------------+
    
  3. pdsmike commented on Sep 29, 2026

    @pdsmike

    Confirming. After git pull on Linux:
    ./setup.sh --setup --gpus 0,1 --layer-split auto

    Strata - Qwen3.8-Flash-Next on a normal PC (NVIDIA GPU + system RAM + CPU)
    
    === Step 1: checking your PC ===
      [ok] GPU: NVIDIA GeForce RTX 5060 Ti, 15.9 GB VRAM, compute capability 12.0, driver 610.57.04
           3 NVIDIA GPUs: Strata uses GPU 0 - choose another with --gpu N:
             0: NVIDIA GeForce RTX 5060 Ti, 16 GB
             1: NVIDIA GeForce RTX 5060 Ti, 16 GB
             2: NVIDIA GeForce RTX 3060, 12 GB
      [ok] RAM: 62 GB
      [ok] CPU: Intel(R) Core(TM) Ultra 5 245K (AVX2)
    
    === Step 2: your choices ===
      1) Qwen3.8-Flash-Next   Qwen; GSQ-RCO quants by ISTA-DASLab - the original model
      2) Swift 1.5            UkisAI's fine-tune of Qwen3.8-Flash-Next - thinks much shorter (-63% thinking tokens, 1.8x sooner answers by its authors' numbers)
      3) Qwen3.8-Flash-Next Coder ISTA-DASLab's coding version - half the experts (code, tools, images kept): needs ~32 GB of RAM, faster; weaker outside coding
    Which model? [1]: 2
      [ok] model: Swift 1.5
      Its license: Swift Open License 1.0: https://huggingface.co/ukisai/Swift-1.5-Qwen3.8-Flash-Next-GSQ-RCO-GGUF
    
      1) Q2_0     2-bit, the fastest; download 66 GB, uses ~34 GB of RAM
      2) IQ2_XS   2-bit i-quant, a little better quality, close in speed; download 68 GB, uses ~36 GB of RAM
      3) IQ3_XXS  3-bit i-quant, better quality, slower (more CPU work per token); download 76 GB, uses ~43 GB of RAM
    Which size? [3]: 3
      [ok] size: IQ3_XXS
    
      Context length = how much text the model can see at once (your chat, files, tool output).
      Longer needs more VRAM for it, so fewer experts fit on the GPU:
      1) 8K tokens
      2) 32K tokens
      3) 64K tokens   (recommended for your GPU)
      4) 128K tokens
      5) 256K tokens
    Context? [3]: 4
      [ok] context: 131072 tokens
    
      KV cache precision (the model's memory of the conversation):
      1) 8-bit   (recommended: what every published number was measured with)
      2) 4-bit   half the memory (about 4% faster at 128K), but measurably less precise on long
                 documents; long-context lookups (needle tests) still pass
    KV cache? [1]: 2
      [ok] KV cache: 4-bit (Hadamard-rotated)
    
      Images: the model can also read pictures (screenshots, photos, scanned pages). This adds a 0.9 GB
      download and keeps ~1.4 GB of VRAM free for the image encoder, so text is a few % slower.
    Do you want images? [n]: n
      [ok] images: off
    
    === Step 3: Python packages ===
      [ok] numpy, jinja2, regex, pyyaml, tqdm, requests, cmake, ninja, pillow, psutil already installed
    
    === Step 4: the Strata engine ===
      [ok] llama.cpp 3cf0325 (gguf-py, ggml, mtmd)
      [ok] ready-made engine already installed
      [ok] engine: /home/mike/Programs/Strata/engine/strata
    
    === Step 5: downloading Swift 1.5 IQ3_XXS ===
      [ok] Swift-Qwen3.8-Flash-Next-GSQ-RCO-IQ3_XXS-00001-of-00002.gguf already downloaded
      [ok] Swift-Qwen3.8-Flash-Next-GSQ-RCO-IQ3_XXS-00002-of-00002.gguf already downloaded
      [ok] model files present
    
    === Step 6: preparing the model for Strata ===
      [ok] model prepared: /home/mike/Programs/Strata-data/packs/swift-iq3_xxs
      [ok] MTP draft layer: /home/mike/Programs/Strata-data/mtp/rt
    
    === Step 7: writing the start script ===
      [ok] KV streaming on: the context's KV cache lives in RAM (1.0 GB), more experts fit in VRAM
      [ok] layer split across GPUs [0, 1] (auto)
    
      [X]  there is no GPU [0, 1]: 0 = NVIDIA GeForce RTX 5060 Ti, 1 = NVIDIA GeForce RTX 5060 Ti, 2 = NVIDIA GeForce RTX 3060
    

    After running setup without params new engine is building correctly, but the same issue when running again ./setup.sh --setup --gpus 0,1 --layer-split auto

      The engine's source changed: compiling it again (only what changed, a few minutes) ...
      > /usr/bin/cmake -G Ninja -DCMAKE_MAKE_PROGRAM=/home/mike/Programs/Strata/.venv/bin/ninja -S /home/mike/Programs/Strata -B /home/mike/Programs/Strata/build -DCMAKE_BUILD_TYPE=Release -DSTRATA_ENABLE_CUDA=ON -DSTRATA_BUILD_TESTS=OFF -DCMAKE_CUDA_ARCHITECTURES=120 -DCMAKE_CUDA_COMPILER=/usr/local/cuda-13.3/bin/nvcc -DSTRATA_GGML_DIR=/home/mike/Programs/Strata/third_party/llama.cpp
    -- Strata: CUDA enabled, arch 120
    -- strata: pack/full/experts.bin absent - the expert arena load test is NOT registered
    -- Warning: ccache not found - consider installing it for faster compilation or disable this warning with GGML_CCACHE=OFF
    -- CMAKE_SYSTEM_PROCESSOR: x86_64
    -- GGML_SYSTEM_ARCH: x86
    -- Including CPU backend
    -- x86 detected
    -- Adding CPU backend variant ggml-cpu: -march=native 
    -- ggml version: 0.24.0
    -- ggml commit:  f1b1d96
    -- Configuring done (0.1s)
    -- Generating done (0.0s)
    -- Build files have been written to: /home/mike/Programs/Strata/build
      > /usr/bin/cmake --build /home/mike/Programs/Strata/build --target strata -j 7
    
  4. ymja commented on Sep 29, 2026

    @ymja

    Same issue with 5080+3090 combo in Win11.

    All looks fine (both cards "detected") in the setup just as in the logs above but the script stops at "there is no GPU [0, 1]"

  5. pdsmike commented on Sep 29, 2026

    @pdsmike

    Quick fix

    insert these two lines after the ], closing lib_dirs in the_model.json (strata-swift-iq3_xxs.json)
    "gpu": [0, 1],
    "layer_split": "auto",

    before "port" and use
    ./run-the_model.sh:

    "lib_dirs": [
    "/usr/local/cuda-13.3/bin",
    "/usr/local/cuda-13.3/lib64"
    ],
    "gpu": [0, 1],
    "layer_split": "auto",

    "port": 8080
    }

  6. Niko1221 commented on Sep 29, 2026

    @Niko1221
    Owner

    Thanks @megakilo, @sal7g86 and @pdsmike - confirmed and fixed for the next release.

    In 0.1.21, --gpus 0,1 stops at the end of setup ("there is no GPU [0, 1]"), on Linux and Windows alike: the
    calibration lookup that runs last didn't expect a list of GPUs. Until the release, the workaround is the one
    @megakilo found: set up with one GPU, then put "gpu": [0, 1] and "layer_split": "auto" in the model's
    strata-*.json and start it again.

    In the next release you won't need any flags:

    • setup lists your cards and says which ones Strata can use (and why not, e.g. older than RTX 30);
    • when two or more can share the model it asks which to use, with the two best together recommended;
    • a model installed on one card asks once at its next start whether to use both;
    • --gpus 0,1, --gpus all or --gpu 0,1 also work at any start, and are remembered;
    • --calibrate measures the split as it runs;
    • the Monitor shows every card: total VRAM, power and load, and each card's own reading underneath.

    Tested on a Windows PC with an RTX 5080, RTX 2080 Ti and RTX 3090 (the 2080 Ti is refused with its reason). I don't
    have a Linux PC with several GPUs; if you can try the release on yours, that would confirm the Linux side.

  7. Niko1221 commented on Sep 29, 2026

    @Niko1221
    Owner

    Fixed in 0.1.22 (released today): --gpus 0,1 no longer stops at the end of setup, --gpus also works on an installed model, setup asks which GPUs to use without any flag, --calibrate measures the split, and the Monitor shows every card. Thank you @megakilo, @sal7g86 and @pdsmike. I tested it on Windows only (the Linux setup is the same code); if the Linux run doesn't work for you, please reopen with the output.

  8. sal7g86 commented on Sep 29, 2026

    @sal7g86

    @Niko1221, doesn't work :

    
    $ ./setup.sh --setup 
    Strata - Qwen3.8-Flash-Next on a normal PC (NVIDIA GPU + system RAM + CPU)
    
    === Step 1: checking your PC ===
      Your NVIDIA GPUs:
        GPU 0: NVIDIA GeForce RTX 5070, 12 GB VRAM - can be used
        GPU 1: NVIDIA GeForce RTX 3060, 12 GB VRAM - can be used
    
      Strata can run the model on one GPU, or share it across both: then each card holds the
      experts of its own layers, so together they hold about twice as many, and prompts are read about 20%
      faster (details: docs/MULTI_GPU.md). A much slower extra card can also make it slower.
      1) GPU 0 (NVIDIA GeForce RTX 5070, 12 GB) + GPU 1 (NVIDIA GeForce RTX 3060, 12 GB) together   (recommended)
      2) GPU 0 (NVIDIA GeForce RTX 5070, 12 GB) only
      3) GPU 1 (NVIDIA GeForce RTX 3060, 12 GB) only
    Which GPUs? [1]: 
      [ok] GPUs: GPU 0 (NVIDIA GeForce RTX 5070, 12 GB) + GPU 1 (NVIDIA GeForce RTX 3060, 12 GB) together (the model's layers are split across them)
      [ok] GPU: NVIDIA GeForce RTX 5070, 11.9 GB VRAM, compute capability 12.0, driver 615.71.09
      [ok] RAM: 63 GB
      [ok] CPU: 13th Gen Intel(R) Core(TM) i7-13700F (AVX2)
    
    === Step 2: your choices ===
      1) Qwen3.8-Flash-Next   Qwen; GSQ-RCO quants by ISTA-DASLab - the original model
      2) Swift 1.5            UkisAI's fine-tune of Qwen3.8-Flash-Next - thinks much shorter (-63% thinking tokens, 1.8x sooner answers by its authors' numbers)
      3) Qwen3.8-Flash-Next Coder ISTA-DASLab's coding version - half the experts (code, tools, images kept): needs ~32 GB of RAM, faster; weaker outside coding
    Which model? [1]: 
      [ok] model: Qwen3.8-Flash-Next
    
      1) Q2_0     2-bit, the fastest; download 66 GB, uses ~34 GB of RAM
      2) IQ2_XS   2-bit i-quant, a little better quality, close in speed; download 68 GB, uses ~36 GB of RAM
      3) IQ3_XXS  3-bit i-quant, better quality, slower (more CPU work per token); download 76 GB, uses ~43 GB of RAM
      4) IQ3_S    3.5-bit i-quant, the best quality (matches the full model), the slowest; needs a 64 GB PC with little else running; download 84 GB, uses ~50 GB of RAM
    Which size? [3]: 4
      [ok] size: IQ3_S
    
      Context length = how much text the model can see at once (your chat, files, tool output).
      Longer needs more VRAM for it, so fewer experts fit on the GPU:
      1) 8K tokens
      2) 32K tokens   (recommended for your GPU)
      3) 64K tokens
      4) 128K tokens
      5) 256K tokens
    Context? [2]: 4
      [ok] context: 131072 tokens
    
      KV cache precision (the model's memory of the conversation):
      1) 8-bit   (recommended: what every published number was measured with)
      2) 4-bit   half the memory (about 4% faster at 128K), but measurably less precise on long
                 documents; long-context lookups (needle tests) still pass
    KV cache? [1]: 
      [ok] KV cache: 8-bit
    
      Images: the model can also read pictures (screenshots, photos, scanned pages). This adds a 0.9 GB
      download and keeps ~1.4 GB of VRAM free for the image encoder, so text is a few % slower.
    Do you want images? [n]: 
      [ok] images: off
    
      EXPERIMENTAL - speed projection: a small control vector applied while the model runs (layers 4-44).
      It changes how the model answers: its package describes it as a refusal-direction projection (the
      model declines far fewer requests). Off unless you choose it; when on, the web app can switch it off
      per chat. Details: data/experimental-speed-projection/README.md
    Turn on the experimental speed projection? [n]: 
      [ok] experimental speed projection: off
    
    === Step 3: Python packages ===
      [ok] numpy, jinja2, regex, pyyaml, tqdm, requests, cmake, ninja, pillow, psutil already installed
    
    === Step 4: the Strata engine ===
      [ok] llama.cpp 3cf0325 (gguf-py, ggml, mtmd)
      [ok] ready-made engine already installed
      [ok] engine: /media/sal/LLM/Strata/engine/strata
    
    === Step 5: downloading Qwen3.8-Flash-Next IQ3_S ===
      [ok] Qwen3.8-Flash-Next-GSQ-RCO-IQ3_S-00001-of-00002.gguf already downloaded
      [ok] Qwen3.8-Flash-Next-GSQ-RCO-IQ3_S-00002-of-00002.gguf already downloaded
      [ok] model files present
    
    === Step 6: preparing the model for Strata ===
      [ok] model prepared: /media/sal/LLM/Strata-data/packs/iq3_s
      [ok] MTP draft layer: /media/sal/LLM/Strata-data/mtp/rt
    
    === Step 7: writing the start script ===
      [ok] layer split across GPUs [0, 1] (auto)
    Tune Strata for this PC now? It measures a few engine settings (about 5-10 minutes; the PC is busy meanwhile; later: START-HERE --calibrate) [y]: y
    
      Tuning Strata for this PC: the output speed is measured with a few engine settings (the PCIe share, the
      draft depth, the CPU threads). It takes about 5-10 minutes; the PC is busy meanwhile.
      Loading the model for the measurements ...
    [strata] starting the engine: reading the model's weights ...
      [!]  the tuning did not finish (the engine exited before it was ready (see /media/sal/LLM/Strata/strata-iq3_s.log)): the default settings stay
      [ok] start script: run-iq3_s.sh
    
    All set.
      API (OpenAI):     http://127.0.0.1:8080/v1   (any API key; model name: anything)
      API (Anthropic):  http://127.0.0.1:8080/v1/messages
      Next time:        just run ./setup.sh (or run-iq3_s.sh) - it starts right away
      [ok] GPUs: GPU 0 (NVIDIA GeForce RTX 5070, 12 GB) + GPU 1 (NVIDIA GeForce RTX 3060, 12 GB) together (layers split auto)
    
      ----------------------------------------------------------------------------------------------------
      Starting qwen3.8-flash-next-iq3_s: it loads about 55 GB into RAM and locks part of it for the GPU.
      While it does, YOUR PC CAN BE SLOW OR STOP RESPONDING FOR 1-3 MINUTES (longer the first time after a
      restart). That is normal: please wait and don't close this window - the browser opens when it is ready.
      Later, closing this window stops the model.
      ----------------------------------------------------------------------------------------------------
    loading the model (the first start takes a minute or two) ...
    [strata] layer split across GPUs [0, 1] (auto)
    [strata] starting the engine: reading the model's weights ...
    Traceback (most recent call last):
      File "/media/sal/LLM/Strata/serve/server.py", line 1616, in <module>
        sys.exit(main())
                 ^^^^^^
      File "/media/sal/LLM/Strata/serve/server.py", line 1548, in main
        engine = StrataEngine(cfg["exe"], engine_args(cfg), cwd=cfg.get("cwd"), log=cfg.get("log"), env=env)
                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
      File "/media/sal/LLM/Strata/serve/server.py", line 182, in __init__
        raise RuntimeError("the engine exited before it was ready" + (f" (see {log})" if log else ""))
    RuntimeError: the engine exited before it was ready (see /media/sal/LLM/Strata/strata-iq3_s.log)
    

    on log:

    unknown argument: --layer-split
    strata generate --pack DIR --tokens "1,2,3" [options]
    
      --pack DIR           the pack directory (default pack/full)
      --tokens LIST        the prompt as comma-separated token IDS (required)
      --tokens-file PATH   pretokenized prompt, commas or whitespace (alternative to --tokens)
      --ple-gguf PATH      required PLE table (original second GGUF shard)
      --no-ple             explicit diagnostic ablation of the PLE layer
      --ple-io direct|mmap  n-gram table reads (plan v0.3 P2). direct (default): unbuffered SSD
                           reads, the table never enters RAM or the file cache; mmap: A/B arm
      --ple-row-cache N    bounded cache of fetched rows, 90 B each (default 1048576; 0 = off)
      --ple-inflight N     outstanding SSD reads (default 64)
      --ple-delay-us U     fault injection: each row read completes no earlier than U us
      --ple-sync-submit    A/B arm: submit table reads on the token thread (default: an I/O thread)
      --kv fp16|int8       KV storage (plan v0.3 P7): int8 codes + fp16 scale per 64 values, half the
                           VRAM; default fp16 until gate G-C accepts int8
      --kv q4_0            4-bit K/V after a Hadamard rotation (PR #21): half of int8's memory,
                           slightly lower precision (see bench/results/2026-09-27-kv-q4)
      --kv-resident N      KV streaming: keep N cells of each QSA layer in VRAM (min 20480) and the
                           whole K/V in pinned RAM; the freed VRAM goes to expert slots. 0 (default):
                           all of it in VRAM. A context of N cells or fewer is not streamed
      --stream-token       enqueue token work on the session stream (experimental)
      --check-logits       copy and check all logits in the stream-token path
      --gr-fp32-activations  experimental CUDA-oracle GR activation precision
      --gr-native-mmvf      experimental pinned GR norm/projections; implies FP32 activations
      --native-bf16         experimental CUDA-oracle SSM/router/indexer BF16 projections
      --native-bf16-extra   experimental CUDA-oracle PLE/shared gate BF16 projections
      --native-ple-key      experimental native PLE key; requires --native-dense-gguf
      --native-moe-combine  experimental pinned CUDA routed/shared combination
      --native-gdn          experimental pinned CUDA GDN norms/gates/recurrence
      --native-flash-attn-short  diagnostic pinned vector attention; --max-context <=256
      --native-qsa-indexer  experimental pinned indexer key cache and pooling
      --native-qsa          experimental pinned QSA normalization and output gate
      --native-rope         experimental pinned text-only CUDA rotary arithmetic
      --native-ple-postops  experimental pinned PLE postprojection arithmetic
      --native-router       experimental pinned CUDA 512-expert top-10 routing
      --cpu-oracle-q8-0     experimental pinned CPU expert quantization and dot reduction
      --native SHARD1      every full-context native path at once (plan v0.3 P1): stream-token,
                           GR MMVF, BF16, head, dense + PLE key, MoE combine, GDN, router, QSA,
                           indexer, RoPE, PLE postops, and the CPU q8_0 contract unless the
                           expert cache is on. Individual --native-* flags stay for A/B.
      --native-head-gguf PATH  native Q5_K head from model shard 1; requires --stream-token
      --native-dense-gguf PATH native GDN/QSA/shared projections; repeat for each source model shard
      --expert-cache-cpu-order  experimental GPU expert reduction matching CPU order
      --max-new N          tokens to generate (default 16)
      --max-context N      KV/state capacity (default 4096)
      --greedy             argmax (the default)
      --seed S             enable sampling with this Philox seed
      --top-k N --top-p F --temperature F
      --dump-logits PATH   write one line of raw logits per position
      --logits-stride N    store every Nth row plus final input (default 1); N>1 requires --max-new 1
      --dump-residual PATH write the final R (hc x n_embd, f32) for head bisection
      --dump-layers PATH   write R after EVERY layer, per position: the C1 bisection ladder
      --dump-halves PATH   write both halves' block_out and inject per layer: the half bisection
      --dump-routing PATH  write the routed expert ids and weights per layer per position (P0.S8)
      --no-capture         run the layers directly instead of replaying graphs
      --shared-late        A/B: shared expert after the CPU pool (default: overlapped with it)
      --keep-canonical     A/B: also load canonical copies of natively served tensors (more VRAM)
      --vision             --serve takes images too (GENI requests; embeddings from strata-vision)
      --prompt-cache N     --serve: keep N conversation checkpoints between requests (default 6, ~118 MB
                           of RAM each; 0 = read every prompt from the start)
      --prompt-cache-every N  --serve: also checkpoint every N fresh prompt tokens (default 16384, 0 = off)
      --turn-token ID      --serve: the token that opens a chat turn (default 248045, <|im_start|>)
      --short-read N       --serve: read at most N fresh text tokens through the decode windows instead
                           of the batched prompt path (default 64, 0 = off)
      --suffix-draft N     prompt lookup: draft from an earlier repeat of the last N+ tokens of context
                           when it pays (default 3; 0 = MTP only)
      --mtp-max-t M        cap the MTP's windows at M tokens (0 = --spec; longer ones come from suffixes)
      --control-vector-scaled FILE:SCALE[,...]  a control vector GGUF on the residual stream (llama.cpp's
                           format; --control-vector FILE = scale 1).  --serve: requests switch it (cvec=0|1)
      --control-vector-layer-range A B  the layers it follows (inclusive; default 1 .. the last)
      --cvec-mode add|project  h += s v (default) or h -= s (h.v) v with v unit
      --cvec-dir per-layer|single:L  each layer's own direction (default) or layer L's everywhere (project)
      --no-token-graph     A/B: two graphs per layer (the host launches each) instead of one per token
      --no-fused-gr        A/B: the six-kernel hyper-connection read and a separate write (native)
      --prefill CHUNK      batched prompt processing in chunks of CHUNK tokens (needs --native); auto =
                           the largest chunk up to 8192 whose buffers the expert cache can lend
      --no-pool            skip the CPU expert pool (the GPU-only floor)
      --sync-every-layer   debug: synchronise after every layer
      --ple-gguf PATH      the n-gram/PLE shard.  WITHOUT IT LAYER 1's PLE IS SILENTLY SKIPPED,
                           which changes every number downstream - pass it for any real run
      --dump-mixed PATH    write the post-attention residual (n_embd, f32)
      --stage-timing       per-stage KERNEL-COUNT shares.  NOT a time profile: an uncaptured
                           event interval includes host gaps, so run with --gpu-only-full first
      --graph-only         MEASURE: replay the 48 `pre` graphs only.  OMITS the 48 `post` graphs
                           and the LM head, so it is NOT the GPU floor (R0.3, Memory/ERRORS.md A4)
      --gpu-only-full      MEASURE: replay pre+post for all 48 layers plus the LM head, no pool.
                           THE TRUE PER-TOKEN GPU FLOOR.  Quote this one, not --graph-only.
      --stats              print the per-stage breakdown
      --gpu-stages         R0.9: capture the layer as three graphs (mixer / ffn+router / post)
                           and time them from OUTSIDE the capture.  The per-stage table on the
                           real graph that --stage-timing cannot give.  Prints and exits.
      --expert-profile P   R4.2e: pre-load the VRAM tier from a `profile.bin` (see
                           tools/make_profile.py) instead of admitting on first use.
      --no-hit-poke        R4.2d's A/B arm.  The hit path pokes the driver once right after its
                           launch so the GPU starts while the CPU pool runs; without it the work
                           waits for the next driver entry and does not overlap at all.
      --no-ple-prefetch     A/B arm: read the PLE table's sixteen rows one at a time, instead of
                           issuing them in one PrefetchVirtualMemory call.
      --expert-cache N     R4: keep N expert blobs resident in VRAM and compute their rows on the
                           GPU via `moe_hit_grouped_s2`.  DEFAULT 0.  Measured at 4096 slots
                           with --expert-cache-per-layer: 54.4% hits, CPU pool drain 19.1 -> 10.3
                           ms/token, -2.7 ms/token end to end.
      --expert-cache-per-layer  R4.2g: give each layer its OWN slots instead of letting the first
                           position take all of them.  The default policy fills in arrival order
                           from one shared counter, so 256 slots went to ~26 layers of position 0
                           and measured **2.97%**.  Per-layer, the same routing gives 21.4% at 8
                           slots/layer and 70.4% at 64.
      --no-host-worker     R2.2: the A/B arm.  By default the HOST THREAD joins the drain, so the
                           pool is six threads on six cores instead of five plus an idle core;
                           this flag restores the five-worker form for comparison on `pool phases`.
      --pool-workers N     R2.2: CPU expert pool worker count.  Default 0 = every physical core
                           except the one the host loop spins on.  A sweep is how the pool's
                           deviation from `cpu_s2` is attributed.
      --mmap-experts       R2.1: opt OUT of the resident expert arena, back to MapViewOfFile.
                           The A/B arm: the mmap's rate depends on the OS page cache holding
                           34 GB, and measured 71.97 vs 34.78 ms/token cold vs warm.
    

    I rerun without --setup

    $ ./setup.sh 
    Strata - Qwen3.8-Flash-Next on a normal PC (NVIDIA GPU + system RAM + CPU)
      [ok] build tools present (CUDA 13.4)
      The engine's source changed: compiling it again (only what changed, a few minutes) ...
      > /usr/bin/cmake -G Ninja -DCMAKE_MAKE_PROGRAM=/usr/bin/ninja -S /media/sal/LLM/Strata -B /media/sal/LLM/Strata/build -DCMAKE_BUILD_TYPE=Release -DSTRATA_ENABLE_CUDA=ON -DSTRATA_BUILD_TESTS=OFF -DCMAKE_CUDA_ARCHITECTURES=120 -DCMAKE_CUDA_COMPILER=/usr/local/cuda/bin/nvcc -DSTRATA_GGML_DIR=/media/sal/LLM/Strata/third_party/llama.cpp
    -- Strata: CUDA enabled, arch 120
    -- strata: pack/full/experts.bin absent - the expert arena load test is NOT registered
    -- ccache found, compilation results will be cached. Disable with GGML_CCACHE=OFF.
    -- CMAKE_SYSTEM_PROCESSOR: x86_64
    -- GGML_SYSTEM_ARCH: x86
    -- Including CPU backend
    -- x86 detected
    -- Adding CPU backend variant ggml-cpu: -march=native 
    -- ggml version: 0.24.0
    -- ggml commit:  a751715
    -- Configuring done (0.1s)
    -- Generating done (0.0s)
    -- Build files have been written to: /media/sal/LLM/Strata/build
      > /usr/bin/cmake --build /media/sal/LLM/Strata/build --target strata -j 12
    [5/121] Building CUDA object CMakeFiles/strata_kernels.dir/src/kernels/cuda/s2_gemv_quads.cu.o
    /media/sal/LLM/Strata/src/kernels/cuda/s2_gemv_quads.cu(31): warning #177-D: variable "strata::kernels::<unnamed>::CODES_PER_BYTE_S2" was declared but never referenced
      constexpr int CODES_PER_BYTE_S2 = 4;
                    ^
    
    Remark: The warnings can be suppressed with "-diag-suppress <warning-number>"
    
    [7/121] Building CXX object CMakeFiles/strata_core.dir/src/core/weights.cpp.o
    /media/sal/LLM/Strata/src/core/weights.cpp: In member function ‘bool strata::core::WeightTable::load(const std::string&, void*, uint64_t, std::string&, const std::set<std::__cxx11::basic_string<char> >*)’:
    /media/sal/LLM/Strata/src/core/weights.cpp:144:51: warning: format ‘%llu’ expects argument of type ‘long long unsigned int*’, but argument 6 has type ‘uint64_t*’ {aka ‘long unsigned int*’} [-Wformat=]
      144 |                                   "%255s %d %d %llu %llu %llu %llu %lld %lld %d %d %d %d %d %llu %llu %llu %d %d",
          |                                                ~~~^
          |                                                   |
          |                                                   long long unsigned int*
          |                                                %lu
      145 |                                   name, &r.file, &kind, &r.src_off, &r.src_bytes, &r.dst_off, &r.dst_bytes,
          |                                                         ~~~~~~~~~~
          |                                                         |
          |                                                         uint64_t* {aka long unsigned int*}
    /media/sal/LLM/Strata/src/core/weights.cpp:144:56: warning: format ‘%llu’ expects argument of type ‘long long unsigned int*’, but argument 7 has type ‘uint64_t*’ {aka ‘long unsigned int*’} [-Wformat=]
      144 |                                   "%255s %d %d %llu %llu %llu %llu %lld %lld %d %d %d %d %d %llu %llu %llu %d %d",
          |                                                     ~~~^
          |                                                        |
          |                                                        long long unsigned int*
          |                                                     %lu
      145 |                                   name, &r.file, &kind, &r.src_off, &r.src_bytes, &r.dst_off, &r.dst_bytes,
          |                                                                     ~~~~~~~~~~~~
          |                                                                     |
          |                                                                     uint64_t* {aka long unsigned int*}
    /media/sal/LLM/Strata/src/core/weights.cpp:144:61: warning: format ‘%llu’ expects argument of type ‘long long unsigned int*’, but argument 8 has type ‘uint64_t*’ {aka ‘long unsigned int*’} [-Wformat=]
      144 |                                   "%255s %d %d %llu %llu %llu %llu %lld %lld %d %d %d %d %d %llu %llu %llu %d %d",
          |                                                          ~~~^
          |                                                             |
          |                                                             long long unsigned int*
          |                                                          %lu
      145 |                                   name, &r.file, &kind, &r.src_off, &r.src_bytes, &r.dst_off, &r.dst_bytes,
          |                                                                                   ~~~~~~~~~~
          |                                                                                   |
          |                                                                                   uint64_t* {aka long unsigned int*}
    /media/sal/LLM/Strata/src/core/weights.cpp:144:66: warning: format ‘%llu’ expects argument of type ‘long long unsigned int*’, but argument 9 has type ‘uint64_t*’ {aka ‘long unsigned int*’} [-Wformat=]
      144 |                                   "%255s %d %d %llu %llu %llu %llu %lld %lld %d %d %d %d %d %llu %llu %llu %d %d",
          |                                                               ~~~^
          |                                                                  |
          |                                                                  long long unsigned int*
          |                                                               %lu
      145 |                                   name, &r.file, &kind, &r.src_off, &r.src_bytes, &r.dst_off, &r.dst_bytes,
          |                                                                                               ~~~~~~~~~~~~
          |                                                                                               |
          |                                                                                               uint64_t* {aka long unsigned int*}
    /media/sal/LLM/Strata/src/core/weights.cpp:144:71: warning: format ‘%lld’ expects argument of type ‘long long int*’, but argument 10 has type ‘int64_t*’ {aka ‘long int*’} [-Wformat=]
      144 |                                   "%255s %d %d %llu %llu %llu %llu %lld %lld %d %d %d %d %d %llu %llu %llu %d %d",
          |                                                                    ~~~^
          |                                                                       |
          |                                                                       long long int*
          |                                                                    %ld
      145 |                                   name, &r.file, &kind, &r.src_off, &r.src_bytes, &r.dst_off, &r.dst_bytes,
      146 |                                   &r.ne0, &r.ne1, &r.code_bits, &r.code_bias, &r.group_elems, &r.codebook,
          |                                   ~~~~~~                               
          |                                   |
          |                                   int64_t* {aka long int*}
    /media/sal/LLM/Strata/src/core/weights.cpp:144:76: warning: format ‘%lld’ expects argument of type ‘long long int*’, but argument 11 has type ‘int64_t*’ {aka ‘long int*’} [-Wformat=]
      144 |                                   "%255s %d %d %llu %llu %llu %llu %lld %lld %d %d %d %d %d %llu %llu %llu %d %d",
          |                                                                         ~~~^
          |                                                                            |
          |                                                                            long long int*
          |                                                                         %ld
      145 |                                   name, &r.file, &kind, &r.src_off, &r.src_bytes, &r.dst_off, &r.dst_bytes,
      146 |                                   &r.ne0, &r.ne1, &r.code_bits, &r.code_bias, &r.group_elems, &r.codebook,
          |                                           ~~~~~~                            
          |                                           |
          |                                           int64_t* {aka long int*}
    /media/sal/LLM/Strata/src/core/weights.cpp:144:96: warning: format ‘%llu’ expects argument of type ‘long long unsigned int*’, but argument 17 has type ‘uint64_t*’ {aka ‘long unsigned int*’} [-Wformat=]
      144 |                                   "%255s %d %d %llu %llu %llu %llu %lld %lld %d %d %d %d %d %llu %llu %llu %d %d",
          |                                                                                             ~~~^
          |                                                                                                |
          |                                                                                                long long unsigned int*
          |                                                                                             %lu
    ......
      147 |                                   &r.has_offset, &r.codes_bytes, &r.scales_bytes, &r.offset_bytes,
          |                                                  ~~~~~~~~~~~~~~                                 
          |                                                  |
          |                                                  uint64_t* {aka long unsigned int*}
    /media/sal/LLM/Strata/src/core/weights.cpp:144:101: warning: format ‘%llu’ expects argument of type ‘long long unsigned int*’, but argument 18 has type ‘uint64_t*’ {aka ‘long unsigned int*’} [-Wformat=]
      144 |                                   "%255s %d %d %llu %llu %llu %llu %lld %lld %d %d %d %d %d %llu %llu %llu %d %d",
          |                                                                                                  ~~~^
          |                                                                                                     |
          |                                                                                                     long long unsigned int*
          |                                                                                                  %lu
    ......
      147 |                                   &r.has_offset, &r.codes_bytes, &r.scales_bytes, &r.offset_bytes,
          |                                                                  ~~~~~~~~~~~~~~~                     
          |                                                                  |
          |                                                                  uint64_t* {aka long unsigned int*}
    /media/sal/LLM/Strata/src/core/weights.cpp:144:106: warning: format ‘%llu’ expects argument of type ‘long long unsigned int*’, but argument 19 has type ‘uint64_t*’ {aka ‘long unsigned int*’} [-Wformat=]
      144 |                                   "%255s %d %d %llu %llu %llu %llu %lld %lld %d %d %d %d %d %llu %llu %llu %d %d",
          |                                                                                                       ~~~^
          |                                                                                                          |
          |                                                                                                          long long unsigned int*
          |                                                                                                       %lu
    ......
      147 |                                   &r.has_offset, &r.codes_bytes, &r.scales_bytes, &r.offset_bytes,
          |                                                                                   ~~~~~~~~~~~~~~~         
          |                                                                                   |
          |                                                                                   uint64_t* {aka long unsigned int*}
    [12/121] Building CUDA object CMakeFiles/strata_kernels.dir/src/kernels/cuda/shared_expert.cu.o
    /media/sal/LLM/Strata/src/kernels/cuda/shared_expert.cu(71): warning #177-D: function "strata::kernels::<unnamed>::to_f16_kernel" was declared but never referenced
                void to_f16_kernel(const float* __restrict__ in, uint16_t* __restrict__ out, int n) {
                     ^
    
    Remark: The warnings can be suppressed with "-diag-suppress <warning-number>"
    
    [14/121] Building CUDA object CMakeFiles/strata_kernels.dir/src/kernels/cuda/gr.cu.o
    /media/sal/LLM/Strata/src/kernels/cuda/gr.cu(112): warning #177-D: function "strata::kernels::<unnamed>::block_sum" was declared but never referenced
                double block_sum(double v, double* scratch) {
                       ^
    
    Remark: The warnings can be suppressed with "-diag-suppress <warning-number>"
    
    [16/121] Building CUDA object CMakeFiles/strata_kernels.dir/src/kernels/cuda/gdn.cu.o
    /media/sal/LLM/Strata/src/kernels/cuda/gdn.cu(35): warning #177-D: function "strata::kernels::<unnamed>::softplus_f" was declared but never referenced
                                float softplus_f(float x) { return x > 20.0f ? x : log1pf(expf(x)); }
                                      ^
    
    Remark: The warnings can be suppressed with "-diag-suppress <warning-number>"
    
    [66/121] Building CXX object CMakeFiles/strata_engine.dir/src/core/layer.cpp.o
    /media/sal/LLM/Strata/src/core/layer.cpp: In function ‘bool strata::core::moe_layer(const WeightTable&, const ModelGeometry&, int64_t, int64_t, const MoEBuffers&, const float*, const float*, float*, void*, std::string&, const Doorbell*)’:
    /media/sal/LLM/Strata/src/core/layer.cpp:468:1: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation]
      468 | if (!moe_route(tables, g, layer, k, b, x, stream, err, db)) return false;    return moe_finish(tables, g, layer, k, b, x, parts, out, stream, err);}
          | ^~
    /media/sal/LLM/Strata/src/core/layer.cpp:468:78: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’
      468 | if (!moe_route(tables, g, layer, k, b, x, stream, err, db)) return false;    return moe_finish(tables, g, layer, k, b, x, parts, out, stream, err);}
          |                                                                              ^~~~~~
    /media/sal/LLM/Strata/src/core/layer.cpp: In function ‘bool strata::core::qsa_layer(const WeightTable&, const ModelGeometry&, int64_t, int64_t, int32_t, const QsaState&, const QsaBuffers&, const float*, float*, void*, std::string&, float*)’:
    /media/sal/LLM/Strata/src/core/layer.cpp:861:1: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation]
      861 | if (!gemv_quantized(*w_attnk, p_k, f_k, b.x_q8_0, b.x_q8k, b.kcur, g.n_embd, g.n_head_kv * g.head_dim,                        v.name("attn_k.weight"), stream, err, x)) return false;    if (!gemv_quantized(*w_attnv, p_v, f_v, b.x_q8_0, b.x_q8k, b.vcur, g.n_embd, g.n_head_kv * g.head_dim,                        v.name("attn_v.weight"), stream, err, x, w_attnk->native_data && w_attnv->native_data)) return false;    dump_slot(dump, g, layer, b.vcur,                            (uint64_t) 2 * g.n_embd + 2 * g.hc + (uint64_t) g.n_head * g.head_dim,                            (uint64_t) g.n_head_kv * g.head_dim, stream);    if (!normalize_rotate(b.kcur, w_kn, (int) g.n_head_kv, (int) g.head_dim)) return false;
          | ^~
    /media/sal/LLM/Strata/src/core/layer.cpp:861:186: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’
      861 | if (!gemv_quantized(*w_attnk, p_k, f_k, b.x_q8_0, b.x_q8k, b.kcur, g.n_embd, g.n_head_kv * g.head_dim,                        v.name("attn_k.weight"), stream, err, x)) return false;    if (!gemv_quantized(*w_attnv, p_v, f_v, b.x_q8_0, b.x_q8k, b.vcur, g.n_embd, g.n_head_kv * g.head_dim,                        v.name("attn_v.weight"), stream, err, x, w_attnk->native_data && w_attnv->native_data)) return false;    dump_slot(dump, g, layer, b.vcur,                            (uint64_t) 2 * g.n_embd + 2 * g.hc + (uint64_t) g.n_head * g.head_dim,                            (uint64_t) g.n_head_kv * g.head_dim, stream);    if (!normalize_rotate(b.kcur, w_kn, (int) g.n_head_kv, (int) g.head_dim)) return false;
          |                                                                                                                                                                                          ^~
    /media/sal/LLM/Strata/src/core/layer.cpp:910:5: warning: this ‘else’ clause does not guard... [-Wmisleading-indentation]
      910 |     else if (st.kv_int8) kv_gather_q8_step(st.k_q, st.v_q, st.k_scale, st.v_scale, st.page_table, b.ids, st.step, cap, s,                                 b.k_scratch, b.v_scratch, stream);    else kv_gather_step(st.k_pool, st.v_pool, st.page_table, b.ids, st.step, cap, s, b.k_scratch, b.v_scratch,                   stream);    if (native_flash_attn_short) {
          |     ^~~~
    /media/sal/LLM/Strata/src/core/layer.cpp:910:330: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘else’
      910 |     else if (st.kv_int8) kv_gather_q8_step(st.k_q, st.v_q, st.k_scale, st.v_scale, st.page_table, b.ids, st.step, cap, s,                                 b.k_scratch, b.v_scratch, stream);    else kv_gather_step(st.k_pool, st.v_pool, st.page_table, b.ids, st.step, cap, s, b.k_scratch, b.v_scratch,                   stream);    if (native_flash_attn_short) {
          |                                                                                                                                                                                                                                                                                                                                          ^~
    /media/sal/LLM/Strata/src/core/layer.cpp:934:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation]
      934 |     if (!w_attno->native_data) quantize_q8_K(b.attn32, b.attn_q8k, g.n_head * g.head_dim, stream);    if (w_attno->native_data) {
          |     ^~
    /media/sal/LLM/Strata/src/core/layer.cpp:934:103: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’
      934 |     if (!w_attno->native_data) quantize_q8_K(b.attn32, b.attn_q8k, g.n_head * g.head_dim, stream);    if (w_attno->native_data) {
          |                                                                                                       ^~
    /media/sal/LLM/Strata/src/core/layer.cpp:813:774: warning: unused variable ‘n_bid’ [-Wunused-variable]
      813 | bool qsa_layer(const WeightTable& tables, const ModelGeometry& g, int64_t layer, int64_t pos, int32_t pos_base,               const QsaState& st, const QsaBuffers& b, const float* x, float* out, void* stream,               std::string& err, float* dump) {    using namespace strata::kernels;    const QsaShapes s = qsa_shapes(g);    const LayerView v(tables, layer);    const int64_t n_kv = pos + 1;    /* P7 audit: RoPE reads cos/sin row pos_base + pos, and the table holds max_cells rows. */    if ((int64_t) pos_base + pos >= st.max_cells || pos_base < 0) {        err = "qsa_layer: position " + std::to_string((long long) pos_base + pos) + " is outside the RoPE table (" + std::to_string((long long) st.max_cells) + " rows)";        return false;    }    const int64_t n_bid = n_kv / s.idx_block;    const int64_t width = qsa_selection_width(n_kv, s);    const int64_t cap = qsa_selection_width(kTopkMaxCells, s);
          |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ^~~~~
    /media/sal/LLM/Strata/src/core/layer.cpp:813:819: warning: unused variable ‘width’ [-Wunused-variable]
      813 | bool qsa_layer(const WeightTable& tables, const ModelGeometry& g, int64_t layer, int64_t pos, int32_t pos_base,               const QsaState& st, const QsaBuffers& b, const float* x, float* out, void* stream,               std::string& err, float* dump) {    using namespace strata::kernels;    const QsaShapes s = qsa_shapes(g);    const LayerView v(tables, layer);    const int64_t n_kv = pos + 1;    /* P7 audit: RoPE reads cos/sin row pos_base + pos, and the table holds max_cells rows. */    if ((int64_t) pos_base + pos >= st.max_cells || pos_base < 0) {        err = "qsa_layer: position " + std::to_string((long long) pos_base + pos) + " is outside the RoPE table (" + std::to_string((long long) st.max_cells) + " rows)";        return false;    }    const int64_t n_bid = n_kv / s.idx_block;    const int64_t width = qsa_selection_width(n_kv, s);    const int64_t cap = qsa_selection_width(kTopkMaxCells, s);
          |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   ^~~~~
    /media/sal/LLM/Strata/src/core/layer.cpp: In function ‘bool strata::core::block_layer_pre(const WeightTable&, const ModelGeometry&, int64_t, int64_t, int32_t, const GdnBuffers&, const QsaState&, const QsaBuffers&, const MoEBuffers&, int64_t, const BlockBuffers&, void*, std::string&, const Doorbell*, const PleRun*, int, int)’:
    /media/sal/LLM/Strata/src/core/layer.cpp:1119:23: warning: unused variable ‘hcd’ [-Wunused-variable]
     1119 |         const int64_t hcd = strata::kernels::NG_HC_DIM;
          |                       ^~~
    /media/sal/LLM/Strata/src/core/layer.cpp: In function ‘bool strata::core::block_layer(const WeightTable&, const ModelGeometry&, int64_t, int64_t, int32_t, const GdnBuffers&, const QsaState&, const QsaBuffers&, const MoEBuffers&, int64_t, const BlockBuffers&, const float*, void*, std::string&, const Doorbell*, const PleRun*)’:
    /media/sal/LLM/Strata/src/core/layer.cpp:1269:1: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation]
     1269 | if (!block_layer_pre(tables, g, layer, pos, pos_base, gb, qst, qb, mb, k, bb, stream, err, db, ple))        return false;    return block_layer_post(tables, g, layer, k, mb, bb, parts, stream, err);}}
          | ^~
    /media/sal/LLM/Strata/src/core/layer.cpp:1269:126: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’
     1269 | if (!block_layer_pre(tables, g, layer, pos, pos_base, gb, qst, qb, mb, k, bb, stream, err, db, ple))        return false;    return block_layer_post(tables, g, layer, k, mb, bb, parts, stream, err);}}
          |                                                                                                                              ^~~~~~
    [109/121] Building CXX object CMakeFiles/strata_engine.dir/src/core/verify.cpp.o
    /media/sal/LLM/Strata/src/core/verify.cpp: In static member function ‘static void strata::core::Verifier::raise_flag(uint32_t*, uint32_t)’:
    /media/sal/LLM/Strata/src/core/verify.cpp:963:20: warning: unused variable ‘f’ [-Wunused-variable]
      963 |     volatile long* f = (volatile long*) flag;
          |                    ^
    [120/121] Building CXX object CMakeFiles/strata.dir/src/program/generate.cpp.o
    /media/sal/LLM/Strata/src/program/generate.cpp:671:5: warning: ‘int {anonymous}::argmax(const std::vector<float>&)’ defined but not used [-Wunused-function]
      671 | int argmax(const std::vector<float>& v) {
          |     ^~~~~~
    [121/121] Linking CXX executable strata
      [ok] engine compiled: /media/sal/LLM/Strata/engine/strata
      [ok] GPUs: GPU 0 (NVIDIA GeForce RTX 5070, 12 GB) + GPU 1 (NVIDIA GeForce RTX 3060, 12 GB) together (layers split auto)
    
      ----------------------------------------------------------------------------------------------------
      Starting qwen3.8-flash-next-iq3_s: it loads about 55 GB into RAM and locks part of it for the GPU.
      While it does, YOUR PC CAN BE SLOW OR STOP RESPONDING FOR 1-3 MINUTES (longer the first time after a
      restart). That is normal: please wait and don't close this window - the browser opens when it is ready.
      Later, closing this window stops the model.
      ----------------------------------------------------------------------------------------------------
    loading the model (the first start takes a minute or two) ...
    [strata] layer split across GPUs [0, 1] (auto)
    [strata] starting the engine: reading the model's weights ...
    [strata] loading the experts into RAM (about 55 GB) and locking part of them for the GPU.
             YOUR PC CAN BE SLOW OR STOP RESPONDING FOR 1-3 MINUTES NOW - this is normal.
             Please wait and don't close this window; the browser opens when it is ready.
    [strata] experts loaded: 46.84 GiB at 3.15 GiB/s (21 s so far)
    [strata] filling the GPU's expert cache (1929 experts, 3.68 GiB of VRAM) ...
    [strata] almost ready ...
    Traceback (most recent call last):
      File "/media/sal/LLM/Strata/serve/server.py", line 1616, in <module>
        sys.exit(main())
                 ^^^^^^
      File "/media/sal/LLM/Strata/serve/server.py", line 1548, in main
        engine = StrataEngine(cfg["exe"], engine_args(cfg), cwd=cfg.get("cwd"), log=cfg.get("log"), env=env)
                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
      File "/media/sal/LLM/Strata/serve/server.py", line 182, in __init__
        raise RuntimeError("the engine exited before it was ready" + (f" (see {log})" if log else ""))
    RuntimeError: the engine exited before it was ready (see /media/sal/LLM/Strata/strata-iq3_s.log)
    sal@sal-PC:/media/sal/LLM/Strata$ 
    

    on log:

    strata generate: layer split across 2 GPUs: CUDA0, then CUDA1 (split auto)
    strata generate: PCIe probe: 28.3 GB/s host->device -> pcie_frac 0.55 (default 0.55)
    strata generate: this CPU has no AVX-512: the expert kernels run on AVX-2 (multi-token for the i-quant gate/up rows)
    strata generate: native pack: /media/sal/LLM/Strata-data/packs/iq3_s experts (largest blob 2.66 MB), token embedding type 23 in mapped host memory (322 MiB)
    strata generate: 1466 MiB of weights loaded from /media/sal/LLM/Strata-data/packs/iq3_s (302 canonical tensors skipped: served natively)
    strata generate: 300 native projection matrices, 2018.88 MiB of weights
    strata generate: PLE on, table 320001536 rows of /media/sal/LLM/Strata-data/models/IQ3_S/Qwen3.8-Flash-Next-GSQ-RCO-IQ3_S-00002-of-00002.gguf
    strata generate: layer split: CUDA1 PCIe probe 6.6 GB/s -> pcie_frac 0.14
    strata generate: layer split: CUDA1 holds its weights, session and head; 5.14 GiB free
    strata mtp: draft layer loaded, 950 MiB of VRAM (experts 675, dense 111)
    strata generate: expert arena: mlock failed (raise ulimit -l); cudaHostRegister limited to 8 GiB for CUDA1; 8 slices pinned (7 GiB); MAP_HUGETLB unavailable (no hugetlb pool configured?); using 4 KB pages
    strata generate: loaded 46.84 GiB at 3.16 GiB/s
    strata generate: profile /media/sal/LLM/Strata/data/expert-profile.bin: 24576 ranked pairs, built for 24576 slots
    strata generate: layer split auto: CUDA0 48 SMs at 2.56 GHz -> 0.59 ms per layer, 3.68 GiB for experts
    strata generate: layer split auto: CUDA1 28 SMs at 1.84 GHz -> 1.41 ms per layer, 0.99 GiB for experts
    strata generate: layer split auto: K=47 - predicted 45.6 ms per decode window; the caches hold 2327 of 24576 profiled pairs (~91.4% of the routed mass)
    strata generate: expert cache auto: 5.85 GiB free, 700 MiB reserved -> 1485 slots
    strata generate: expert cache 1929 slots, 3.68 GiB of VRAM; policy is
    strata generate: the GPU computes the experts in the cache; it rounds differently from the CPU,
                     so a reply can differ slightly from a run without the cache (same quality:
                     bench/results/2026-09-27-cache-parity).
                     PROFILE, ranked by routing frequency, no eviction.
    strata generate: pre-filled 1929 of 1929 slots from the profile; slot 0 verified
    strata generate: layer split: CUDA1 runs layers 47-47, expert cache 398 slots (0.99 GiB), 398 of its 512 profiled pairs; slot 0 verified
    strata generate: layer split: CUDA0 runs layers 0-46
    strata generate: R4 hit path ON - resident experts are computed on the GPU
    strata generate: 15 expert-pool workers + the host thread
    strata generate: session is up (engine 0.1.22)
    strata generate: token graph hit path: 2327 resident experts, decided on the device
    strata serve: the prompt path allocates its own buffers (too few cache slots to borrow)
    strata verify: window up to 6 tokens, 74.7 MiB of device buffers
    strata serve: layer split: layers 0-46 (CUDA0), 47-47 (CUDA1), one hand-off per window
    strata verify: window up to 6 tokens, 74.7 MiB of device buffers
    gather_rows: no kernel image is available for execution on the device
    strata generate: layer split across 2 GPUs: CUDA0, then CUDA1 (split auto)
    strata generate: PCIe probe: 26.4 GB/s host->device -> pcie_frac 0.55 (default 0.55)
    strata generate: this CPU has no AVX-512: the expert kernels run on AVX-2 (multi-token for the i-quant gate/up rows)
    strata generate: native pack: /media/sal/LLM/Strata-data/packs/iq3_s experts (largest blob 2.66 MB), token embedding type 23 in mapped host memory (322 MiB)
    strata generate: 1466 MiB of weights loaded from /media/sal/LLM/Strata-data/packs/iq3_s (302 canonical tensors skipped: served natively)
    strata generate: 300 native projection matrices, 2018.88 MiB of weights
    strata generate: PLE on, table 320001536 rows of /media/sal/LLM/Strata-data/models/IQ3_S/Qwen3.8-Flash-Next-GSQ-RCO-IQ3_S-00002-of-00002.gguf
    strata generate: layer split: CUDA1 PCIe probe 6.6 GB/s -> pcie_frac 0.14
    strata generate: layer split: CUDA1 holds its weights, session and head; 5.08 GiB free
    strata mtp: draft layer loaded, 950 MiB of VRAM (experts 675, dense 111)
    strata generate: expert arena: mlock failed (raise ulimit -l); cudaHostRegister limited to 8 GiB for CUDA1; 8 slices pinned (7 GiB); MAP_HUGETLB unavailable (no hugetlb pool configured?); using 4 KB pages
    strata generate: loaded 46.84 GiB at 3.19 GiB/s
    strata generate: profile /media/sal/LLM/Strata/data/expert-profile.bin: 24576 ranked pairs, built for 24576 slots
    strata generate: layer split auto: CUDA0 48 SMs at 2.56 GHz -> 0.59 ms per layer, 3.68 GiB for experts
    strata generate: layer split auto: CUDA1 28 SMs at 1.84 GHz -> 1.41 ms per layer, 0.95 GiB for experts
    strata generate: layer split auto: K=47 - predicted 45.6 ms per decode window; the caches hold 2313 of 24576 profiled pairs (~91.4% of the routed mass)
    strata generate: expert cache auto: 5.85 GiB free, 700 MiB reserved -> 1485 slots
    strata generate: expert cache 1929 slots, 3.68 GiB of VRAM; policy is
    strata generate: the GPU computes the experts in the cache; it rounds differently from the CPU,
                     so a reply can differ slightly from a run without the cache (same quality:
                     bench/results/2026-09-27-cache-parity).
                     PROFILE, ranked by routing frequency, no eviction.
    strata generate: pre-filled 1929 of 1929 slots from the profile; slot 0 verified
    strata generate: layer split: CUDA1 runs layers 47-47, expert cache 385 slots (0.95 GiB), 385 of its 512 profiled pairs; slot 0 verified
    strata generate: layer split: CUDA0 runs layers 0-46
    strata generate: R4 hit path ON - resident experts are computed on the GPU
    strata generate: 15 expert-pool workers + the host thread
    strata generate: session is up (engine 0.1.22)
    strata generate: token graph hit path: 2314 resident experts, decided on the device
    strata serve: the prompt path allocates its own buffers (too few cache slots to borrow)
    strata verify: window up to 6 tokens, 74.7 MiB of device buffers
    strata serve: layer split: layers 0-46 (CUDA0), 47-47 (CUDA1), one hand-off per window
    strata verify: window up to 6 tokens, 74.7 MiB of device buffers
    gather_rows: no kernel image is available for execution on the device
    strata generate: layer split across 2 GPUs: CUDA0, then CUDA1 (split auto)
    strata generate: PCIe probe: 26.6 GB/s host->device -> pcie_frac 0.55 (default 0.55)
    strata generate: this CPU has no AVX-512: the expert kernels run on AVX-2 (multi-token for the i-quant gate/up rows)
    strata generate: native pack: /media/sal/LLM/Strata-data/packs/iq3_s experts (largest blob 2.66 MB), token embedding type 23 in mapped host memory (322 MiB)
    strata generate: 1466 MiB of weights loaded from /media/sal/LLM/Strata-data/packs/iq3_s (302 canonical tensors skipped: served natively)
    strata generate: 300 native projection matrices, 2018.88 MiB of weights
    strata generate: PLE on, table 320001536 rows of /media/sal/LLM/Strata-data/models/IQ3_S/Qwen3.8-Flash-Next-GSQ-RCO-IQ3_S-00002-of-00002.gguf
    strata generate: layer split: CUDA1 PCIe probe 6.6 GB/s -> pcie_frac 0.14
    strata generate: layer split: CUDA1 holds its weights, session and head; 5.07 GiB free
    strata mtp: draft layer loaded, 950 MiB of VRAM (experts 675, dense 111)
    strata generate: expert arena: mlock failed (raise ulimit -l); cudaHostRegister limited to 8 GiB for CUDA1; 8 slices pinned (7 GiB); MAP_HUGETLB unavailable (no hugetlb pool configured?); using 4 KB pages
    strata generate: loaded 46.84 GiB at 3.21 GiB/s
    strata generate: profile /media/sal/LLM/Strata/data/expert-profile.bin: 24576 ranked pairs, built for 24576 slots
    strata generate: layer split auto: CUDA0 48 SMs at 2.56 GHz -> 0.59 ms per layer, 3.68 GiB for experts
    strata generate: layer split auto: CUDA1 28 SMs at 1.84 GHz -> 1.41 ms per layer, 0.97 GiB for experts
    strata generate: layer split auto: K=47 - predicted 45.6 ms per decode window; the caches hold 2320 of 24576 profiled pairs (~91.4% of the routed mass)
    strata generate: expert cache auto: 5.85 GiB free, 700 MiB reserved -> 1485 slots
    strata generate: expert cache 1929 slots, 3.68 GiB of VRAM; policy is
    strata generate: the GPU computes the experts in the cache; it rounds differently from the CPU,
                     so a reply can differ slightly from a run without the cache (same quality:
                     bench/results/2026-09-27-cache-parity).
                     PROFILE, ranked by routing frequency, no eviction.
    strata generate: pre-filled 1929 of 1929 slots from the profile; slot 0 verified
    strata generate: layer split: CUDA1 runs layers 47-47, expert cache 388 slots (0.96 GiB), 388 of its 512 profiled pairs; slot 0 verified
    strata generate: layer split: CUDA0 runs layers 0-46
    strata generate: R4 hit path ON - resident experts are computed on the GPU
    strata generate: 15 expert-pool workers + the host thread
    strata generate: session is up (engine 0.1.22)
    strata generate: token graph hit path: 2317 resident experts, decided on the device
    strata serve: the prompt path allocates its own buffers (too few cache slots to borrow)
    strata verify: window up to 6 tokens, 74.7 MiB of device buffers
    strata serve: layer split: layers 0-46 (CUDA0), 47-47 (CUDA1), one hand-off per window
    strata verify: window up to 6 tokens, 74.7 MiB of device buffers
    gather_rows: no kernel image is available for execution on the device
    
  9. m-abs commented on Oct 10, 2026

    @m-abs

    Hi @Niko1221

    I think, I have this issue with a 5060 TI 16 VRAM + 3060 12 VRAM on v0.1.42

     > ./update.sh      
    Getting the newest Strata (git pull) ...
    Already up to date.
    Strata - Qwen3.8-Flash-Next on a normal PC (a GPU + system RAM + CPU)
      [ok] numpy, jinja2, regex, pyyaml, tqdm, requests, cmake, ninja, pillow, psutil already installed
      [ok] qwen3.8-flash-next-q2_0: up to date
      [ok] swift-1.5-iq2_xs: up to date
      [ok] qwen3.8-flash-next-coder-iq1_m: up to date
    
      [ok] Strata is updated (engine 0.1.42). Start the model with ./setup.sh when you want it.
     > ./setup.sh --setup 
    Strata - Qwen3.8-Flash-Next on a normal PC (a GPU + system RAM + CPU)
    
    === Step 1: checking your PC ===
      Your NVIDIA GPUs:
        GPU 0: NVIDIA GeForce RTX 5060 Ti, 16 GB VRAM - can be used
        GPU 1: NVIDIA GeForce RTX 3060, 12 GB VRAM - can be used
    
      Strata can run the model on one GPU, or share it across both: then each card holds the
      experts of its own layers, so together they hold about twice as many, and prompts are read about 20%
      faster (details: docs/MULTI_GPU.md). A much slower extra card can also make it slower.
      1) GPU 0 (NVIDIA GeForce RTX 5060 Ti, 16 GB) + GPU 1 (NVIDIA GeForce RTX 3060, 12 GB) together   (recommended)
      2) GPU 0 (NVIDIA GeForce RTX 5060 Ti, 16 GB) only
      3) GPU 1 (NVIDIA GeForce RTX 3060, 12 GB) only
    Which GPUs? [1]: 1
      [ok] GPUs: GPU 0 (NVIDIA GeForce RTX 5060 Ti, 16 GB) + GPU 1 (NVIDIA GeForce RTX 3060, 12 GB) together (the model's layers are split across them)
      [ok] GPU: NVIDIA GeForce RTX 5060 Ti, 15.9 GB VRAM, compute capability 12.0, driver 615.71.09
      [ok] RAM: 63 GB
      [ok] CPU: Intel(R) Core(TM) Ultra 5 235 (AVX2)
      [ok] PCIe: 5.0 x8
    
    === Step 2: your choices ===
      1) Qwen3.8-Flash-Next   Qwen; GSQ-RCO quants by ISTA-DASLab - the original model
      2) Swift 1.5            UkisAI's fine-tune of Qwen3.8-Flash-Next - thinks much shorter (-63% thinking tokens, 1.8x sooner answers by its authors' numbers)
      3) Qwen3.8-Flash-Next Coder ISTA-DASLab's coding version - half the experts (code, tools, images kept): needs ~32 GB of RAM, faster; weaker outside coding
      4) Qwen3.8-Flash-Next (Unsloth) Unsloth's ~4-bit quantizations - UD-IQ4_XS: a 94 GB download; with less than ~80 GB of RAM part of its experts are read from the SSD (UD-Q4_K_XL, 111 GB: experimental)
    Which model? [1]: 1
      [ok] model: Qwen3.8-Flash-Next
    
      1) Q2_0     2-bit, the fastest; download 66 GB, uses ~34 GB of RAM
      2) IQ2_XS   2-bit i-quant, a little better quality, close in speed; download 68 GB, uses ~36 GB of RAM
      3) IQ3_XXS  3-bit i-quant, better quality, slower (more CPU work per token); download 76 GB, uses ~43 GB of RAM
      4) IQ3_S    3.5-bit i-quant, the best quality (matches the full model), the slowest; needs a 64 GB PC with little else running; download 84 GB, uses ~50 GB of RAM
    Which size? [3]: 1
      [ok] size: Q2_0
    
      Context length = how much text the model can see at once (your chat, files, tool output).
      Longer needs more VRAM for it, so fewer experts fit on the GPU:
      1) 8K tokens
      2) 32K tokens   (recommended for your GPU)
      3) 64K tokens
      4) 128K tokens
      5) 200K tokens
      6) 256K tokens
      7) 384K tokens   (experimental: setup adds rope scaling)
      8) 512K tokens   (experimental: setup adds rope scaling)
    Context? [2]: 5
      [ok] context: 204800 tokens
    
      KV cache precision (the model's memory of the conversation):
      1) 8-bit   (recommended: what every published number was measured with)
      2) 4-bit   half the memory (about 4% faster at 128K), but measurably less precise on long
                 documents; long-context lookups (needle tests) still pass
    KV cache? [1]: 2
      [ok] KV cache: 4-bit (Hadamard-rotated)
    
      Images: the model can also read pictures (screenshots, photos, scanned pages). This adds a 0.9 GB
      download and keeps ~1.4 GB of VRAM free for the image encoder, so text is a few % slower.
    Do you want images? [n]: y
      [ok] images: on
    
      EXPERIMENTAL - speed projection: a small control vector applied while the model runs (layers 4-44).
      It changes how the model answers: its package describes it as a refusal-direction projection (the
      model declines far fewer requests). Off unless you choose it; when on, the web app can switch it off
      per chat. Details: data/experimental-speed-projection/README.md
    Turn on the experimental speed projection? [n]: n
      [ok] experimental speed projection: off
    
    === Step 3: Python packages ===
      [ok] numpy, jinja2, regex, pyyaml, tqdm, requests, cmake, ninja, pillow, psutil already installed
    
    === Step 4: the Strata engine ===
      [ok] llama.cpp 3cf0325 (gguf-py, ggml, mtmd)
      [ok] engine already built for this PC
      [ok] engine: /home/mabs/project/Niko1221/Strata/engine/strata
    
    === Step 5: downloading Qwen3.8-Flash-Next Q2_0 ===
      [ok] Qwen3.8-Flash-Next-GSQ-RCO-Q2_0-00001-of-00002.gguf already downloaded
      [ok] Qwen3.8-Flash-Next-GSQ-RCO-Q2_0-00002-of-00002.gguf already downloaded
      [ok] model files present
      [ok] vision encoder already downloaded
      [ok] vision encoder: /home/mabs/project/Niko1221/Strata-data/models/mmproj-Qwen3.8-Flash-Next-BF16.gguf
    
    === Step 6: preparing the model for Strata ===
      [ok] model prepared: /home/mabs/project/Niko1221/Strata-data/packs/q2_0
      [ok] MTP draft layer: /home/mabs/project/Niko1221/Strata-data/mtp/rt
    
    === Step 7: writing the start script ===
      [ok] KV streaming on: the context's KV cache lives in RAM (1.5 GB), more experts fit in VRAM
      [ok] layer split across GPUs [0, 1] (auto)
      [ok] the settings tuned for this PC earlier are used (2026-10-10)
      the earlier run config is kept as strata-q2_0.json.bak
      [ok] start script: run-q2_0.sh
    
    All set.
      API (OpenAI):     http://127.0.0.1:8080/v1   (any API key; model name: anything)
      API (Anthropic):  http://127.0.0.1:8080/v1/messages
      Next time:        just run ./setup.sh (or run-q2_0.sh) - it starts right away
      Images:           send them in the chat page, in chat.py (/image <path>) or over the API
      Several requests at once (opt-in): --parallel 2 decodes up to 2 together instead of one after the other (each takes ~0.4 GB of VRAM from the expert cache; docs/BATCHING.md).
      [ok] GPUs: GPU 0 (NVIDIA GeForce RTX 5060 Ti, 16 GB) + GPU 1 (NVIDIA GeForce RTX 3060, 12 GB) together (layers split auto)
    
      ----------------------------------------------------------------------------------------------------
      Starting qwen3.8-flash-next-q2_0: it loads about 38 GB into RAM and locks part of it for the GPU.
      While it does, YOUR PC CAN BE SLOW OR STOP RESPONDING FOR 1-3 MINUTES (longer the first time after a
      restart). That is normal: please wait and don't close this window - the browser opens when it is ready.
      Later, closing this window stops the model.
      ----------------------------------------------------------------------------------------------------
      Settings (strata-q2_0.json): --expert-cache auto --prefill auto --spec 4 --max-context 204800 --kv
        q4_0 --kv-resident 32768 --vision --vram-reserve-mib 700 --spec-min-p 0.5 --adapt-every 1
        --adapt-swaps 160 --adapt-decay 0.97; server 127.0.0.1:8080, gpu 0,1, layer_split auto
    [strata] layer split: card order 1,0 (the faster card last; "gpu_order": "as_given" keeps 0,1, #1352)
    [strata] layer split: card order 1,0 (the faster card last; "gpu_order": "as_given" keeps 0,1, #1352)
    loading the vision encoder ...
    Traceback (most recent call last):
      File "/home/mabs/project/Niko1221/Strata/serve/server.py", line 6329, in <module>
        sys.exit(main())
                 ~~~~^^
      File "/home/mabs/project/Niko1221/Strata/serve/server.py", line 6106, in main
        vision = Vision(vcfg, log=open(cfg["log"], "a", encoding="utf-8") if cfg.get("log") else None,
                        env=vision_env(cfg, env), lazy=lazy)
      File "/home/mabs/project/Niko1221/Strata/serve/server.py", line 1954, in __init__
        self._start()
        ~~~~~~~~~~~^^
      File "/home/mabs/project/Niko1221/Strata/serve/server.py", line 1976, in _start
        raise RuntimeError(vision_start_error(line, self.spawn[1]))
    RuntimeError: the vision encoder did not start: [New LWP 1355671]
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Metadata

Metadata

Assignees

No one assigned

    Labels

    No labels
    No labels

    Projects

    No projects

      Milestone

      No milestone

      Relationships

      None yet

      Development

      No branches or pull requests

      Issue actions