From 568af25d310e82db15da1154502a4b92cee850a4 Mon Sep 17 00:00:00 2001 From: Niko Maroulis Date: Sun, 1 Nov 2026 21:21:16 -0500 Subject: [PATCH 01/49] RPC: probe the endpoint before registering, upstream registration now aborts on failure --- c_src/llama_cpp_ex/llama_nif.cpp | 149 +++++++++++++++++++++++++++++-- lib/llama_cpp_ex/rpc.ex | 46 +++++----- 2 files changed, 166 insertions(+), 29 deletions(-) diff --git a/c_src/llama_cpp_ex/llama_nif.cpp b/c_src/llama_cpp_ex/llama_nif.cpp index 599e67e..c16d6da 100644 --- a/c_src/llama_cpp_ex/llama_nif.cpp +++ b/c_src/llama_cpp_ex/llama_nif.cpp @@ -26,8 +26,12 @@ // with only -I flags. #ifdef GGML_USE_RPC #include +#include #include +#include +#include #include +#include #include #include #endif @@ -524,10 +528,13 @@ LLAMA_NIF(backend_free, 0); // 1. RPC_STATUS_ASSERT is GGML_ABORT (ggml-rpc.cpp:30). Any peer crash, // network failure or malformed response terminates the OS process — the // whole BEAM. There is no error return, no retry, no reconnect. -// 2. Registration, by contrast, is safe: an unreachable endpoint makes -// ggml_backend_rpc_add_server return nullptr. So failures are *detectable -// before load* and *fatal during it*, and that asymmetry is why -// rpc_add_server reports rather than logs. +// 2. Since #18626 (d0132a680) registration aborts too: the connect and the +// HELLO moved into rpc_dispatcher::start, which GGML_ABORTs on an +// unreachable endpoint, an unparseable one, or a version mismatch where +// ggml_backend_rpc_add_server used to return nullptr. rpc_add_server +// therefore probes the endpoint itself first (rpc_probe_hello), so a dead +// or mismatched node is still *detectable before load* and only *fatal +// during it*. #ifdef GGML_USE_RPC @@ -607,6 +614,122 @@ bool rpc_wait_until_listening(const std::string& host, const std::string& port, return false; } +// rpc_probe_hello speaks the HELLO exchange by hand, so it has to track the +// wire layout in ggml-rpc.cpp. Upstream changes that layout only together with +// the major version (the server's "client needs upgrade to protocol v%d.x"), +// so a major bump stops the build here instead of failing every probe at run +// time. +static_assert(RPC_PROTO_MAJOR_VERSION == 8, + "RPC protocol major changed: re-check rpc_probe_hello against " + "rpc_msg_hello_req/rsp and RPC_CMD_HELLO in ggml-rpc.cpp"); + +constexpr uint8_t kRpcCmdHello = 14; // static_assert'ed stable upstream +constexpr size_t kRpcConnCapsSize = 24; // transport.h RPC_CONN_CAPS_SIZE +// rpc_msg_hello_rsp: major, minor, patch, padding, conn_caps[24] +constexpr size_t kRpcHelloRspSize = 4 + kRpcConnCapsSize; + +bool rpc_send_all(int fd, const void* data, size_t len) { + const auto* p = static_cast(data); + while (len > 0) { + ssize_t n = send(fd, p, len, MSG_NOSIGNAL); + if (n <= 0) { + if (n < 0 && errno == EINTR) continue; + return false; + } + p += n; + len -= static_cast(n); + } + return true; +} + +bool rpc_recv_all(int fd, void* data, size_t len) { + auto* p = static_cast(data); + while (len > 0) { + ssize_t n = recv(fd, p, len, 0); + if (n <= 0) { + if (n < 0 && errno == EINTR) continue; + return false; + } + p += n; + len -= static_cast(n); + } + return true; +} + +// Connects to the endpoint and performs a TCP-only HELLO (no transport +// capabilities advertised, so the worker never starts an RDMA upgrade for it), +// then closes. True when the peer answered with a protocol the client side +// accepts — the same test negotiate_hello applies. +// +// The endpoint is parsed and resolved exactly as rpc_dispatcher::start does +// (first ':', std::stoi, IPv4 only), because anything this accepts goes on to +// that function, where every failure is an abort. A worker that dies between +// the probe and the registration still aborts; that window is upstream's. +bool rpc_probe_hello(const std::string& endpoint, int timeout_ms) { + size_t colon = endpoint.find(':'); + if (colon == std::string::npos) return false; + std::string host = endpoint.substr(0, colon); + int port; + try { + port = std::stoi(endpoint.substr(colon + 1)); + } catch (...) { + return false; + } + if (port <= 0 || port > 65535) return false; + + addrinfo hints{}; + hints.ai_family = AF_INET; + hints.ai_socktype = SOCK_STREAM; + addrinfo* res = nullptr; + if (getaddrinfo(host.c_str(), std::to_string(port).c_str(), &hints, &res) != 0 || !res) { + return false; + } + + bool ok = false; + for (addrinfo* ai = res; ai && !ok; ai = ai->ai_next) { + int fd = socket(ai->ai_family, ai->ai_socktype | SOCK_CLOEXEC, ai->ai_protocol); + if (fd < 0) continue; + + int flags = fcntl(fd, F_GETFL, 0); + fcntl(fd, F_SETFL, flags | O_NONBLOCK); + int rc = connect(fd, ai->ai_addr, ai->ai_addrlen); + if (rc != 0 && errno == EINPROGRESS) { + pollfd pfd{fd, POLLOUT, 0}; + int err = 0; + socklen_t len = sizeof(err); + rc = (poll(&pfd, 1, timeout_ms) == 1 && + getsockopt(fd, SOL_SOCKET, SO_ERROR, &err, &len) == 0 && err == 0) + ? 0 : -1; + } + if (rc != 0) { + close(fd); + continue; + } + fcntl(fd, F_SETFL, flags); + timeval tv{timeout_ms / 1000, (timeout_ms % 1000) * 1000}; + setsockopt(fd, SOL_SOCKET, SO_RCVTIMEO, &tv, sizeof(tv)); + setsockopt(fd, SOL_SOCKET, SO_SNDTIMEO, &tv, sizeof(tv)); + + // | cmd (1) | request_size (8) | conn_caps (24, zeroed) | + uint8_t req[1 + sizeof(uint64_t) + kRpcConnCapsSize] = {}; + req[0] = kRpcCmdHello; + const uint64_t req_size = kRpcConnCapsSize; + std::memcpy(req + 1, &req_size, sizeof(req_size)); + + uint64_t rsp_size = 0; + uint8_t rsp[kRpcHelloRspSize] = {}; + ok = rpc_send_all(fd, req, sizeof(req)) && + rpc_recv_all(fd, &rsp_size, sizeof(rsp_size)) && + rsp_size == kRpcHelloRspSize && + rpc_recv_all(fd, rsp, sizeof(rsp)) && + rsp[0] == RPC_PROTO_MAJOR_VERSION && + rsp[1] <= RPC_PROTO_MINOR_VERSION; + close(fd); + } + freeaddrinfo(res); + return ok; +} + } // namespace #endif // GGML_USE_RPC @@ -636,7 +759,9 @@ LLAMA_NIF(rpc_supported, 0); // the remote devices. // // Returns the number of devices the endpoint contributed. Upstream memoizes per -// endpoint, so a repeat call is a no-op and returns 0 added. +// endpoint, so a repeat call is a no-op and returns 0 added — but the probe +// still runs, so a registered peer that has since gone away reports +// :unreachable. std::variant, fine::Error> rpc_add_server(ErlNifEnv* env, std::string endpoint) { #ifndef GGML_USE_RPC @@ -645,12 +770,18 @@ rpc_add_server(ErlNifEnv* env, std::string endpoint) { #else size_t before = ggml_backend_dev_count(); + // ggml_backend_rpc_add_server aborts the VM on an unreachable or + // mismatched endpoint (see the top of this section), so check first. + if (!rpc_probe_hello(endpoint, 5000)) { + return fine::Error(atoms::unreachable); + } + ggml_backend_reg_t reg = ggml_backend_rpc_add_server(endpoint.c_str()); if (!reg) { - // Both an unreachable endpoint and a HELLO major/minor mismatch collapse - // to nullptr here, and ggml_backend_register silently no-ops on nullptr - // — so without this check a dead or mismatched node simply vanishes and - // the model loads onto the wrong devices. + // A worker reporting zero devices still comes back as nullptr, and + // ggml_backend_register silently no-ops on nullptr — so without this + // check that node simply vanishes and the model loads onto the wrong + // devices. return fine::Error(atoms::unreachable); } diff --git a/lib/llama_cpp_ex/rpc.ex b/lib/llama_cpp_ex/rpc.ex index 06ac544..c2228dc 100644 --- a/lib/llama_cpp_ex/rpc.ex +++ b/lib/llama_cpp_ex/rpc.ex @@ -24,9 +24,10 @@ defmodule LlamaCppEx.RPC do LLAMA_RPC=1 LLAMA_BACKEND=cuda mix compile - On Linux the transport auto-negotiates RDMA when both peers have a usable HCA, - which is a build-time choice (`LLAMA_RPC_RDMA`, default on) with no runtime - switch. See `LlamaCppEx.RPC.Server` for how to tell which transport you got. + On Linux the transport auto-negotiates RDMA when both peers have a usable HCA + (`LLAMA_RPC_RDMA`, default on). Setting `GGML_RPC_NO_RDMA` in either peer's + environment keeps that peer on TCP. See `LlamaCppEx.RPC.Server` for how to + tell which transport you got. > #### A peer failure kills the VM {: .error} > @@ -38,11 +39,14 @@ defmodule LlamaCppEx.RPC do > to catch. > > Registration is the exception and the reason this module is shaped the way it - > is: an unreachable endpoint is reported as `{:error, :unreachable}` rather - > than aborting, so a two-node setup can be *checked* before a model load and - > is only *fatal* during one. Check with `ping/1` before you load; treat the VM - > as the unit of restart afterwards. Real fault isolation would mean running - > the RPC client in a separate OS process, which is a different architecture. + > is. Upstream's registration aborts too (since llama.cpp #18626), so + > `add_server/1` first connects and exchanges the protocol HELLO itself: an + > unreachable or incompatible endpoint is reported as `{:error, :unreachable}` + > rather than aborting, so a two-node setup can be *checked* before a model + > load and is only *fatal* during one. Check with `ping/1` before you load; + > treat the VM as the unit of restart afterwards. Real fault isolation would + > mean running the RPC client in a separate OS process, which is a different + > architecture. ## Two device orderings, and they disagree @@ -96,7 +100,8 @@ defmodule LlamaCppEx.RPC do Returns the number of devices the endpoint contributed. Idempotent: upstream memoizes the registration per endpoint, so registering the same endpoint twice - succeeds and reports `0` added the second time. + succeeds and reports `0` added the second time. Every call still connects and + exchanges the HELLO first, with a 5-second timeout. Must be called **before** `LlamaCppEx.Model.load/2`, because tensor placement is computed from the devices that exist at load time. @@ -107,11 +112,12 @@ defmodule LlamaCppEx.RPC do ## Errors * `{:error, :rpc_unsupported}` — the NIF was built without `LLAMA_RPC=1`. - * `{:error, :unreachable}` — nothing answered, or the peer's RPC protocol - major/minor did not match ours. Upstream collapses both to a null - registration, and a null registration is silently ignored by - `ggml_backend_register`, so this check is the only thing standing between - you and a model that quietly loads onto the wrong devices. + * `{:error, :unreachable}` — nothing answered within 5 seconds, the + endpoint is not `host:port`, the peer's RPC protocol major/minor did not + match ours, or the worker reported no devices. Upstream aborts the VM on + the first three, and silently ignores the last one at registration, so + this check is the only thing standing between you and a crash or a model + that quietly loads onto the wrong devices. """ @spec add_server(endpoint()) :: {:ok, non_neg_integer()} | {:error, error()} def add_server(endpoint) when is_binary(endpoint) do @@ -160,13 +166,13 @@ defmodule LlamaCppEx.RPC do Reports whether an endpoint is reachable and speaks a compatible protocol. This is `add_server/1` under a name that says what it is good for. It has the - same side effect — a reachable endpoint stays registered — and it is **not** a - health check you can repeat to monitor a peer: the answer is memoized after the - first success, and once a model is loaded a dead peer aborts the VM rather than - failing a probe. + same side effect — a reachable endpoint stays registered. Each call connects + and exchanges the HELLO again, so it does report a peer that has gone away + since registering; but once a model is loaded a dead peer aborts the VM on + the next RPC command, before any probe gets a say. - Use it once, before loading, to turn "the model landed on the wrong devices" - into a clear error. + Use it before loading, to turn "the model landed on the wrong devices" or a + VM abort into a clear error. """ @spec ping(endpoint()) :: :ok | {:error, error()} def ping(endpoint) when is_binary(endpoint) do From 1871c2ff54534529de284569f6d5a28de370f41d Mon Sep 17 00:00:00 2001 From: Niko Maroulis Date: Sun, 1 Nov 2026 21:56:44 -0500 Subject: [PATCH 02/49] RPC: tests for non-RPC peers and bad endpoints; spark scripts: LAN link, GGML_RPC_NO_RDMA; overhead bench --- bench/spark_overhead.exs | 126 ++++++++++++++++++++++++++++++++++++ scripts/spark/lib.sh | 6 ++ scripts/spark/rpc-worker.sh | 10 +-- test/rpc_test.exs | 33 ++++++++++ 4 files changed, 170 insertions(+), 5 deletions(-) create mode 100644 bench/spark_overhead.exs diff --git a/bench/spark_overhead.exs b/bench/spark_overhead.exs new file mode 100644 index 0000000..0b121c0 --- /dev/null +++ b/bench/spark_overhead.exs @@ -0,0 +1,126 @@ +# Binding overhead against upstream's own tools, on one model. +# +# scripts/spark/remote.sh --env MIX_ENV=bench --env LLAMA_MODEL_PATH= \ +# --big-cores spark-1 mix run bench/spark_overhead.exs +# +# Compare with, from the same llama.cpp commit: +# +# llama-bench -m -fa 1 -p 512 -n 128 -r 3 +# llama-batched-bench -m -fa 1 -c 16384 -npp 128 -ntg 128 -npl 1,4,8 +# +# Three decode paths, each timed from the first streamed token to the last so +# prompt processing and context creation stay out of the number: +# +# stream LlamaCppEx.stream/3 -- the C++ generate_tokens loop, one sequence +# server1 LlamaCppEx.Server, n_parallel 1 -- the batch_eval_sample tick loop +# serverN LlamaCppEx.Server, n_parallel N, N concurrent streams -- aggregate +# +# llama-bench's tg does no sampling and sends nothing anywhere, so the gap to +# `stream` is the whole binding cost per token: sampler chain, token_to_piece, +# enif_send and the BEAM receive. + +model_path = System.get_env("LLAMA_MODEL_PATH") || raise "Set LLAMA_MODEL_PATH" +n_gen = String.to_integer(System.get_env("SPARK_N_GEN") || "128") +samples = String.to_integer(System.get_env("SPARK_SAMPLES") || "3") + +parallel = + (System.get_env("SPARK_PARALLEL") || "4,8") + |> String.split(",", trim: true) + |> Enum.map(&String.to_integer/1) + +# Base-model friendly and long-running under greedy decoding; the chat template +# is deliberately not applied so every path sees the same tokens. +prompt = + "Write a detailed, multi-chapter history of the Roman Empire, starting with " <> + "the founding of Rome and continuing through the fall of Constantinople.\n\n" + +defmodule Overhead do + def median([_ | _] = xs) do + s = Enum.sort(xs) + n = length(s) + if rem(n, 2) == 1, do: Enum.at(s, div(n, 2)), else: (Enum.at(s, div(n, 2) - 1) + Enum.at(s, div(n, 2))) / 2 + end + + # Consumes an enumerable of chunks and returns {tokens_after_first, seconds}. + def time_decode(enum) do + {count, first, last} = + Enum.reduce(enum, {0, nil, nil}, fn + {:error, reason}, _ -> + raise "generation failed: #{inspect(reason)}" + + chunk, {n, first, _} when is_binary(chunk) or is_map(chunk) -> + now = System.monotonic_time(:microsecond) + {n + 1, first || now, now} + + _other, acc -> + acc + end) + + {count - 1, (last - first) / 1_000_000} + end + + def tps({n, s}) when s > 0, do: n / s +end + +:ok = LlamaCppEx.init() +{:ok, model} = LlamaCppEx.load_model(model_path, n_gpu_layers: -1) + +IO.puts("model: #{Path.basename(model_path)} n_gen: #{n_gen} samples: #{samples}\n") +IO.puts("| path | streams | tokens/stream | per-stream t/s | aggregate t/s |") +IO.puts("|---|---|---|---|---|") + +gen_opts = [max_tokens: n_gen, temp: 0.0, n_ctx: 4096] + +# Warm-up: kernel selection and CUDA graph capture happen on the first run. +model |> LlamaCppEx.stream(prompt, gen_opts) |> Stream.run() + +runs = for _ <- 1..samples, do: Overhead.time_decode(LlamaCppEx.stream(model, prompt, gen_opts)) +tps = Overhead.median(Enum.map(runs, &Overhead.tps/1)) +{n, _} = hd(runs) +IO.puts("| stream | 1 | #{n} | #{Float.round(tps, 2)} | #{Float.round(tps, 2)} |") + +for n_par <- [1 | parallel] do + {:ok, server} = + LlamaCppEx.Server.start_link( + model_path: model_path, + n_gpu_layers: -1, + n_parallel: n_par, + n_ctx: 4096 * n_par, + temp: 0.0, + cache_prompt: false + ) + + # start_link returns before the load; a generate call queues behind it. + {:ok, _} = LlamaCppEx.Server.generate(server, prompt, max_tokens: 8) + + one_round = fn -> + t0 = System.monotonic_time(:microsecond) + + results = + 1..n_par + |> Task.async_stream( + fn _ -> + Overhead.time_decode(LlamaCppEx.Server.stream(server, prompt, max_tokens: n_gen)) + end, + max_concurrency: n_par, + timeout: :infinity + ) + |> Enum.map(fn {:ok, r} -> r end) + + wall = (System.monotonic_time(:microsecond) - t0) / 1_000_000 + per = Overhead.median(Enum.map(results, &Overhead.tps/1)) + total = results |> Enum.map(&elem(&1, 0)) |> Enum.sum() + {per, total / wall, results |> hd() |> elem(0)} + end + + rounds = for _ <- 1..samples, do: one_round.() + per = Overhead.median(Enum.map(rounds, &elem(&1, 0))) + agg = Overhead.median(Enum.map(rounds, &elem(&1, 1))) + toks = rounds |> hd() |> elem(2) + + IO.puts( + "| server#{n_par} | #{n_par} | #{toks} | #{Float.round(per, 2)} | #{Float.round(agg, 2)} |" + ) + + GenServer.stop(server) +end diff --git a/scripts/spark/lib.sh b/scripts/spark/lib.sh index 69e1e0a..845ec0d 100755 --- a/scripts/spark/lib.sh +++ b/scripts/spark/lib.sh @@ -18,12 +18,18 @@ SPARK_NODES=(spark-1 spark-2) # a GID against the socket's local address, so one peer connection can only ever # use one link. Link 0 is the one everything uses; link 1 is listed so the fact # sheet can prove both trained. +# +# `lan` is the 10 GbE management NIC (enP7s7, MTU 1500, no RDMA-capable HCA on +# that subnet). It exists only as the slow arm of a transport comparison: a +# two-node run belongs on the fabric. spark_fabric_ip() { case "$1:${2:-0}" in spark-1:0) printf '10.100.64.1' ;; spark-1:1) printf '10.100.65.1' ;; + spark-1:lan) printf '10.0.20.26' ;; spark-2:0) printf '10.100.64.2' ;; spark-2:1) printf '10.100.65.2' ;; + spark-2:lan) printf '10.0.20.25' ;; *) return 1 ;; esac } diff --git a/scripts/spark/rpc-worker.sh b/scripts/spark/rpc-worker.sh index 3c337dd..5955b9d 100755 --- a/scripts/spark/rpc-worker.sh +++ b/scripts/spark/rpc-worker.sh @@ -56,10 +56,10 @@ cache=1 # legitimately holds tens of GB of weights, so an absolute default would be # either useless or a footgun; this catches the leak, not the workload. rss_fraction=0.92 -# Force the TCP path. There is no runtime switch for the transport: selection is -# silent auto-negotiation, and GGML_RDMA_DEV pointing at a device that does not -# exist is the only lever short of a -DGGML_RPC_RDMA=OFF build. Both ends have -# to agree, so pass --tcp here and GGML_RDMA_DEV to the client too. +# Force the TCP path with GGML_RPC_NO_RDMA, upstream's runtime switch: a peer +# with it set advertises no RDMA capability in the HELLO, so the connection +# stays on TCP whatever the other end can do. Setting it on the worker alone is +# enough; the client can set it too. tcp=0 # `logs` takes a bare line count. lines=100 @@ -137,7 +137,7 @@ exec taskset -c $SPARK_BIG_CORES mix run scripts/spark/rpc_worker.exs" # trees coexist and switching back is a cache hit. printf 'export LLAMA_RPC=1\n' [ "$debug" -eq 1 ] && printf 'export GGML_RPC_DEBUG=1\n' - [ "$tcp" -eq 1 ] && printf 'export GGML_RDMA_DEV=no-such-hca\n' + [ "$tcp" -eq 1 ] && printf 'export GGML_RPC_NO_RDMA=1\n' printf 'cd "$HOME/%s"\n' "$SPARK_REMOTE_DIR" printf '%s\n' "$inner" ) diff --git a/test/rpc_test.exs b/test/rpc_test.exs index 7e7eba3..8909e6f 100644 --- a/test/rpc_test.exs +++ b/test/rpc_test.exs @@ -75,6 +75,39 @@ defmodule LlamaCppEx.RPCTest do test "ping/1 reports the same refusal" do assert RPC.ping("127.0.0.1:1") == {:error, expected_refusal()} end + + test "a listener that is not an RPC worker is an error, never a crash" do + # Since llama.cpp #18626 upstream's own handshake aborts the process when + # the peer accepts and then answers wrongly, so this is the case the NIF's + # pre-flight HELLO exists for: one peer closes after reading the request, + # the other answers with bytes that are not a HELLO response. + for reply <- [:close, "HTTP/1.1 400 Bad Request\r\n\r\n"] do + {:ok, listen} = :gen_tcp.listen(0, [:binary, active: false, ip: {127, 0, 0, 1}]) + {:ok, port} = :inet.port(listen) + + acceptor = + Task.async(fn -> + {:ok, sock} = :gen_tcp.accept(listen, 10_000) + _ = :gen_tcp.recv(sock, 0, 5_000) + if is_binary(reply), do: :gen_tcp.send(sock, reply) + :gen_tcp.close(sock) + end) + + endpoint = "127.0.0.1:#{port}" + assert RPC.add_server(endpoint) == {:error, expected_refusal()} + + # A non-RPC build never connects, so nobody is accepted; do not wait. + if RPC.supported?(), do: Task.await(acceptor), else: Task.shutdown(acceptor, :brutal_kill) + :gen_tcp.close(listen) + end + end + + test "an endpoint that is not host:port is an error, never a crash" do + # Upstream parses with std::stoi and GGML_ABORTs when that fails. + for endpoint <- ["no-port-here", "127.0.0.1:", "127.0.0.1:http"] do + assert RPC.add_server(endpoint) == {:error, expected_refusal()} + end + end end describe "add_servers/1" do From 098156884f6c626a2a71559a712a85b2db54f1c1 Mon Sep 17 00:00:00 2001 From: Niko Maroulis Date: Sun, 1 Nov 2026 22:00:00 -0500 Subject: [PATCH 03/49] spark: end-to-end check script, single node with three models and two-node split --- scripts/spark/e2e.exs | 335 ++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 335 insertions(+) create mode 100644 scripts/spark/e2e.exs diff --git a/scripts/spark/e2e.exs b/scripts/spark/e2e.exs new file mode 100644 index 0000000..065fc04 --- /dev/null +++ b/scripts/spark/e2e.exs @@ -0,0 +1,335 @@ +# End-to-end check of the CUDA build on a Spark, single node or across two. +# +# # one node: two chat models and an embedding model resident at once +# scripts/spark/remote.sh --env MIX_ENV=test --env LLAMA_RPC=1 spark-1 \ +# mix run scripts/spark/e2e.exs single +# +# # two nodes: a model layer-split over the fabric next to a local one +# scripts/spark/rpc-worker.sh start spark-2 +# scripts/spark/remote.sh --env MIX_ENV=test --env LLAMA_RPC=1 spark-1 \ +# mix run scripts/spark/e2e.exs two-node 10.100.64.2:50052 +# +# Every check asserts on what the model said, not only on {:ok, _}: a model +# that loads onto the wrong device, or a split that corrupts activations, +# still returns {:ok, text}. Exits non-zero on any failure. +# +# Models default to the files on spark-1 and can be overridden: +# SPARK_E2E_BIG Qwen3.8-27B NVFP4 (dense, hybrid GDN, MTP head) +# SPARK_E2E_MOE Qwen3-30B-A3B Q4_K_M +# SPARK_E2E_EMBED Qwen3-Embedding-0.6B +# SPARK_E2E_TOOLS a model whose template supports tools + +home = System.user_home!() + +big = + System.get_env("SPARK_E2E_BIG") || + Path.join(home, "models/esatapedico/Qwen3.8-27B-NVFP4-MTP-GGUF/main/Qwen3.8-27B-NVFP4-MTP-MID-HIGH.gguf") + +moe = + System.get_env("SPARK_E2E_MOE") || + Path.join(home, "models/Qwen/Qwen3-30B-A3B-GGUF/main/Qwen3-30B-A3B-Q4_K_M.gguf") + +embed = + System.get_env("SPARK_E2E_EMBED") || + Path.join(home, "models/test/Qwen3-Embedding-0.6B-f16.gguf") + +defmodule E2E do + alias LlamaCppEx.ModelManager + + def start, do: Agent.start_link(fn -> [] end, name: __MODULE__) + + def step(label, fun) do + IO.write(" " <> String.pad_trailing(label, 52)) + t0 = System.monotonic_time(:millisecond) + + outcome = + try do + fun.() + rescue + e -> {:error, Exception.message(e)} + catch + kind, reason -> {:error, "#{kind}: #{inspect(reason)}"} + end + + ms = System.monotonic_time(:millisecond) - t0 + + case outcome do + {:ok, detail} -> + IO.puts("PASS #{detail} (#{ms} ms)") + Agent.update(__MODULE__, &[:ok | &1]) + + {:error, detail} -> + IO.puts("FAIL #{detail}") + Agent.update(__MODULE__, &[:error | &1]) + end + end + + def finish do + results = Agent.get(__MODULE__, & &1) + failed = Enum.count(results, &(&1 == :error)) + + if failed == 0 do + IO.puts("\nall #{length(results)} checks passed") + else + IO.puts("\n#{failed} of #{length(results)} checks FAILED") + System.halt(1) + end + end + + def content({:ok, %{choices: [%{message: message} | _]}}), do: message.content || "" + def content(other), do: raise("unexpected reply: #{inspect(other, limit: 5)}") + + # Factual prompts with one checkable answer each. Thinking is off so the + # answer is in `content`, and the token budget leaves room for a sentence. + def ask(target, question, expect, opts \\ []) do + reply = + target + |> chat(question, opts) + |> content() + + if reply =~ expect, + do: {:ok, inspect(String.slice(String.trim(reply), 0, 40))}, + else: {:error, "expected #{inspect(expect)} in #{inspect(reply)}"} + end + + defp chat({:manager, id}, question, opts), + do: ModelManager.chat_completion(id, [%{role: "user", content: question}], chat_opts(opts)) + + defp chat(server, question, opts), + do: LlamaCppEx.chat_completion(server, [%{role: "user", content: question}], chat_opts(opts)) + + defp chat_opts(opts), + do: Keyword.merge([max_tokens: 64, temp: 0.0, enable_thinking: false], opts) + + def questions do + [ + {"What is the capital of France? One word.", ~r/Paris/i}, + {"What is 12 times 12? Reply with the number only.", ~r/144/}, + {"Which planet is known as the Red Planet? One word.", ~r/Mars/i}, + {"What is the chemical symbol for gold? Reply with the symbol only.", ~r/\bAu\b/} + ] + end + + def concurrent(target, n) do + qs = questions() |> Stream.cycle() |> Enum.take(n) + + results = + qs + |> Task.async_stream(fn {q, e} -> ask(target, q, e) end, + max_concurrency: n, + timeout: 300_000 + ) + |> Enum.map(fn {:ok, r} -> r end) + + case Enum.reject(results, &match?({:ok, _}, &1)) do + [] -> {:ok, "#{n}/#{n} correct"} + bad -> {:error, inspect(bad)} + end + end + + def stream_text(server, question) do + chunks = + server + |> LlamaCppEx.stream_chat_completion([%{role: "user", content: question}], + max_tokens: 64, + temp: 0.0, + enable_thinking: false + ) + |> Enum.to_list() + + text = + chunks + |> Enum.flat_map(fn + %{choices: [%{delta: %{content: c}} | _]} when is_binary(c) -> [c] + _ -> [] + end) + |> Enum.join() + + {length(chunks), text} + end + + def cosine(a, b) do + dot = Enum.zip_with(a, b, &(&1 * &2)) |> Enum.sum() + norm = fn v -> :math.sqrt(Enum.reduce(v, 0.0, &(&1 * &1 + &2))) end + dot / (norm.(a) * norm.(b)) + end + + def mem_gb do + {out, 0} = System.cmd("free", ["-b"]) + [_, total, used | _] = out |> String.split("\n") |> Enum.at(1) |> String.split() + "#{Float.round(String.to_integer(used) / 1.0e9, 1)} / #{Float.round(String.to_integer(total) / 1.0e9, 1)} GB used" + end +end + +{:ok, _} = E2E.start() +LlamaCppEx.set_log_level(:error) +:ok = LlamaCppEx.init() + +case System.argv() do + ["single" | _] -> + IO.puts("\n== single node: two chat models + one embedding model resident\n") + {:ok, _} = LlamaCppEx.ModelSupervisor.start_link(memory_budget: :infinity) + alias LlamaCppEx.ModelManager + + E2E.step("CUDA0 is the GPU and reports unified memory", fn -> + case Enum.find(LlamaCppEx.devices(), &(&1.backend == "CUDA")) do + %{name: "CUDA0", type: :igpu} = d -> {:ok, "#{d.description}, #{div(d.memory_total, 1_000_000_000)} GB"} + other -> {:error, inspect(other)} + end + end) + + E2E.step("load NVFP4 27B (server, n_parallel 4)", fn -> + {:ok, _} = ModelManager.load("big", {:path, big}, n_gpu_layers: -1, n_parallel: 4, n_ctx: 16_384) + {:ok, Path.basename(big)} + end) + + E2E.step("load Qwen3-30B-A3B MoE (server, n_parallel 4)", fn -> + {:ok, _} = ModelManager.load("moe", {:path, moe}, n_gpu_layers: -1, n_parallel: 4, n_ctx: 16_384) + {:ok, Path.basename(moe)} + end) + + E2E.step("load embedding model (direct)", fn -> + {:ok, _} = ModelManager.load("embed", {:path, embed}, capabilities: [:embed], n_gpu_layers: -1) + {:ok, Path.basename(embed)} + end) + + E2E.step("three models resident", fn -> + ids = ModelManager.list() |> Enum.map(& &1.id) |> Enum.sort() + if ids == ["big", "embed", "moe"], do: {:ok, E2E.mem_gb()}, else: {:error, inspect(ids)} + end) + + for {q, e} <- E2E.questions() |> Enum.take(2), id <- ["big", "moe"] do + E2E.step("#{id}: #{String.slice(q, 0, 30)}", fn -> E2E.ask({:manager, id}, q, e) end) + end + + E2E.step("both chat models at once, 8 requests each", fn -> + [a, b] = + Task.await_many( + [Task.async(fn -> E2E.concurrent({:manager, "big"}, 8) end), + Task.async(fn -> E2E.concurrent({:manager, "moe"}, 8) end)], + 600_000 + ) + + case {a, b} do + {{:ok, x}, {:ok, y}} -> {:ok, "big #{x}, moe #{y}"} + _ -> {:error, inspect({a, b})} + end + end) + + E2E.step("embeddings rank a paraphrase above an unrelated text", fn -> + {:ok, a} = ModelManager.embed("embed", "The cat sat on the mat.") + {:ok, b} = ModelManager.embed("embed", "A cat was sitting on a rug.") + {:ok, c} = ModelManager.embed("embed", "Quarterly revenue grew by eight percent.") + {sim, far} = {E2E.cosine(a, b), E2E.cosine(a, c)} + if sim > far, do: {:ok, "#{Float.round(sim, 3)} > #{Float.round(far, 3)}"}, else: {:error, "#{sim} <= #{far}"} + end) + + E2E.step("unload one model, the other keeps serving", fn -> + :ok = ModelManager.unload("moe") + E2E.ask({:manager, "big"}, "What is the capital of France? One word.", ~r/Paris/i) + end) + + ["two-node", endpoint | _] -> + IO.puts("\n== two nodes over #{endpoint}: split model + local model\n") + + E2E.step("worker answers the HELLO", fn -> + case LlamaCppEx.RPC.ping(endpoint) do + :ok -> {:ok, inspect(Enum.map(LlamaCppEx.RPC.devices(), & &1.name))} + other -> {:error, inspect(other)} + end + end) + + {:ok, split} = + LlamaCppEx.Server.start_link( + model_path: big, + rpc_servers: [endpoint], + devices: ["CUDA0", "RPC0"], + split_mode: :layer, + tensor_split: [0.5, 0.5], + n_gpu_layers: -1, + n_parallel: 4, + n_ctx: 16_384 + ) + + E2E.step("NVFP4 27B loads split across CUDA0 + RPC0", fn -> + {:ok, _} = LlamaCppEx.Server.generate(split, "Hello", max_tokens: 1) + {:ok, E2E.mem_gb()} + end) + + {:ok, local} = + LlamaCppEx.Server.start_link( + model_path: moe, + devices: ["CUDA0"], + n_gpu_layers: -1, + n_parallel: 4, + n_ctx: 16_384 + ) + + E2E.step("Qwen3-30B-A3B loads locally beside it", fn -> + {:ok, _} = LlamaCppEx.Server.generate(local, "Hello", max_tokens: 1) + {:ok, E2E.mem_gb()} + end) + + for {q, e} <- E2E.questions() do + E2E.step("split: #{String.slice(q, 0, 36)}", fn -> E2E.ask(split, q, e) end) + end + + E2E.step("split: streaming chat completion", fn -> + {n, text} = E2E.stream_text(split, "What is the capital of France? One word.") + if text =~ ~r/Paris/i, do: {:ok, "#{n} chunks, #{inspect(String.trim(text))}"}, else: {:error, inspect(text)} + end) + + E2E.step("split + local at once, 8 requests each", fn -> + [a, b] = + Task.await_many( + [Task.async(fn -> E2E.concurrent(split, 8) end), Task.async(fn -> E2E.concurrent(local, 8) end)], + 600_000 + ) + + case {a, b} do + {{:ok, x}, {:ok, y}} -> {:ok, "split #{x}, local #{y}"} + _ -> {:error, inspect({a, b})} + end + end) + + E2E.step("split: tool call", fn -> + tools = [ + %{ + type: "function", + function: %{ + name: "get_weather", + description: "Get the current weather for a city", + parameters: %{ + type: "object", + properties: %{city: %{type: "string"}}, + required: ["city"] + } + } + } + ] + + {:ok, %{choices: [%{message: msg, finish_reason: reason} | _]}} = + LlamaCppEx.chat_completion(split, [%{role: "user", content: "What's the weather in Paris right now?"}], + tools: tools, + max_tokens: 512, + temp: 0.0 + ) + + case msg do + %{tool_calls: [%{function: %{name: "get_weather", arguments: args}} | _]} -> + if args =~ ~r/Paris/i, do: {:ok, "#{reason}: #{args}"}, else: {:error, args} + + other -> + {:error, inspect(other, limit: 8)} + end + end) + + GenServer.stop(local) + GenServer.stop(split) + + _ -> + IO.puts("usage: mix run scripts/spark/e2e.exs single | two-node ") + System.halt(2) +end + +E2E.finish() From 499b4923a9906f1eaf0d2323b733d9800f4e5982 Mon Sep 17 00:00:00 2001 From: Niko Maroulis Date: Mon, 2 Nov 2026 06:43:08 -0500 Subject: [PATCH 04/49] MTP: DFlash/DSpark drafters via type:, RS-snapshot rollback on hybrid targets, re-inject features after checkpoint rollback; spec bench --- bench/spark_spec.exs | 128 +++++++++++++++++++++++++++++++ bench/spark_two_node.exs | 19 ++--- c_src/llama_cpp_ex/llama_nif.cpp | 102 ++++++++++++++++++++---- lib/llama_cpp_ex/context.ex | 9 ++- lib/llama_cpp_ex/mtp.ex | 113 +++++++++++++++++++-------- lib/llama_cpp_ex/nif.ex | 2 +- test/llama_cpp_ex_test.exs | 12 +-- test/mtp_model_test.exs | 105 +++++++++++++++++++++++-- test/mtp_test.exs | 26 +++++++ test/support/test_models.exs | 8 ++ test/test_helper.exs | 5 ++ 11 files changed, 455 insertions(+), 74 deletions(-) create mode 100644 bench/spark_spec.exs diff --git a/bench/spark_spec.exs b/bench/spark_spec.exs new file mode 100644 index 0000000..bff47d4 --- /dev/null +++ b/bench/spark_spec.exs @@ -0,0 +1,128 @@ +# Plain decode against every speculative drafter, through LlamaCppEx.MTP. +# +# scripts/spark/remote.sh --env MIX_ENV=bench --big-cores spark-1 \ +# mix run bench/spark_spec.exs [config ...] +# +# A config is `plain`, `mtp:` (the head inside the target GGUF), +# `dflash::` or `dspark::`. With none given: +# plain, mtp:1..4. Each config runs the same four chat-templated prompts twice, +# greedy, 256 tokens, thinking off, and reports the median decode rate (first +# token to last, so prefill is excluded) and the draft acceptance. +# +# Greedy speculative decoding is lossless, so every config's text is also +# compared with the plain run's: a drafter that changes the output is a bug, +# whatever it does to the rate. Same prompts as the llama-server runs in +# docs/dgx-spark.md, for a like-for-like comparison. + +alias LlamaCppEx.{Chat, MTP} + +[target | configs] = System.argv() +configs = if configs == [], do: ["plain", "mtp:1", "mtp:2", "mtp:3", "mtp:4"], else: configs +n_gen = 256 + +prompts = [ + "Write a Python function that parses an ISO-8601 date string and returns a datetime, with docstring and error handling.", + "Explain step by step how to compute the derivative of x^3 * sin(x).", + "Write a short essay about the history of the printing press.", + "List ten tips for writing maintainable Elixir code, one sentence each." +] + +LlamaCppEx.set_log_level(:error) +:ok = LlamaCppEx.init() +{:ok, model} = LlamaCppEx.load_model(target, n_gpu_layers: -1, load_mtp: true) + +templated = + Enum.map(prompts, fn p -> + {:ok, text} = + Chat.apply_template(model, [%{role: "user", content: p}], enable_thinking: false) + + text + end) + +defmodule Spec do + def median(xs) do + s = Enum.sort(xs) + n = length(s) + if rem(n, 2) == 1, do: Enum.at(s, div(n, 2)), else: (Enum.at(s, div(n, 2) - 1) + Enum.at(s, div(n, 2))) / 2 + end + + # {text, tokens_after_first / seconds} + def run(enum) do + {pieces, first, last, n} = + Enum.reduce(enum, {[], nil, nil, 0}, fn + {:error, reason}, _ -> raise "generation failed: #{inspect(reason)}" + piece, {acc, f, _, n} when is_binary(piece) -> + now = System.monotonic_time(:microsecond) + {[piece | acc], f || now, now, n + 1} + end) + + {pieces |> Enum.reverse() |> IO.iodata_to_binary(), (n - 1) * 1_000_000 / max(last - first, 1)} + end +end + +opts = [max_tokens: n_gen, temp: 0.0] + +IO.puts("target: #{Path.basename(target)}\n") +IO.puts( + "| config | median t/s | range | vs plain | acceptance | output == plain | ms/iter draft / verify / ckpt / sample / other |" +) + +IO.puts("|---|---|---|---|---|---|---|") + +{reference, _} = + Enum.reduce(configs, {nil, nil}, fn config, {ref_texts, ref_rate} -> + {runner, cleanup, label} = + case String.split(config, ":", parts: 3) do + ["plain"] -> + {fn prompt -> Spec.run(LlamaCppEx.stream(model, prompt, Keyword.put(opts, :n_ctx, 4096))) end, + fn -> nil end, "plain"} + + [type, n | rest] -> + draft = + case rest do + [path] -> elem(LlamaCppEx.load_model(path, n_gpu_layers: -1), 1) + [] -> nil + end + + {:ok, mtp} = + MTP.init(model, + type: String.to_existing_atom(type), + draft_model: draft, + n_draft: String.to_integer(n), + n_ctx: 4096 + ) + + {fn prompt -> Spec.run(MTP.stream(mtp, prompt, opts)) end, fn -> MTP.stats(mtp) end, + "#{type} n=#{mtp.n_draft}"} + end + + _warm = runner.(hd(templated)) + results = for _ <- 1..2, prompt <- templated, do: runner.(prompt) + texts = results |> Enum.take(length(templated)) |> Enum.map(&elem(&1, 0)) + rates = Enum.map(results, &elem(&1, 1)) + med = Spec.median(rates) + + {acc, split} = + case cleanup.() do + %{acceptance_rate: r, iters: iters, timing_us: t} -> + per = fn key -> Float.round(Map.fetch!(t, key) / max(iters, 1) / 1000, 2) end + + {"#{Float.round(r * 100, 1)}%", + Enum.map_join([:draft, :verify, :ckpt, :sample, :other], " / ", &per.(&1))} + + _ -> + {"-", "-"} + end + + same = if ref_texts, do: to_string(texts == ref_texts), else: "-" + vs = if ref_rate, do: "#{Float.round(med / ref_rate, 2)}x", else: "-" + + IO.puts( + "| #{label} | #{Float.round(med, 2)} | #{Float.round(Enum.min(rates), 1)}-#{Float.round(Enum.max(rates), 1)} | #{vs} | #{acc} | #{same} | #{split} |" + ) + + :erlang.garbage_collect() + {ref_texts || texts, ref_rate || med} + end) + +_ = reference diff --git a/bench/spark_two_node.exs b/bench/spark_two_node.exs index 516ef65..d6e5a1e 100644 --- a/bench/spark_two_node.exs +++ b/bench/spark_two_node.exs @@ -248,12 +248,12 @@ case which do "b1" -> # Controlled: the model fits one node, so anything the second node costs is # pure RPC overhead rather than a memory benefit. - path = models["120b"] + path = System.get_env("SPARK_TWO_NODE_MODEL") || models["120b"] File.exists?(path) || raise "missing #{path}" single = TwoNode.measure( - "120b single-node", + "#{Path.basename(path, ".gguf")} single-node", path, [n_parallel: 1, n_ctx: n_ctx, cache_prompt: false], prompt_tokens, @@ -265,7 +265,7 @@ case which do two = TwoNode.measure( - "120b two-node 50/50", + "#{Path.basename(path, ".gguf")} two-node 50/50", path, [ n_parallel: 1, @@ -339,18 +339,19 @@ case which do TwoNode.table(single ++ [two]) "b3" -> - # Transport A/B. Run this twice: once normally, once with the worker AND this - # process started under GGML_RDMA_DEV=nonexistent. There is no runtime - # switch — that variable and a -DGGML_RPC_RDMA=OFF build are the only levers. - path = models["120b"] + # Transport A/B. Run once per transport: normally (RDMA on the fabric), with + # GGML_RPC_NO_RDMA=1 set on the worker (`rpc-worker.sh start --tcp`) for TCP + # over the same 200 GbE link, and with the worker on the 10 GbE LAN + # (`--link lan`) for the management network. SPARK_TRANSPORT labels the row. + path = System.get_env("SPARK_TWO_NODE_MODEL") || models["120b"] register.() {local, remote} = device_names.() - transport = if System.get_env("GGML_RDMA_DEV") in [nil, ""], do: "RDMA", else: "TCP (forced)" + transport = System.get_env("SPARK_TRANSPORT") || "RDMA" row = TwoNode.measure( - "120b two-node over #{transport}", + "#{Path.basename(path, ".gguf")} two-node over #{transport}", path, [ n_parallel: 1, diff --git a/c_src/llama_cpp_ex/llama_nif.cpp b/c_src/llama_cpp_ex/llama_nif.cpp index c16d6da..395df6a 100644 --- a/c_src/llama_cpp_ex/llama_nif.cpp +++ b/c_src/llama_cpp_ex/llama_nif.cpp @@ -6,6 +6,9 @@ #include "log.h" #include "sampling.h" #include "speculative.h" +// Staging API: llama_model_target_layer_ids{,_n}, to validate a DFlash drafter +// before upstream's constructor asserts on it. decision.cpp includes it the same way. +#include "../../vendor/llama.cpp/src/llama-ext.h" #include #include #include @@ -2782,14 +2785,15 @@ chat_session_parse(ErlNifEnv* env, fine::ResourcePtr session, // Dirty: re-parses the whole reply, so its cost grows with the reply. LLAMA_NIF(chat_session_parse, ERL_NIF_DIRTY_JOB_CPU_BOUND); -// --- Speculative decoding (MTP) --- +// --- Speculative decoding (MTP, DFlash, DSpark) --- std::variant>, fine::Error> speculative_init( ErlNifEnv* env, fine::ResourcePtr ctx_tgt, fine::ResourcePtr ctx_dft, - int64_t n_draft) + int64_t n_draft, + fine::Atom type) { if (n_draft <= 0) { return fine::Error(std::string("n_draft must be > 0")); @@ -2798,22 +2802,66 @@ speculative_init( return fine::Error(kNoLogitsMessage); } + common_speculative_type spec_type; + const std::string type_name = type.to_string(); + if (type_name == "mtp") { + spec_type = COMMON_SPECULATIVE_TYPE_DRAFT_MTP; + } else if (type_name == "dflash") { + spec_type = COMMON_SPECULATIVE_TYPE_DRAFT_DFLASH; + } else if (type_name == "dspark") { + spec_type = COMMON_SPECULATIVE_TYPE_DRAFT_DSPARK; + } else { + return fine::Error("unknown speculative type :" + type_name); + } + + const llama_model* model_tgt = llama_get_model(ctx_tgt->ctx); + const llama_model* model_dft = llama_get_model(ctx_dft->ctx); + + // The DFlash/DSpark constructor GGML_ASSERTs that the draft names the + // target layers it reads, and it reads them by index from the target: a + // draft that is not a DFlash checkpoint, or one trained for a different + // target, aborts the VM instead of failing. Check both here. + if (spec_type != COMMON_SPECULATIVE_TYPE_DRAFT_MTP) { + const uint32_t n_ids = llama_model_target_layer_ids_n(model_dft); + if (n_ids == 0) { + return fine::Error(std::string( + "draft model is not a DFlash/DSpark drafter (it names no target layers)")); + } + const int32_t* ids = llama_model_target_layer_ids(model_dft); + const int32_t n_layer_tgt = llama_model_n_layer(model_tgt); + for (uint32_t k = 0; k < n_ids; k++) { + if (ids[k] < 0 || ids[k] >= n_layer_tgt) { + return fine::Error("draft model reads target layer " + std::to_string(ids[k]) + + ", but the target has " + std::to_string(n_layer_tgt) + + " layers; the drafter belongs to a different model"); + } + } + if (!common_speculative_are_compatible(model_tgt, model_dft)) { + return fine::Error(std::string( + "draft and target vocabularies are incompatible; the drafter belongs to a different model")); + } + } + // Probe partial-rollback support on the target context BEFORE // common_speculative_init. Two reasons: // 1. common_context_can_seq_rm clears the context's KV memory as a // side effect (see common.h:904). // 2. common_speculative_init's MTP impl calls - // llama_set_embeddings_pre_norm(ctx_tgt, true) in its constructor. - // Probing afterwards would clobber that flag and the MTP head - // would see garbage hidden states (acceptance drops to ~5%). - // Dense attention-only models report PART → partial seq_rm is native, - // skip the per-iter checkpoint path. Hybrid models (Qwen 3.6 MoE with - // GDN layers) report FULL → checkpoint every iteration. + // llama_set_embeddings_pre_norm(ctx_tgt, true) in its constructor, + // and the DFlash impl turns on the target-layer extraction there. + // Probing afterwards would clobber those flags and the draft would + // see garbage hidden states (MTP acceptance drops to ~5%). + // Dense attention-only models report PART → partial seq_rm is native. + // A hybrid target (Qwen 3.6/3.8: GDN layers beside attention) reports RS + // when it was created with n_rs_seq > 0 — it keeps that many recurrent + // snapshots and rolls back natively up to that depth, which is how + // upstream's server runs it (n_rs_seq = n_draft) — and FULL without them, + // which costs a state save every iteration plus a restore and re-decode on + // every partial accept. needs_ckpt is settled below, once n_draft is. const auto rm_type_tgt = common_context_can_seq_rm(ctx_tgt->ctx); - const bool needs_ckpt = (rm_type_tgt == COMMON_CONTEXT_SEQ_RM_TYPE_FULL); common_params_speculative params; - params.types = { COMMON_SPECULATIVE_TYPE_DRAFT_MTP }; + params.types = { spec_type }; params.draft.n_max = static_cast(n_draft); params.draft.ctx_tgt = ctx_tgt->ctx; params.draft.ctx_dft = ctx_dft->ctx; @@ -2827,10 +2875,25 @@ speculative_init( if (!spec) { return fine::Error(std::string( - "common_speculative_init returned null — does the model contain MTP heads " - "and does the draft context have ctx_type=:mtp with n_rs_seq>0?")); + "common_speculative_init returned null — does the draft context match " + "the speculative type (ctx_type: :mtp for MTP heads)?")); } + // The DFlash impl clamps n_max to the drafter's trained block size; keep + // what it settled on so the loop never asks for more. + const int32_t n_max = common_speculative_n_max(spec); + if (n_max > 0 && n_max < n_draft) { + n_draft = n_max; + } + + // Snapshots cover a verify batch of up to n_rs_seq + 1 tokens, i.e. a draft + // of up to n_rs_seq; past that the RS path is not guaranteed and the loop + // falls back to checkpoints, like upstream's server. + const bool needs_ckpt = + rm_type_tgt == COMMON_CONTEXT_SEQ_RM_TYPE_FULL || + (rm_type_tgt == COMMON_CONTEXT_SEQ_RM_TYPE_RS && + static_cast(n_draft) > llama_n_rs_seq(ctx_tgt->ctx)); + auto res = fine::make_resource( spec, std::move(ctx_tgt), std::move(ctx_dft), static_cast(n_draft), needs_ckpt); @@ -3338,6 +3401,15 @@ fine::Ok<> generate_mtp_tokens( // then — including it here would duplicate it in the context. // `sampled` sits at prompt[size - n_accepted_total - 1], since // the accept loop pushed n_accepted_total tokens after it. + // + // The draft context was rolled back to n_past above, so the + // drafter has lost these positions too: hand the re-decode to + // common_speculative_process exactly as the verify batch was, + // or the next draft is conditioned on a hole. A DFlash drafter + // reads the target's hidden states only through process, and + // without this its acceptance collapsed to ~3% on a hybrid + // target. Every row asks for output, as the verify batch did, + // because the drafter's extraction follows the output rows. if (n_accepted_total > 0) { llama_batch redo = llama_batch_init(n_accepted_total, 0, 1); BatchFreeGuard redo_guard(redo); @@ -3346,13 +3418,17 @@ fine::Ok<> generate_mtp_tokens( prompt[prompt.size() - n_accepted_total - 1 + i]; batch_push(redo, tok, n_past + static_cast(i), seq_id, - /*logits=*/ i == n_accepted_total - 1); + /*logits=*/ true); } int ret = decode_tracked(*sp.ctx_tgt, redo); if (ret != 0) { send_error("rollback re-decode failed: code=" + std::to_string(ret)); return fine::Ok(); } + if (!speculative_process(sp.spec, spec_batch, redo)) { + send_error("common_speculative_process failed after rollback"); + return fine::Ok(); + } } } else { // Dense model: native partial seq_rm trims the unaccepted diff --git a/lib/llama_cpp_ex/context.ex b/lib/llama_cpp_ex/context.ex index 97c8fea..495a986 100644 --- a/lib/llama_cpp_ex/context.ex +++ b/lib/llama_cpp_ex/context.ex @@ -145,10 +145,11 @@ defmodule LlamaCppEx.Context do with a separate `:default` context to drive multi-token-prediction speculative decoding via `LlamaCppEx.MTP`. * `:n_rs_seq` - Number of recurrent-state snapshots per sequence to retain for - partial rollback of speculative drafts. `0` (default) disables rollback. For an - MTP draft context, use `0` — the MTP implementation handles rollback - internally via cached hidden states (`pending_h` / `verify_h`), not - recurrent-state snapshots. + partial rollback of speculative drafts. `0` (default) disables rollback. + `LlamaCppEx.MTP.init/2` gives the target context one per draft position, + as upstream's server does; the draft context gets `0` — the drafters + handle their own rollback (MTP via cached hidden states, DFlash by + re-injecting target features), not via recurrent-state snapshots. * `:ctx_other` - An existing `%Context{}` whose raw pointer is passed as `llama_context_params.ctx_other`. Optional; omitted or `nil` is `nullptr`. `gemma4-assistant` requires it at construction. `MTP.init/2` diff --git a/lib/llama_cpp_ex/mtp.ex b/lib/llama_cpp_ex/mtp.ex index d5b1123..438f478 100644 --- a/lib/llama_cpp_ex/mtp.ex +++ b/lib/llama_cpp_ex/mtp.ex @@ -52,17 +52,19 @@ defmodule LlamaCppEx.MTP do target's token embeddings); Qwen's constructor leaves `cparams.ctx_other` as `nullptr`. - > #### Speculation is not always a win on hybrid models {: .warning} + > #### Hybrid models roll back on recurrent snapshots {: .info} > > A model that mixes recurrent (SSM) layers with attention ones — Qwen 3.8 is > 48 SSM layers to 16 attention layers — cannot roll back part of a sequence - > natively, so every speculative iteration snapshots and restores the whole - > recurrent state. That state is over 100 MiB at Qwen 3.8's sizes, and the - > cost lands in `stats/1`'s `timing_us.ckpt`. Measured on an M1 Max (Metal, - > Q4_K_M target + Q4_0 head), MTP was a net *slowdown* at every draft length: - > 0.89x at `n_draft: 1` (75% acceptance) falling to 0.56x at `n_draft: 5` - > (30%). Check `timing_us.ckpt` against `timing_us.total` before assuming - > speculation is helping, and prefer small `n_draft` when it is not. + > from its KV cache alone. `init/2` therefore creates the target context with + > one recurrent-state snapshot per draft position (`n_rs_seq: n_draft`), as + > upstream's server does, and a rejected draft is rolled back natively. Before + > that, every iteration saved the whole recurrent state (over 100 MiB at Qwen + > 3.8's sizes) and every partial accept restored it and re-decoded the + > accepted prefix: on GB10 that held Qwen3.8-27B NVFP4 to 21 tok/s at + > `n_draft: 2` where the snapshot path does 27, and on an M1 Max it made MTP a + > net slowdown. `stats/1`'s `timing_us.ckpt` is that save/restore, and stays + > zero unless `n_draft` exceeds the snapshots. Upstream currently requires `n_parallel = 1` for MTP. This module reflects that — a single MTP session decodes one sequence at a time. Reuse the same @@ -110,22 +112,34 @@ defmodule LlamaCppEx.MTP do end @doc """ - Initializes an MTP speculative session: builds the target context, the MTP - draft context (`ctx_type: :mtp`), and the underlying `common_speculative` - state. + Initializes a speculative session: builds the target context, the draft + context, and the underlying `common_speculative` state. ## Options - * `:draft_model` - A separate `LlamaCppEx.Model` holding the MTP head, for - checkpoints that ship it as a sidecar GGUF rather than inside the target - file (Qwen 3.8: `Qwen3.8-27B-Q4_K_M.gguf` plus `mtp-Qwen3.8-27B-Q4_0.gguf`; - Gemma4 E4B: a `gemma4` target plus a `gemma4-assistant` head). It must be - loaded with `load_mtp: true`. - Defaults to `nil`, meaning the head is expected inside the target model - and the draft context is built against it. + * `:type` - The drafter. Defaults to `:mtp`. + * `:mtp` - a Multi-Token Prediction head, inside the target GGUF or in a + sidecar passed as `:draft_model`. The draft context is built with + `ctx_type: :mtp`. + * `:dflash` - a DFlash / DFlash 2 block-diffusion drafter (GGUF + architecture `dflash`), passed as `:draft_model`. It drafts a whole + block in one pass from the target's hidden states, and is the fastest + option measured on GB10: 3.3× plain decode on Qwen3.8-27B NVFP4 against + 2.1× for its MTP head (see `docs/dgx-spark.md`). + * `:dspark` - a DSpark drafter (DFlash plus a Markov head), passed as + `:draft_model`. + * `:draft_model` - A separate `LlamaCppEx.Model` holding the drafter. + Required for `:dflash` and `:dspark`. For `:mtp` it is the sidecar head + for checkpoints that ship one rather than embedding it (Qwen 3.8: + `Qwen3.8-27B-Q4_K_M.gguf` plus `mtp-Qwen3.8-27B-Q4_0.gguf`; Gemma4 E4B: + a `gemma4` target plus a `gemma4-assistant` head), loaded with + `load_mtp: true`. Defaults to `nil`, meaning the MTP head is expected + inside the target model and the draft context is built against it. * `:n_draft` - Max draft tokens generated per iteration. Defaults to `3`. Larger values mean fewer model forward passes but lower per-iteration - acceptance; 2–4 is the sweet spot in practice. + acceptance; 2–4 is the sweet spot for MTP in practice. A DFlash drafter + caps it at its trained block size minus one (7 for Qwen3.8 DFlash 2), + and that is also where it measured fastest. * `:n_ctx` - Context size for both contexts. Defaults to `2048`. * Any `Context` tuning option (e.g. `:n_threads`, `:flash_attn`, `:type_k`/`:type_v`, `:offload_kqv`). Applied to both contexts. @@ -137,16 +151,34 @@ defmodule LlamaCppEx.MTP do def init(%Model{} = model, opts \\ []) do n_draft = Keyword.get(opts, :n_draft, 3) draft_model = Keyword.get(opts, :draft_model) + type = Keyword.get(opts, :type, :mtp) with :ok <- validate_n_draft(n_draft), - {:ok, head_model} <- validate_head(model, draft_model) do - do_init(model, head_model, opts, n_draft) + {:ok, head_model} <- validate_drafter(type, model, draft_model) do + do_init(model, head_model, opts, n_draft, type) end end defp validate_n_draft(n) when is_integer(n) and n > 0, do: :ok defp validate_n_draft(_), do: {:error, ":n_draft must be a positive integer"} + defp validate_drafter(:mtp, target, draft), do: validate_head(target, draft) + + # Whether the drafter really is a DFlash checkpoint for this target is checked + # in the NIF, where the model's target-layer metadata is readable: upstream's + # constructor asserts on it, so it has to be refused before init. + defp validate_drafter(type, _target, %Model{} = draft) when type in [:dflash, :dspark], + do: {:ok, draft} + + defp validate_drafter(type, _target, nil) when type in [:dflash, :dspark], + do: {:error, "type: #{inspect(type)} needs the drafter GGUF passed as draft_model:"} + + defp validate_drafter(type, _target, other) when type in [:dflash, :dspark], + do: {:error, ":draft_model must be a LlamaCppEx.Model, got: #{inspect(other)}"} + + defp validate_drafter(type, _target, _draft), + do: {:error, ":type must be :mtp, :dflash or :dspark, got: #{inspect(type)}"} + # Which model the draft context is built from, and whether it can actually # serve as one. Two shapes reach this: the head inside the target GGUF (no # `:draft_model`), and the head in a sidecar GGUF alongside it. @@ -216,25 +248,38 @@ defmodule LlamaCppEx.MTP do {:error, ":draft_model must be a LlamaCppEx.Model, got: #{inspect(other)}"} end - defp do_init(model, head_model, opts, n_draft) do + defp do_init(model, head_model, opts, n_draft, type) do base_ctx_opts = forwardable_context_opts(opts) - main_opts = Keyword.merge(base_ctx_opts, ctx_type: :default) - # Match upstream server: MTP draft context is created with n_rs_seq=0. - # The MTP impl handles state rollback internally via cached hidden - # states (pending_h / verify_h), not via recurrent-state snapshots. - draft_opts = Keyword.merge(base_ctx_opts, ctx_type: :mtp, n_rs_seq: 0) + + # Recurrent-state snapshots on the target, one per draft position, as + # upstream's server sizes them (common_params_speculative.need_n_rs_seq). + # A hybrid target (GDN layers beside attention) then rolls a rejected draft + # back natively instead of saving its state every iteration and re-decoding + # the accepted prefix on every partial accept: measured on Qwen3.8-27B + # NVFP4 with DFlash 2, that re-decode was the largest cost in the loop. A + # DFlash drafter clamps n_draft to its block size (at most 16) after init, + # so the snapshots are capped there rather than sized from what was asked. + n_rs_seq = if type == :mtp, do: n_draft, else: min(n_draft, 16) + main_opts = Keyword.merge(base_ctx_opts, ctx_type: :default, n_rs_seq: n_rs_seq) + # Match upstream (common_speculative_init_result): the draft context is + # created with n_rs_seq=0, as an MTP context only for an MTP head. The + # drafters handle rollback themselves (MTP via cached hidden states, + # DFlash by re-injecting target features), not via recurrent snapshots. + draft_ctx_type = if type == :mtp, do: :mtp, else: :default + draft_opts = Keyword.merge(base_ctx_opts, ctx_type: draft_ctx_type, n_rs_seq: 0) with {:ok, main_ctx} <- Context.create(model, main_opts), {:ok, mtp_ctx} <- Context.create(head_model, Keyword.merge(draft_opts, ctx_other: main_ctx)), {:ok, spec_ref} <- - LlamaCppEx.NIF.speculative_init(main_ctx.ref, mtp_ctx.ref, n_draft) do + LlamaCppEx.NIF.speculative_init(main_ctx.ref, mtp_ctx.ref, n_draft, type) do {:ok, %__MODULE__{ main_ctx: main_ctx, mtp_ctx: mtp_ctx, spec_ref: spec_ref, - n_draft: n_draft + # A DFlash drafter clamps n_draft to its block size; report what runs. + n_draft: LlamaCppEx.NIF.speculative_stats(spec_ref).n_draft }} end end @@ -404,11 +449,11 @@ defmodule LlamaCppEx.MTP do * `:tokens_emitted` - tokens streamed back to the caller * `:tokens_per_sec` - throughput over the active generation window * `:timing_us` - `%{draft: μs, verify: μs, sample: μs, ckpt: μs, other: μs, - total: μs}`. `:ckpt` is the recurrent-state save/restore that only hybrid - models pay and is zero elsewhere; on Qwen 3.8 it is large enough to decide - whether speculation helps at all. `:other` is whatever falls outside the - named buckets, dominated on Metal by GPU-sync waits from the previous - iteration's async verify decode. + total: μs}`. `:ckpt` is the recurrent-state save/restore a hybrid target + pays when it has fewer recurrent snapshots than `n_draft` (never, for a + session built by `init/2`), and is zero elsewhere. `:other` is whatever + falls outside the named buckets, dominated on Metal by GPU-sync waits + from the previous iteration's async verify decode. * `:n_draft` - max draft length configured at init Counters are cumulative across all `stream/3` / `generate/3` calls on this diff --git a/lib/llama_cpp_ex/nif.ex b/lib/llama_cpp_ex/nif.ex index ef0c2ec..ecb9ac1 100644 --- a/lib/llama_cpp_ex/nif.ex +++ b/lib/llama_cpp_ex/nif.ex @@ -177,7 +177,7 @@ defmodule LlamaCppEx.NIF do do: :erlang.nif_error(:not_loaded) # Speculative decoding (MTP) - def speculative_init(_ctx_tgt, _ctx_dft, _n_draft), do: :erlang.nif_error(:not_loaded) + def speculative_init(_ctx_tgt, _ctx_dft, _n_draft, _type), do: :erlang.nif_error(:not_loaded) def speculative_stats(_spec), do: :erlang.nif_error(:not_loaded) def speculative_print_stats(_spec), do: :erlang.nif_error(:not_loaded) diff --git a/test/llama_cpp_ex_test.exs b/test/llama_cpp_ex_test.exs index 8a63926..243ad26 100644 --- a/test/llama_cpp_ex_test.exs +++ b/test/llama_cpp_ex_test.exs @@ -1092,12 +1092,14 @@ defmodule LlamaCppExTest do %{model: model, mtp: mtp} end - test "contexts use no recurrent-state rollback slots", %{mtp: mtp} do - # Matching upstream server, the draft ctx is created with n_rs_seq=0 — - # MTP rolls back via cached hidden states (pending_h / verify_h), not - # recurrent-state snapshots. Both contexts report 0. + test "the target keeps a recurrent snapshot per draft position, the draft none", %{ + mtp: mtp + } do + # Matching upstream (need_n_rs_seq / common_speculative_init_result): the + # target rolls a rejected draft back on n_draft recurrent snapshots, and + # the draft ctx has none — MTP rolls back via cached hidden states. assert LlamaCppEx.Context.n_rs_seq(mtp.mtp_ctx) == 0 - assert LlamaCppEx.Context.n_rs_seq(mtp.main_ctx) == 0 + assert LlamaCppEx.Context.n_rs_seq(mtp.main_ctx) == mtp.n_draft end test "stream produces text and a sensible acceptance rate", %{mtp: mtp} do diff --git a/test/mtp_model_test.exs b/test/mtp_model_test.exs index 8aeee78..d88ce9e 100644 --- a/test/mtp_model_test.exs +++ b/test/mtp_model_test.exs @@ -305,10 +305,18 @@ defmodule LlamaCppEx.MTPSidecarTest do end # A hybrid target (Qwen 3.8: SSM layers beside attention ones) cannot roll back - # part of a sequence natively, so the loop snapshots the recurrent state every - # iteration. That cost is the difference between speculation paying off and not, - # so it gets its own bucket rather than hiding inside :other. - test "timing_us reports a ckpt bucket", %{session: session} do + # part of a sequence from its KV cache alone. init/2 gives it one recurrent + # snapshot per draft position, as upstream's server does, so a rejected draft + # rolls back natively. Without them the loop saves the recurrent state every + # iteration and re-decodes the accepted prefix on every partial accept, which + # measured 21 tok/s against 27 at n_draft 2 on Qwen3.8-27B NVFP4 — the :ckpt + # bucket is where that path would show. + test "a hybrid target rolls back on recurrent snapshots, not checkpoints", %{ + session: session + } do + assert LlamaCppEx.Context.n_rs_seq(session.main_ctx) == session.n_draft + assert LlamaCppEx.Context.n_rs_seq(session.mtp_ctx) == 0 + assert {:ok, _} = MTP.generate(session, "Count to ten:", max_tokens: 24, temp: 0.0) timing = MTP.stats(session).timing_us @@ -317,8 +325,7 @@ defmodule LlamaCppEx.MTPSidecarTest do assert Map.has_key?(timing, key), "timing_us is missing #{inspect(key)}" end - assert timing.ckpt > 0, - "a hybrid target should have paid for at least one recurrent-state snapshot" + assert timing.ckpt == 0, "the loop fell back to recurrent-state checkpoints" # The named buckets are carved out of total, never billed twice on top of it. assert timing.draft + timing.verify + timing.sample + timing.ckpt <= timing.total @@ -347,6 +354,88 @@ defmodule LlamaCppEx.MTPSidecarTest do end end +defmodule LlamaCppEx.DFlashTest do + # DFlash block-diffusion drafting through the same session API, type: :dflash. + # The drafter is a separate `dflash`-architecture GGUF trained against one + # target: it reads that target's hidden states at fixed layer indices. + # + # LLAMA_SMOKE_DFLASH_MODEL=/path/to/Qwen3.8-27B-Q4_K_M.gguf \ + # LLAMA_SMOKE_DFLASH_DRAFT_MODEL=/path/to/Qwen3.8-27B-DFlash2-Q4_K_M.gguf \ + # mix test --include dflash + # + # async: false and one session for the module, as for the MTP modules above. + use ExUnit.Case, async: false + + alias LlamaCppEx.MTP + + @moduletag :dflash + @moduletag timeout: 300_000 + + setup_all do + :ok = LlamaCppEx.init() + + {:ok, target} = + LlamaCppEx.load_model(LlamaCppEx.TestModels.path!(:dflash), n_gpu_layers: -1) + + {:ok, draft} = + LlamaCppEx.load_model(LlamaCppEx.TestModels.path!(:dflash_draft), n_gpu_layers: -1) + + # Ask for more than any DFlash block holds, to see it clamped. + {:ok, session} = MTP.init(target, type: :dflash, draft_model: draft, n_ctx: 2048, n_draft: 64) + + %{target: target, draft: draft, session: session} + end + + test "n_draft is clamped to the drafter's block size", %{session: session} do + # The loop sizes its verify batch from this; asking upstream for more than + # the block holds would draft nothing past it. + assert session.n_draft < 64 + assert session.n_draft == MTP.stats(session).n_draft + end + + test "generate/3 drafts and the target accepts some of it", %{session: session} do + before = MTP.stats(session) + + assert {:ok, text} = + MTP.generate(session, "List the days of the week, comma separated:", + max_tokens: 32, + temp: 0.0 + ) + + assert text =~ "Monday" + + now = MTP.stats(session) + assert now.drafts_generated > before.drafts_generated + + assert now.drafts_accepted > before.drafts_accepted, + "no draft accepted: the drafter is not seeing the target's hidden states" + end + + test "greedy output matches plain greedy decode on the target", %{ + target: target, + session: session + } do + # Short, for the near-tie reason MTPSidecarTest gives. + prompt = "The capital of France is" + opts = [max_tokens: 8, temp: 0.0] + + assert {:ok, spec} = MTP.generate(session, prompt, opts) + assert {:ok, plain} = LlamaCppEx.generate(target, prompt, opts ++ [n_ctx: 2048]) + assert spec == plain + end + + test "a model that is not a DFlash drafter is refused, not aborted", %{target: target} do + # Upstream's constructor GGML_ASSERTs on a drafter with no target layers. + assert {:error, message} = MTP.init(target, type: :dflash, draft_model: target, n_ctx: 512) + assert message =~ "not a DFlash/DSpark drafter" + end + + test "the drafter cannot stand in for an MTP head", %{target: target, draft: draft} do + assert {:error, message} = MTP.init(target, draft_model: draft, n_ctx: 512) + assert message =~ "load_mtp: true" + end +end + defmodule LlamaCppEx.MTPE4BSidecarTest do # Gemma4 E4B's target/draft split: the target GGUF is `gemma4` with zero nextn # layers, and a separate `mtp-gemma-4-*.gguf` is a `gemma4-assistant` sidecar @@ -442,8 +531,8 @@ defmodule LlamaCppEx.MTPE4BSidecarTest do assert now.tokens_emitted > before.tokens_emitted end - # E4B is dense, not hybrid — ckpt stays 0. The Qwen sidecar test pins - # ckpt > 0 for the hybrid case. + # E4B is dense, not hybrid — ckpt stays 0. The Qwen sidecar test pins that a + # hybrid target stays off the checkpoint path too. test "timing_us reports the expected buckets", %{target: target, session: session} do {:ok, prompt} = LlamaCppEx.Chat.apply_template(target, [%{role: "user", content: "Count to ten:"}], diff --git a/test/mtp_test.exs b/test/mtp_test.exs index 12aedd9..f7cbda0 100644 --- a/test/mtp_test.exs +++ b/test/mtp_test.exs @@ -30,6 +30,32 @@ defmodule LlamaCppEx.MTPTest do end end + describe "init/2 :type validation" do + @unloaded %LlamaCppEx.Model{ref: nil, load_mtp: true} + + test "a DFlash or DSpark drafter must be passed as :draft_model" do + # Without one there is nothing to build the draft context from; the MTP + # fallback (draft context against the target) would hand upstream's DFlash + # constructor a model with no target layers, which it asserts on. + for type <- [:dflash, :dspark] do + assert {:error, message} = MTP.init(@unloaded, type: type) + assert message =~ "draft_model" + end + end + + test "the drafter must be a Model" do + assert {:error, message} = MTP.init(@unloaded, type: :dflash, draft_model: "/path.gguf") + assert message =~ "must be a LlamaCppEx.Model" + end + + test "an unknown type is refused before any context exists" do + for type <- [:eagle3, "dflash", nil] do + assert {:error, message} = MTP.init(@unloaded, type: type) + assert message =~ ":type must be :mtp, :dflash or :dspark" + end + end + end + describe "init/2 requires a model loaded with load_mtp: true" do # Regression test for a silent break: upstream #26296 made the MTP head's # tensors opt-in at load time via a flag defaulting to false. Nothing on the diff --git a/test/support/test_models.exs b/test/support/test_models.exs index 1b8819d..da2d12e 100644 --- a/test/support/test_models.exs +++ b/test/support/test_models.exs @@ -29,6 +29,12 @@ defmodule LlamaCppEx.TestModels do # Its own env var because the two files are provisioned independently. mtp_e4b_draft: {"LLAMA_SMOKE_MTP_E4B_DRAFT_MODEL", "a Gemma4 E4B MTP sidecar (gemma4-assistant)"}, + # A DFlash / DFlash 2 drafter and the target it was trained for, e.g. + # Qwen3.8-27B-Q4_K_M.gguf with z-lab/Qwen3.8-27B-DFlash2-GGUF. The target + # is its own var even though it is usually the :mtp file, because a DFlash + # drafter reads specific target layers and only pairs with its own model. + dflash: {"LLAMA_SMOKE_DFLASH_MODEL", "a DFlash target"}, + dflash_draft: {"LLAMA_SMOKE_DFLASH_DRAFT_MODEL", "a DFlash drafter"}, # Decision models, one per readout: laya reads the embeddings output, # openjev reads label logits. Upstream's own test models # (ggml-org/tinylaya-for-testing-gguf, ggml-org/tinyopenjev-for-testing-gguf) @@ -52,6 +58,8 @@ defmodule LlamaCppEx.TestModels do | :mtp_draft | :mtp_e4b | :mtp_e4b_draft + | :dflash + | :dflash_draft | :decision_laya | :decision_openjev | :decision_clef diff --git a/test/test_helper.exs b/test/test_helper.exs index 90c371a..57b98ed 100644 --- a/test/test_helper.exs +++ b/test/test_helper.exs @@ -26,6 +26,10 @@ # (3 of 4 runs) and did not abort; by b11479 it aborts again # (4 of 6 runs at 23b0202a1). Either way it does not belong in # a green run. See test/mtp_model_test.exs. +# :dflash — DFlash speculative decoding (MTP.init type: :dflash); needs +# LLAMA_SMOKE_DFLASH_MODEL and LLAMA_SMOKE_DFLASH_DRAFT_MODEL, +# a target and the `dflash` drafter trained for it (e.g. +# Qwen3.8-27B-Q4_K_M and z-lab/Qwen3.8-27B-DFlash2-GGUF). # :slow — long-running comparison matrices (F16 vs Q8_0 KV cache); # needs LLAMA_SMOKE_GEN_MODEL # :decision — decision models (LlamaCppEx.Decision); needs both @@ -120,6 +124,7 @@ ExUnit.start( :mtp_sidecar, :decision, :decision_clef, + :dflash, :rpc_live ] ) From 24036b721588b55f2ead7a6d98c195a7ab379669 Mon Sep 17 00:00:00 2001 From: Niko Maroulis Date: Mon, 2 Nov 2026 07:42:38 -0500 Subject: [PATCH 05/49] docs: GB10 speculative decoding, NVFP4, binding overhead, two-node pipelining and transport; README speculative section; changelog --- .claude/plans/release-v0-8-64/plan.md | 155 +++++++++++ .claude/plans/release-v0-8-64/scratchpad.md | 34 +++ CHANGELOG.md | 51 ++++ README.md | 145 +++++----- bench/spark_spec.exs | 5 +- bench/spark_two_node.exs | 4 +- docs/dgx-spark.md | 255 ++++++++++-------- .../dev/lib/gguf_ex/.mix/compile.app_cache | Bin 0 -> 4343 bytes .../dev/lib/gguf_ex/.mix/compile.elixir | Bin 0 -> 1260 bytes .../dev/lib/gguf_ex/.mix/compile.elixir_scm | Bin 0 -> 49 bytes .../consolidated/Elixir.Collectable.beam | Bin 0 -> 9980 bytes .../consolidated/Elixir.Enumerable.beam | Bin 0 -> 15792 bytes .../gguf_ex/consolidated/Elixir.IEx.Info.beam | Bin 0 -> 9928 bytes .../gguf_ex/consolidated/Elixir.Inspect.beam | Bin 0 -> 24812 bytes .../consolidated/Elixir.JSON.Encoder.beam | Bin 0 -> 14068 bytes .../consolidated/Elixir.List.Chars.beam | Bin 0 -> 5348 bytes .../consolidated/Elixir.String.Chars.beam | Bin 0 -> 8892 bytes .../gguf_ex/ebin/Elixir.GgufEx.ExpertMap.beam | Bin 0 -> 11188 bytes .../lib/gguf_ex/ebin/Elixir.GgufEx.File.beam | Bin 0 -> 5640 bytes .../gguf_ex/ebin/Elixir.GgufEx.Parser.beam | Bin 0 -> 16436 bytes .../gguf_ex/ebin/Elixir.GgufEx.Tensor.beam | Bin 0 -> 4660 bytes .../lib/gguf_ex/ebin/Elixir.GgufEx.Types.beam | Bin 0 -> 6724 bytes .../dev/lib/gguf_ex/ebin/Elixir.GgufEx.beam | Bin 0 -> 3060 bytes .../_build/dev/lib/gguf_ex/ebin/gguf_ex.app | 1 + .../test/lib/gguf_ex/.mix/.mix_test_failures | Bin 0 -> 10 bytes .../test/lib/gguf_ex/.mix/compile.app_cache | Bin 0 -> 4343 bytes .../test/lib/gguf_ex/.mix/compile.elixir | Bin 0 -> 1443 bytes .../test/lib/gguf_ex/.mix/compile.elixir_scm | Bin 0 -> 49 bytes .../consolidated/Elixir.Collectable.beam | Bin 0 -> 9980 bytes .../consolidated/Elixir.Enumerable.beam | Bin 0 -> 15792 bytes .../gguf_ex/consolidated/Elixir.IEx.Info.beam | Bin 0 -> 9928 bytes .../gguf_ex/consolidated/Elixir.Inspect.beam | Bin 0 -> 24812 bytes .../consolidated/Elixir.JSON.Encoder.beam | Bin 0 -> 14068 bytes .../consolidated/Elixir.List.Chars.beam | Bin 0 -> 5348 bytes .../consolidated/Elixir.String.Chars.beam | Bin 0 -> 8892 bytes .../gguf_ex/ebin/Elixir.GgufEx.ExpertMap.beam | Bin 0 -> 11188 bytes .../lib/gguf_ex/ebin/Elixir.GgufEx.File.beam | Bin 0 -> 5640 bytes .../gguf_ex/ebin/Elixir.GgufEx.Parser.beam | Bin 0 -> 16436 bytes .../gguf_ex/ebin/Elixir.GgufEx.Tensor.beam | Bin 0 -> 4660 bytes .../Elixir.GgufEx.TestSupport.Builder.beam | Bin 0 -> 8300 bytes .../lib/gguf_ex/ebin/Elixir.GgufEx.Types.beam | Bin 0 -> 6724 bytes .../test/lib/gguf_ex/ebin/Elixir.GgufEx.beam | Bin 0 -> 3060 bytes .../_build/test/lib/gguf_ex/ebin/gguf_ex.app | 1 + .../align_1.gguf | Bin 0 -> 179 bytes .../align_128.gguf | Bin 0 -> 512 bytes .../align_16.gguf | Bin 0 -> 208 bytes .../align_4096.gguf | Bin 0 -> 12288 bytes .../align_64.gguf | Bin 0 -> 320 bytes .../align_8.gguf | Bin 0 -> 192 bytes .../hollow.gguf | Bin 0 -> 288 bytes .../moe2.gguf | Bin 0 -> 320 bytes .../dense.gguf | Bin 0 -> 256 bytes .../mismatch.gguf | Bin 0 -> 320 bytes .../dense0.gguf | Bin 0 -> 128 bytes .../moe.gguf | Bin 0 -> 13024 bytes .../sparse.gguf | Bin 0 -> 4194400 bytes .../whole.gguf | Bin 0 -> 4194400 bytes .../v2.gguf | Bin 0 -> 128 bytes .../basic.gguf | Bin 0 -> 768 bytes lib/llama_cpp_ex/rpc/server.ex | 11 +- scripts/spark/rpc_check.exs | 5 +- 61 files changed, 473 insertions(+), 194 deletions(-) create mode 100644 .claude/plans/release-v0-8-64/plan.md create mode 100644 .claude/plans/release-v0-8-64/scratchpad.md create mode 100644 gguf_ex/_build/dev/lib/gguf_ex/.mix/compile.app_cache create mode 100644 gguf_ex/_build/dev/lib/gguf_ex/.mix/compile.elixir create mode 100644 gguf_ex/_build/dev/lib/gguf_ex/.mix/compile.elixir_scm create mode 100644 gguf_ex/_build/dev/lib/gguf_ex/consolidated/Elixir.Collectable.beam create mode 100644 gguf_ex/_build/dev/lib/gguf_ex/consolidated/Elixir.Enumerable.beam create mode 100644 gguf_ex/_build/dev/lib/gguf_ex/consolidated/Elixir.IEx.Info.beam create mode 100644 gguf_ex/_build/dev/lib/gguf_ex/consolidated/Elixir.Inspect.beam create mode 100644 gguf_ex/_build/dev/lib/gguf_ex/consolidated/Elixir.JSON.Encoder.beam create mode 100644 gguf_ex/_build/dev/lib/gguf_ex/consolidated/Elixir.List.Chars.beam create mode 100644 gguf_ex/_build/dev/lib/gguf_ex/consolidated/Elixir.String.Chars.beam create mode 100644 gguf_ex/_build/dev/lib/gguf_ex/ebin/Elixir.GgufEx.ExpertMap.beam create mode 100644 gguf_ex/_build/dev/lib/gguf_ex/ebin/Elixir.GgufEx.File.beam create mode 100644 gguf_ex/_build/dev/lib/gguf_ex/ebin/Elixir.GgufEx.Parser.beam create mode 100644 gguf_ex/_build/dev/lib/gguf_ex/ebin/Elixir.GgufEx.Tensor.beam create mode 100644 gguf_ex/_build/dev/lib/gguf_ex/ebin/Elixir.GgufEx.Types.beam create mode 100644 gguf_ex/_build/dev/lib/gguf_ex/ebin/Elixir.GgufEx.beam create mode 100644 gguf_ex/_build/dev/lib/gguf_ex/ebin/gguf_ex.app create mode 100644 gguf_ex/_build/test/lib/gguf_ex/.mix/.mix_test_failures create mode 100644 gguf_ex/_build/test/lib/gguf_ex/.mix/compile.app_cache create mode 100644 gguf_ex/_build/test/lib/gguf_ex/.mix/compile.elixir create mode 100644 gguf_ex/_build/test/lib/gguf_ex/.mix/compile.elixir_scm create mode 100644 gguf_ex/_build/test/lib/gguf_ex/consolidated/Elixir.Collectable.beam create mode 100644 gguf_ex/_build/test/lib/gguf_ex/consolidated/Elixir.Enumerable.beam create mode 100644 gguf_ex/_build/test/lib/gguf_ex/consolidated/Elixir.IEx.Info.beam create mode 100644 gguf_ex/_build/test/lib/gguf_ex/consolidated/Elixir.Inspect.beam create mode 100644 gguf_ex/_build/test/lib/gguf_ex/consolidated/Elixir.JSON.Encoder.beam create mode 100644 gguf_ex/_build/test/lib/gguf_ex/consolidated/Elixir.List.Chars.beam create mode 100644 gguf_ex/_build/test/lib/gguf_ex/consolidated/Elixir.String.Chars.beam create mode 100644 gguf_ex/_build/test/lib/gguf_ex/ebin/Elixir.GgufEx.ExpertMap.beam create mode 100644 gguf_ex/_build/test/lib/gguf_ex/ebin/Elixir.GgufEx.File.beam create mode 100644 gguf_ex/_build/test/lib/gguf_ex/ebin/Elixir.GgufEx.Parser.beam create mode 100644 gguf_ex/_build/test/lib/gguf_ex/ebin/Elixir.GgufEx.Tensor.beam create mode 100644 gguf_ex/_build/test/lib/gguf_ex/ebin/Elixir.GgufEx.TestSupport.Builder.beam create mode 100644 gguf_ex/_build/test/lib/gguf_ex/ebin/Elixir.GgufEx.Types.beam create mode 100644 gguf_ex/_build/test/lib/gguf_ex/ebin/Elixir.GgufEx.beam create mode 100644 gguf_ex/_build/test/lib/gguf_ex/ebin/gguf_ex.app create mode 100644 gguf_ex/tmp/GgufExTest/test-alignment-handling-data-offset-and-tensor-offsets-respect-non-default-alignments-bbd0715e/align_1.gguf create mode 100644 gguf_ex/tmp/GgufExTest/test-alignment-handling-data-offset-and-tensor-offsets-respect-non-default-alignments-bbd0715e/align_128.gguf create mode 100644 gguf_ex/tmp/GgufExTest/test-alignment-handling-data-offset-and-tensor-offsets-respect-non-default-alignments-bbd0715e/align_16.gguf create mode 100644 gguf_ex/tmp/GgufExTest/test-alignment-handling-data-offset-and-tensor-offsets-respect-non-default-alignments-bbd0715e/align_4096.gguf create mode 100644 gguf_ex/tmp/GgufExTest/test-alignment-handling-data-offset-and-tensor-offsets-respect-non-default-alignments-bbd0715e/align_64.gguf create mode 100644 gguf_ex/tmp/GgufExTest/test-alignment-handling-data-offset-and-tensor-offsets-respect-non-default-alignments-bbd0715e/align_8.gguf create mode 100644 gguf_ex/tmp/GgufExTest/test-expert_map-1-MoE-metadata-without-fused-tensors-4b69cbab/hollow.gguf create mode 100644 gguf_ex/tmp/GgufExTest/test-expert_map-1-accepts-a-path-directly-d6d2446e/moe2.gguf create mode 100644 gguf_ex/tmp/GgufExTest/test-expert_map-1-dense-model-returns---error,--not_moe--8120b491/dense.gguf create mode 100644 gguf_ex/tmp/GgufExTest/test-expert_map-1-expert-dim-mismatch-is-an-error-34f1fdcd/mismatch.gguf create mode 100644 gguf_ex/tmp/GgufExTest/test-expert_map-1-expert_count-=-0-is-dense-b177585f/dense0.gguf create mode 100644 gguf_ex/tmp/GgufExTest/test-expert_map-1-maps--layer,-expert--to-contiguous-per-projection-ranges-9c6a7ebb/moe.gguf create mode 100644 gguf_ex/tmp/GgufExTest/test-parse-1-round-trip-never-reads-tensor-data--header-present,-data-region-is-a-hole-479f9980/sparse.gguf create mode 100644 gguf_ex/tmp/GgufExTest/test-parse-1-round-trip-never-reads-tensor-data--header-present,-data-region-is-a-hole-479f9980/whole.gguf create mode 100644 gguf_ex/tmp/GgufExTest/test-parse-1-round-trip-parses-GGUF-v2-bc68948d/v2.gguf create mode 100644 gguf_ex/tmp/GgufExTest/test-parse-1-round-trip-parses-a-v3-file-with-all-KV-value-types-and-two-tensors-5c283608/basic.gguf diff --git a/.claude/plans/release-v0-8-64/plan.md b/.claude/plans/release-v0-8-64/plan.md new file mode 100644 index 0000000..795528e --- /dev/null +++ b/.claude/plans/release-v0-8-64/plan.md @@ -0,0 +1,155 @@ +# Plan: Release v0.8.64 (no llama.cpp bump) + +**Depth**: quick · **Status**: completed · **Date**: 2026-10-31 → 2026-11-01 + +## Goal + +Publish v0.8.64 to Hex with precompiled NIFs for all 8 targets. It ships the +changes merged after v0.8.63 (CHANGELOG "Unreleased"), with llama.cpp staying +at `418f905a4`: + +- `LlamaCppEx.set_log_level/1`, `config :llama_cpp_ex, log_level:`, DEBUG + filtered by default (#114) +- `:tools` tag in CI against pinned Qwen3.5-0.8B (#114) +- `elixir_make ~> 0.10.1` (#114); req `~> 0.7` allowed, dep lock updates (#113) +- lock: decimal 3.2.0 / ecto 3.14.2 (#114) + +Done means: release not a draft, 8 assets, `checksum.exs` on master, Hex +0.8.64, and the `/tmp` end-to-end smoke passing against the published +package with the `~/Downloads` models. + +## Decisions + +- **No llama.cpp bump** (user). There are 22 upstream commits on master; + they belong in a separate bump release. So: no header diff, no + decision-port diff, no tokenizer-partition re-diff, no + `decision_compare.exs` rerun. No decision code changed since v0.8.63, which + was compared ALL MATCH. +- **Merge #115 first** (user). It is docs only and `.claude/` and `CLAUDE.md` + are not in the Hex `files` list, so the package is unaffected. +- **Release via PR then tag**, as for v0.8.60–v0.8.63; the version bump and + changelog go through CI before the tag. + +## Phase 1 — Prepare master + +- [x] [git] Merge #115 (squash, delete branch); `git pull` master — first + Inference smoke failed on a pre-existing test race (next item); re-run + green; merged as 3b63b52 +- [x] [test] Fix flaky `ServerSmokeTest` "halting a stream early …": + `attach_collector/1` was a global handler; it caught the previous + test's lingering server's `:done` (39 prompt tokens, `max_tokens`), + which `finish_slot/3` emits after replying. Collectors in + `server_smoke_test.exs` and the telemetry test in `llama_cpp_ex_test.exs` + now pin `metadata.server`; test-only, no CHANGELOG entry +- [x] [git] Branch `release-v0.8.64` from master (3b63b52) +- [x] [config] `mix.exs` `@version "0.8.63"` → `"0.8.64"` +- [x] [docs] CHANGELOG: rename `## Unreleased` → `## v0.8.64`, add an + intro line ("llama.cpp stays at `418f905a4`"), keep the existing + Added/Changed entries; #115 is docs only and gets no entry +- [x] [verify] `mix compile --warnings-as-errors`, `mix format --check-formatted`, + `mix credo --strict`, `mix dialyzer` (0 errors) — all clean + +## Phase 2 — Local test matrix (Metal, `GGML_METAL_NO_RESIDENCY=1`) + +Unset `LLAMA_BACKEND` only where a precompiled path is under test; here +everything is a local build (`LLAMA_BACKEND=metal`). + +- [x] [test] default: `mix test` — 436 passed, 194 excluded +- [x] [test] CI's set: `--include smoke --include embeddings --include slow + --include decision --include tools` with SmolLM2, bge-small, tinylaya, + tinyopenjev, Qwen3.5-0.8B — 601 passed, 29 excluded +- [x] [test] release-guide set: `--include smoke --include embeddings + --include slow --include mtp` with Qwen3.5-0.8B, Qwen3-Embedding-0.6B-f16, + Qwen3.6-35B-A3B-MTP-UD-Q4_K_XL — 585 passed, 45 excluded +- [x] [test] `--include embeddings` with embeddinggemma-2-Q8_0 — 447 passed +- [x] [test] `--include decision_clef` with Cloudflare_clef-flash-Q8_0 — 440 + passed (4/4 clef) +- [x] [test] `--include tools` with Llama-3.2-1B-Instruct (expect 10/11: + the round trip calls the tool again; documented, not a regression) — + 446/447, the round-trip test as expected; Qwen3.5 on Metal 447 +- [x] [test] `--include mtp_sidecar` with Qwen3.8-27B-Q4_K_M + + mtp-Qwen3.8-27B-Q4_0 (E4B pair not on disk, so that module skips) — + 442 passed, 6 skipped +- [x] [test] LLAMA_BACKEND=cpu `--include tools` (what CI runs) — 447 passed +- [x] [verify] Hex source build: `mix hex.build`, unpack into a temp dir, + `LLAMA_BACKEND=cpu mix compile`, confirm `vendor/llama.cpp` HEAD == + `418f905a4` and `input_tokenize.{h,cpp}` are in the tarball — 332K + package, build fetched `418f905a4`, NIF built +- [x] [docs] CHANGELOG v0.8.64: add the "Verified on …" paragraph with the + exact counts from this phase (format as in v0.8.63) + +## Phase 3 — PR and CI + +- [x] [git] Commit "Release v0.8.64", push, open PR — #117 (2 commits: + e081cbf test fix, 008f7bf release) +- [x] [ci] Watch CI: Setup, Tests, Credo, Dialyzer, Formatting, Inference + smoke (now including `:tools`), CUDA link cu12/cu13 — all green + (run 41250391316) +- [x] [ci] Confirm in the Inference smoke log: `Including tags: [... :tools]` + and 0 failures; no `xref: [exclude` annotation — 630 tests, 0 failures; + no xref annotations +- [x] [git] Merge PR (ask the user before merging), pull master — user chose + squash; 4f47d41 + +## Phase 4 — Tag and publish + +- [x] [release] `git tag v0.8.64` on the merge commit; `git push origin v0.8.64` +- [x] [release] Watch `Precompile NIFs`: 2× macos-15 Metal (log shows + `minos: 14.0`), 2× CPU, 4× CUDA (cu12/cu13 legs take ~50–110 min), + then "Checksum and publish the release" and "Publish to Hex" — run + 41255669230 all green in 85 min; both Metal legs `minos: 14.0` +- [x] [release] Verify: `gh release view v0.8.64` → not draft, 8 assets; + master has "Update checksum.exs for v0.8.64"; `mix hex.info llama_cpp_ex` + lists 0.8.64 — draft=false, 8 assets, 1041099, `~> 0.8.64` +- [x] [git] `git pull` master (picks up the checksum commit) + +## Phase 5 — End-to-end smoke from Hex (`/tmp`, `~/Downloads`) + +- [x] [e2e] Fresh project: `rm -rf /tmp/llama_e2e_0864 && mix new`, deps + `{:llama_cpp_ex, "== 0.8.64"}`, `{:req, "~> 0.7"}` +- [x] [e2e] `env -u LLAMA_BACKEND mix compile` → "Downloading precompiled NIF" + for `nif-2.18-aarch64-apple-darwin-0.8.64`, checksum passes, `otool` + minos 14.0; `mix.lock` resolves elixir_make 0.10.1 — all as expected + (httpc `max_header_size` notice, known) +- [x] [e2e] Copy `/tmp/llama_e2e/e2e.exs`; add log-level checks: + `set_log_level(:none)` before `init/0` → a load + tool call writes 0 + stderr lines; default level → the tool call writes no "awaiting trigger" + line; invalid level raises `ArgumentError` — child VM via + `loglevel.exs`, stderr to file +- [x] [e2e] Run with `GGML_METAL_NO_RESIDENCY=1`: all checks PASS (generate, + stream, chat, json_schema, #108 ×3 incl. server and Llama 3.2, #110 ×2, + #111 ×6, embeddings, #109 ×3 incl. Clef noul > 0.5, log level ×3) — + 23 passed, 0 failed; clef noul 0.98; :none 0 stderr lines, default 198 +- [x] [e2e] Optional: repeat compile on a fresh project with + `LLAMA_BACKEND=cpu` to confirm the Hex source build from the published + tarball — built at `418f905`, CPU generate " Paris." + +## Verification summary + +| Gate | Command / evidence | +|---|---| +| Compile/lint | `mix compile --warnings-as-errors`, format, credo --strict, dialyzer | +| Local tests | Phase 2 matrix, counts recorded in CHANGELOG | +| CI | PR checks all green, Inference smoke ran `:tools` | +| Release | workflow green, release published with 8 assets, Hex 0.8.64 | +| Published package | `/tmp` e2e: precompiled download + all checks PASS | + +## Iron Law check + +No application code changes in this plan (version, changelog only). Iron Law +#27 (no special-parsed tokenization of rendered prompts) is unaffected; the +e2e #108/#109 checks re-verify it on the published artifact. + +## Risks + +- **CUDA legs are slow** (47–110 min) and can hit runner capacity; the + release stays a draft until all 8 legs pass, so nothing partial reaches Hex. +- **macos-15 arm64 capacity**: the workflow annotated queueing delays for + v0.8.63, so expect waits. +- **Flaky small-model tool tests on CI CPU**: Qwen3.5-0.8B passed 11/11 on CPU + locally and in CI once. If CI flakes, investigate before re-running; + don't loosen assertions to get green. +- **Local Hex auth expired** (`mix hex.user auth`): this only matters for a + manual publish, since the workflow publishes with its own key. +- **Tag hygiene**: move a tag only while the release is still a draft and + Hex has nothing (see `.claude/solutions/deployment-issues/macos-14-runner-brownout-precompile-20261031.md`). diff --git a/.claude/plans/release-v0-8-64/scratchpad.md b/.claude/plans/release-v0-8-64/scratchpad.md new file mode 100644 index 0000000..5c36c1d --- /dev/null +++ b/.claude/plans/release-v0-8-64/scratchpad.md @@ -0,0 +1,34 @@ +# Scratchpad: release v0.8.64 + +## DECISION + +- No llama.cpp bump (user, 2026-10-31). Upstream master was 22 commits + ahead of `418f905a4` (head `ddf48f85c`); do that as its own release with + the full release-guide diff (header, decision port, tokenizer partition). +- Merge #115 (docs only) before tagging (user). +- No research agents spawned: the process is fixed by docs/release-guide.md + and was exercised end to end for v0.8.63 the same day. +- Skip decision_compare.exs: no decision or tokenizer code changed since + v0.8.63, which was ALL MATCH on 9 models. + +## Known, not regressions + +- Llama-3.2-1B-Instruct `:tools` round trip: calls the tool again (10/11). +- OTP 29.0.3 locally: `Invalid option {max_header_size,65536} ignored` during + the NIF download is expected (httpc predates the option). +- "Found packages with security advisories" should be gone after #114 + (decimal 3.2.0); if it reappears, check `mix deps.get` output. + +## DEAD-END + +(none yet) + +## Flake found on #115 CI (2026-10-31) + +`ServerSmokeTest` "halting a stream early cancels generation" got another +server's `:done` (prompt 39, `max_tokens`) — the preceding chat_completion +test's server, still alive after its test exited (ExUnit doesn't wait for +linked processes), emitting telemetry after `GenServer.reply`. Fixed by +pinning `metadata.server` in the collectors. Not reproducible locally on Metal +with seed 489492 (timing); evidence is the CI log ordering (handler attach at +54.311, stale done logged 54.314). diff --git a/CHANGELOG.md b/CHANGELOG.md index 309afd3..0c9c10c 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,5 +1,56 @@ # Changelog +## Unreleased + +Validated on two DGX Sparks (GB10, CUDA 13.0): the full suite with every +model tag on CUDA, an end-to-end run with three models resident, a model +layer-split across both nodes beside a local one, and the published 0.8.66 +package source-built from a fresh project. See `docs/dgx-spark.md` for the +numbers behind the entries below. + +### Added + +- `LlamaCppEx.MTP.init/2` takes `type: :dflash` or `type: :dspark` with the + drafter passed as `:draft_model`, for upstream's DFlash / DFlash 2 + block-diffusion drafters and DSpark. On Qwen3.8-27B NVFP4 on GB10, DFlash 2 + decodes at 3.1× plain (44.2 against 14.3 tok/s), where the model's MTP head + reaches 2.0×; on an M1 Max, 2.5× on the Q4_K_M build. A drafter that is not + a DFlash checkpoint, or reads layers the target does not have, is refused + with an error: upstream asserts on it. `n_draft` is clamped to the drafter's + block size and `%MTP{}.n_draft` reports the clamped value. + +### Fixed + +- `LlamaCppEx.RPC.add_server/1`, `ping/1` and `Model.load/2`'s + `:rpc_servers` aborted the VM on an RPC build when the endpoint was + unreachable, unparseable, not an RPC worker, or spoke another protocol + version. Upstream's registration has aborted on all four since #18626 + moved the connect into `rpc_dispatcher::start`; the NIF now connects and + exchanges the HELLO itself first (5 s timeout) and returns + `{:error, :unreachable}`. The default build (no `LLAMA_RPC`) was never + affected. The upstream fix is on `nyo16/llama.cpp` branch + `rpc-add-server-no-abort`. +- MTP on a hybrid target (Qwen 3.6 / 3.8: recurrent layers beside attention) + no longer saves the recurrent state every iteration and re-decodes the + accepted prefix on every partial accept. `MTP.init/2` creates the target + context with one recurrent snapshot per draft position, as upstream's server + does, so a rejected draft rolls back natively. GB10, `n_draft: 2`: + Qwen3.8-27B NVFP4 21.1 → 26.8 tok/s, Qwen3.6-35B-A3B 1.42× plain where the + docs had it at 0.95×. M1 Max: Qwen3.8-27B with its sidecar head went from a + net loss at every `n_draft` to 1.96× at `n_draft: 3`. +- After a checkpoint rollback the re-decoded prefix is now fed to the + drafter, which had been left with a gap in its context; DFlash acceptance + was ~3% without it. + +### Changed + +- `LlamaCppEx.Context`'s `:n_rs_seq` docs, `LlamaCppEx.MTP`'s hybrid-model + note and `stats/1`'s `:ckpt` description describe the snapshot rollback. +- RPC docs: `GGML_RPC_NO_RDMA` is upstream's runtime switch to keep a peer on + TCP (`scripts/spark/rpc-worker.sh --tcp` now uses it), and layer split over + RPC is pipelined: the RPC backend implements async compute and events + (#18626), so llama.cpp enables pipeline parallelism across the nodes. + ## v0.8.66 llama.cpp bumped to `785322d17` diff --git a/README.md b/README.md index 5ec8dc2..a5cd92d 100644 --- a/README.md +++ b/README.md @@ -1006,84 +1006,73 @@ The manager estimates footprint from GGUF size (plus a coarse KV-cache estimate Model cleanup is garbage-collection based. `unload/1` stops the backing server (dropping its context and model references) and forces a GC. Because reclamation is by GC, **any caller still holding a `%LlamaCppEx.Model{}` obtained via `fetch_model/1` keeps the model alive** past `unload/1` — prefer id-based routing and avoid holding raw refs. -## Speculative decoding (MTP) - -Multi-Token Prediction speculative decoding (upstream PR [#22673](https://github.com/ggml-org/llama.cpp/pull/22673)) drafts several tokens at once via a head shipped inside the same GGUF as the target model. Upstream llama-server reports ~2x speedup at ~75% draft acceptance on Qwen 3.6. - -> **Performance note: Apple Silicon.** The upstream 2× claim is from NVIDIA datacenter GPUs, where a batched verify decode costs ~1.2× a single-token decode. On Apple Silicon (Metal), a 4-wide verify costs ~2.4× a single decode, which cancels MTP's iteration savings. We measured upstream's own `llama-server --spec-type draft-mtp` on M1 Max: **39.80 tok/s with MTP vs 39.14 tok/s plain** on Qwen 3.6 35B-A3B (1.02×) — i.e. effectively zero speedup from the reference implementation itself. This matches the pattern in upstream [#23011](https://github.com/ggml-org/llama.cpp/issues/23011); a Metal MTP optimization is tracked in [#23114](https://github.com/ggml-org/llama.cpp/pull/23114). -> -> **Tuning for Apple Silicon:** use `n_draft: 1`. With one draft per iteration the verify batch is only 2-wide (much cheaper on Metal) and acceptance jumps to ~79% on Qwen 3.6 35B-A3B. Our measurements on M1 Max with `n_draft: 1`: -> - Qwen 3.6 35B-A3B-MTP (hybrid MoE): plain 39.5 → MTP **44.0 tok/s (1.11×)** -> - Qwen 3.6 27B (dense): plain 10.7 → MTP **10.6 tok/s (~1.0×, neutral)** -> -> Larger `n_draft` hurts on Metal because verify cost grows faster than acceptance benefit. - -> **Performance note: NVIDIA GB10 (DGX Spark).** MTP does pay here, but nothing -> like the upstream 2×, and the best `n_draft` is not 3. Qwen3.6-35B-A3B -> UD-Q4_K_XL from the `-MTP` build, 128-token greedy generations, plain and MTP -> interleaved in one process so drift hits both arms equally (n=11 each): -> -> | | median tok/s | range | vs plain | -> |---|---|---|---| -> | plain | 61.4 | 61.2–62.4 | — | -> | MTP `n_draft: 2` | **71.2** | 62.5–75.5 | **+16%** | -> -> The ranges do not overlap — MTP's slowest run beat plain's fastest — so the -> gain is real despite MTP being the noisier arm by an order of magnitude. -> -> Sweeping `n_draft` on the same model, though, puts the optimum at 2 rather -> than 3, and the engine's own counters say why: -> -> | `n_draft` | acceptance | tokens/iteration | tok/s | -> |---|---|---|---| -> | 2 | 68.5% | 2.38 | 63.0 | -> | 3 | 57.2% | 2.73 | 52.8 | -> -> Going from 2 to 3 buys 15% more tokens per iteration and pays 31% more drafting -> plus 10% more verify for them, because the third draft position is the one -> least likely to be accepted. Marginal acceptance decays faster than marginal -> cost, so the extra draft loses money. In a five-run sweep `n_draft: 3` came out -> 2% *below* plain and `n_draft: 4` 14% below. -> -> So the shape matches Apple Silicon even though the cause differs: on Metal the -> wide verify is expensive, while GB10 is a unified-memory part whose MoE decode -> is memory-bandwidth bound, and a wider verify reads more expert weights per -> step. Both end up wanting a narrower draft than a datacenter GPU does. Treat -> `n_draft: 3` as the datacenter default the upstream 2× assumes, not as a value -> that transfers. - -> **Performance note: Qwen 3.8 27B (hybrid SSM, sidecar head).** This one is -> shaped by a cost the models above do not pay. Qwen 3.8 puts 48 SSM layers -> beside 16 attention ones, and a recurrent layer cannot be rolled back to an -> arbitrary position, so every speculative iteration snapshots and restores the -> whole recurrent state — 150 MiB of it at these sizes. `stats/1` reports that -> separately as `timing_us.ckpt`. Q4_K_M target + Q4_0 sidecar head, 120-token -> greedy generations: -> -> | `n_draft` | acceptance | M1 Max (Metal) | GB10 (DGX Spark) | -> |---|---|---|---| -> | 1 | 75.0% | 0.89× | **1.24×** | -> | 2 | 54–59% | 0.66× | 1.17× | -> | 3 | 40–44% | 0.68× | 1.09× | -> | 4 | 32% | — | 0.96× | -> | 5 | 30% | 0.56× | — | -> -> On Metal MTP is a net loss at every draft length: `ckpt` alone was 1.8 s of a -> 12.5 s run at `n_draft: 1` and 6.9 s of 16.3 s at `n_draft: 3`. On GB10 the -> same snapshot is cheap enough that `n_draft: 1` wins, and — unlike the MoE -> above, whose optimum was 2 — the optimum here is 1, monotonically decreasing -> after it. Measure `ckpt` against `total` before trusting speculation on any -> hybrid model. -> -> Both arms of the GB10 column are warm-cache numbers. A first run off cold page -> cache reads ~19 GB and reported a 4.18 tok/s baseline against 10.83 tok/s warm, -> which inverts the comparison entirely. - -### Other speculative types (EAGLE-3, DFlash, n-gram) - -Upstream llama.cpp implements more speculative types behind the same `common_speculative` API — `draft-eagle3`, `draft-dflash` (block-diffusion drafting via a separate drafter GGUF), and several n-gram self-speculation modes, plus `--spec-default`, which stacks n-gram speculation on top of a model-based drafter. **This binding currently exposes only MTP**: `MTP.init/2` pins `COMMON_SPECULATIVE_TYPE_DRAFT_MTP`, so the other types and the combinations are not reachable from here. The draft *model* is no longer tied to the target, though — see `:draft_model` below for the target/sidecar split. - -> **DFlash status (July 2026, llama.cpp b9932).** DFlash runs end-to-end on Metal via upstream `llama-cli`/`llama-server`, but we measured it *slower* than plain decoding on Apple Silicon at small target sizes: Qwen3.5-4B target + z-lab 0.6B drafter on M4 Max reached 42 tok/s with DFlash vs 85 tok/s plain (greedy sampling; 30% draft acceptance, mean accepted run 2.8 — and stochastic sampling at `temp 0.8` collapses acceptance to ~7%). The Metal economics are the same as the MTP note above (wide verify batches are expensive), and the community drafter-GGUF conversions are still churning: of three third-party Qwen 4B drafter repos tested, only one loads with current upstream (the others hit the `dflash-draft` arch mismatch [#25116](https://github.com/ggml-org/llama.cpp/issues/25116) or lack the `target_layers` metadata added by the conversion refactor [#25110](https://github.com/ggml-org/llama.cpp/pull/25110)). Worth revisiting when the drafter format settles; the natural entry point is a `spec_type` + drafter-model option on `speculative_init`. +## Speculative decoding (MTP, DFlash) + +`LlamaCppEx.MTP` drives upstream's `common_speculative` loop: a drafter proposes +several tokens, the target verifies them in one batched decode, and greedy +output is the target's own (up to the batch-width rounding noted in the +`MTPSidecarTest` comments — upstream's server diverges from its own plain decode +at the same places). Three drafters are supported through `:type`: + +- `:mtp` (default) — a Multi-Token Prediction head (upstream PR + [#22673](https://github.com/ggml-org/llama.cpp/pull/22673)), inside the + target GGUF or in a sidecar passed as `:draft_model`. +- `:dflash` — a DFlash / DFlash 2 block-diffusion drafter: a separate small + GGUF (architecture `dflash`) that drafts a whole block in one pass from the + target's hidden states. Pass it as `:draft_model`. +- `:dspark` — DSpark (DFlash plus a Markov head), the same way. + +```elixir +{:ok, target} = LlamaCppEx.load_model("Qwen3.8-27B-Q4_K_M.gguf", n_gpu_layers: -1) +{:ok, drafter} = LlamaCppEx.load_model("Qwen3.8-27B-DFlash2-Q4_K_M.gguf", n_gpu_layers: -1) +{:ok, spec} = LlamaCppEx.MTP.init(target, type: :dflash, draft_model: drafter, n_draft: 7) +``` + +**Measured.** 256-token greedy chat completions (thinking off), four prompts +run twice, median decode rate; `bench/spark_spec.exs` reproduces it on either +machine: + +| Qwen3.8-27B (dense, hybrid SSM) | GB10, NVFP4 MID-HIGH | M1 Max, Q4_K_M + sidecar head | +|---|---|---| +| plain | 14.3 tok/s | 12.7 tok/s | +| MTP `n_draft: 2` | 26.8 (1.87×, 76% accepted) | 22.1 (1.75×) | +| MTP `n_draft: 3` | 28.6 (2.00×) | 24.8 (1.96×) | +| DFlash 2 `n_draft: 7` | **44.2 (3.10×, 42% accepted)** | **31.8 (2.53×)** | + +| Qwen3.6-35B-A3B (MoE, hybrid SSM) | GB10, UD-Q4_K_M | M1 Max, UD-Q4_K_XL | +|---|---|---| +| plain | 68.3 tok/s | 55.4 tok/s | +| MTP `n_draft: 1` | 86.9 (1.27×) | 69.3 (1.25×) | +| MTP `n_draft: 2` | **96.7 (1.42×)** | **74.5 (1.34×)** | +| MTP `n_draft: 3` | 91.6 (1.34×) | 73.5 (1.33×) | + +- **DFlash 2 is the fastest drafter where one exists for the model** — 3.1× on + GB10, against 2.0× for the same checkpoint's MTP head and 1.8× for DSpark + (`magnitudedev/Qwen3.8-27B-DSpark-GGUF`, measured through upstream's + `llama-server`). Its `n_draft` caps at the drafter's block size minus one (7 + for these), which is also where it measured best. +- **MTP wants `n_draft: 2–3` on a dense model and 2 on a sparse MoE**, where + only ~3B parameters move per token and a wider verify reads more experts. +- Within 2–5% of upstream's `llama-server` with the same drafters, on GB10. + +These numbers postdate a rollback fix: hybrid targets used to save their whole +recurrent state every iteration and re-decode the accepted prefix on every +partial accept, which made MTP a net loss on Apple Silicon and held GB10 to +~1.5×. `MTP.init/2` now gives the target context one recurrent snapshot per +draft position (`n_rs_seq`), as upstream's server does, and `stats/1`'s +`timing_us.ckpt` stays zero. + +### Other speculative types (EAGLE-3, n-gram) + +Upstream also implements `draft-eagle3` and several n-gram self-speculation +modes behind the same API, plus `--spec-default`, which stacks n-gram +speculation on top of a model-based drafter. Those are not exposed here. + +### Drafters + +- [`z-lab/Qwen3.8-27B-DFlash2-GGUF`](https://huggingface.co/z-lab/Qwen3.8-27B-DFlash2-GGUF) + — DFlash 2 for Qwen3.8-27B (Q4_K_M 1.1 GB). Pairs with any quantization of + the target, NVFP4 included. ### Models with MTP heads diff --git a/bench/spark_spec.exs b/bench/spark_spec.exs index bff47d4..f527587 100644 --- a/bench/spark_spec.exs +++ b/bench/spark_spec.exs @@ -4,7 +4,8 @@ # mix run bench/spark_spec.exs [config ...] # # A config is `plain`, `mtp:` (the head inside the target GGUF), -# `dflash::` or `dspark::`. With none given: +# `mtp::`, `dflash::` or +# `dspark::`. With none given: # plain, mtp:1..4. Each config runs the same four chat-templated prompts twice, # greedy, 256 tokens, thinking off, and reports the median decode rate (first # token to last, so prefill is excluded) and the draft acceptance. @@ -80,7 +81,7 @@ IO.puts("|---|---|---|---|---|---|---|") [type, n | rest] -> draft = case rest do - [path] -> elem(LlamaCppEx.load_model(path, n_gpu_layers: -1), 1) + [path] -> elem(LlamaCppEx.load_model(path, n_gpu_layers: -1, load_mtp: type == "mtp"), 1) [] -> nil end diff --git a/bench/spark_two_node.exs b/bench/spark_two_node.exs index d6e5a1e..2e06af5 100644 --- a/bench/spark_two_node.exs +++ b/bench/spark_two_node.exs @@ -15,8 +15,8 @@ Code.require_file("helpers.exs", __DIR__) # b2 The actual point. A model that does NOT fit one node: two-node RPC # versus single-node paging weights off NVMe. This is the number that # justifies the second Spark, and it is allowed to come out negative. -# b3 RDMA versus TCP, in tokens. There is no runtime switch, so TCP is -# forced with GGML_RDMA_DEV set to a device that does not exist. +# b3 RDMA versus TCP, in tokens. One run per transport; see the b3 clause +# for the worker flags (`--tcp` sets GGML_RPC_NO_RDMA, `--link lan`). # b4 Batching amortisation. Per-token RTT is fixed per *graph*, not per # token, so n_parallel should amortise it. Measure, do not assume. # diff --git a/docs/dgx-spark.md b/docs/dgx-spark.md index 664fe17..f552722 100644 --- a/docs/dgx-spark.md +++ b/docs/dgx-spark.md @@ -138,7 +138,7 @@ LLAMA_CUDA_ARCH=121a-real \ `remote.sh` exports all three, so on a Spark this is just `mix compile`. -### Why `LLAMA_CPU_ARM_ARCH` is not optional +### Why `LLAMA_CPU_ARM_ARCH` matters, and when it does not ggml probes the host with `-mcpu=native` when `GGML_NATIVE` is on, which is the default. On GB10 with GCC 13.3 that probe **fails silently**: the compiler @@ -154,6 +154,21 @@ Measured on the emitted `libggml-cpu.a`: Those are the Q4/Q8 quantized matmul kernels. +They run only when the CPU does the math: CPU-only builds, `n_gpu_layers` +below the layer count, MoE experts kept on the CPU. With every layer on the +GPU the flag changes nothing measurable. A fresh project depending on the +published package (no `LLAMA_*` variables, so `-mcpu=native`, CUDA picked up +as `121a-real` automatically) against this repo's tuned build, Qwen3.6-35B-A3B +fully offloaded on spark-2, median of 5: + +| build | TTFT, ~2k-token prompt | decode | +|---|---|---| +| `{:llama_cpp_ex, "0.8.66"}` from Hex, defaults | 698.0 ms | 66.78 tok/s | +| `LLAMA_CPU_ARM_ARCH` + `LLAMA_CUDA_ARCH` | 702.8 ms | 66.49 tok/s | + +So a Hex user on a Spark gets full GPU speed with no flags; set them for +CPU-side work. + ### Why `LLAMA_CUDA_ARCH` must accompany it Naming the CPU architecture requires `GGML_NATIVE=OFF`, and with native off @@ -285,80 +300,94 @@ C-state and there is no exit latency to avoid. **So do not go asking for `idle=poll` on the kernel cmdline.** It was the one thing this work expected to need root for, and the measurement retired it. -## Qwen3.6 and speculative decoding (MTP) +## The binding costs nothing measurable + +Same model, same llama.cpp commit (`785322d17`), upstream's own tools against +`bench/spark_overhead.exs`. Qwen3-8B Q4_K_M, 128 greedy tokens, decode timed +from the first token to the last: + +| path | streams | upstream | llama_cpp_ex | +|---|---|---|---| +| single stream (`llama-bench` tg128 / `LlamaCppEx.stream/3`) | 1 | 44.0 tok/s | 43.5 tok/s | +| server (`llama-server -np 8` / `Server`, `n_parallel: 8`) | 8 | 286 tok/s aggregate | 286 tok/s aggregate | -Two shapes of the current generation, each measured with and without the -Multi-Token Prediction head. The MTP repos are the *same weights* plus the head, -so this is a clean A/B rather than a comparison across quantizations. +`llama-batched-bench` reaches 311 tok/s at 8 streams because it never samples: +every server has to wait for the logits, sample on the CPU and submit the next +step, and that serial dependency is the 8%. Upstream's `--backend-sampling` +(sampling on the GPU) measured within 1% of CPU sampling here, so it is not +exposed. Tuning on this machine is therefore model and drafter choice, not the +binding. -256-token greedy generations through the chat template, **median of 5** with the -range alongside. Five samples matter here: MTP is the noisier arm, and a single -run per setting is not enough to tell a real 1.6× from a lucky draw. The plain -model is freed before the MTP arm runs — leaving ~20 GB of unrelated weights -resident cost the MTP arm about 10% on this unified-memory part, which is -exactly the kind of confound that flips a conclusion. +## Qwen3.8-27B NVFP4 -### Qwen3.6-27B Q4_K_M — dense +`esatapedico/Qwen3.8-27B-NVFP4-MTP-GGUF`, `MID-HIGH` tier: every attention and +FFN weight in native NVFP4 (GGML type 40), Q8_0 heads, the MTP head embedded. +Against the Q4_K_M build of the same model, `llama-bench`: -| config | decode t/s | range | vs baseline | acceptance | +| | size | pp512 | pp2048 | tg128 | |---|---|---|---|---| -| no MTP head | 11.59 | 11.5–11.6 | — | — | -| MTP `n_draft: 1` | 16.88 | 16.9–16.9 | 1.46× | 86.9% | -| MTP `n_draft: 2` | 18.38 | 18.2–18.4 | 1.59× | 76.4% | -| **MTP `n_draft: 3`** | **18.65** | 18.4–18.7 | **1.61×** | 68.2% | -| MTP `n_draft: 4` | 17.42 | 17.3–17.5 | 1.50× | 57.1% | +| Q4_K_M | 17.7 GiB | 1015 | 1023 | 11.21 | +| NVFP4 MID-HIGH | 15.7 GiB | 1236 | 1265 | **14.19** | -No range overlaps the baseline: **MTP is worth 1.6× on the dense model**, and -`n_draft` 2 and 3 are within noise of each other. +NVFP4 is +22% prefill and +27% decode. Decode reads 15.7 GiB per token at +14.2 tok/s — 240 GB/s, 88% of GB10's 273 GB/s — so it is bandwidth-bound and +there is little left to take from the kernels. Prefill runs W4A4 on the +Blackwell FP4 MMA (`mma.sync ... kind::mxf4nvf4`); an `nsys` profile of pp2048 +puts 53% of GPU time in that matmul, 9% in activation quantization and ~23% in +element-wise ops (SwiGLU, gating muls, adds, the GDN conv-state concat). -### Qwen3.6-35B-A3B UD-Q4_K_M — MoE +## Speculative decoding: MTP, DFlash 2, DSpark -| config | decode t/s | range | vs baseline | acceptance | -|---|---|---|---|---| -| no MTP head | 65.36 | 65.1–65.8 | — | — | -| MTP `n_draft: 1` | 67.56 | 67.0–67.7 | 1.03× | 81.0% | -| MTP `n_draft: 2` | 62.29 | 61.4–62.3 | 0.95× | 67.2% | -| MTP `n_draft: 3` | 63.28 | 63.0–63.5 | 0.97× | 64.9% | -| MTP `n_draft: 4` | 47.66 | 44.8–48.6 | 0.73× | 40.9% | - -Essentially neutral at best, and a loss past `n_draft: 1`. - -> The README reports **+16%** at `n_draft: 2` for Qwen3.6-35B-A3B on GB10, from -> an interleaved n=11 run on **UD-Q4_K_XL**. This measurement is UD-Q4_K_**M**, -> and the draft acceptance rates agree closely (67.2% here versus 68.5% there at -> `n_draft: 2`) while the throughput economics do not. Take the quantization as -> the likely difference and measure your own before relying on either number. - -### The rule this gives you - -**MTP pays on dense models and roughly breaks even on sparse MoE.** The mechanism -is the one that makes this chip interesting: speculative decoding spends compute -(a batched verification pass) to save memory bandwidth (sequential decode steps). -On the dense 27B every token reads all 27B of weights, so that trade is strongly -favourable — 1.6×. On the 35B-A3B only ~3B parameters move per token, decode is -already cheap, and the draft-and-verify overhead eats the gain. - -Two more things the numbers say: - -- **The best `n_draft` is model-shaped, so measure it.** On the dense model 3 is - best and 2 is within noise; on the MoE anything above 1 loses. There is no - single default that transfers, which is also the README's conclusion for - Metal. -- **Acceptance decays fast with draft depth** — 87% → 76% → 68% → 57% on the - dense model — so past the sweet spot you pay twice: wasted draft compute and a - longer verification batch. +256-token greedy chat completions (thinking off), four prompts run twice, +median decode rate. Upstream is `llama-server` with `--spec-type`; the binding +is `LlamaCppEx.MTP` (`bench/spark_spec.exs`): -```elixir -{:ok, model} = LlamaCppEx.Model.load(mtp_path, n_gpu_layers: 99, load_mtp: true) -{:ok, session} = LlamaCppEx.MTP.init(model, n_draft: 3, n_ctx: 4096) -{:ok, text} = LlamaCppEx.MTP.generate(session, prompt, max_tokens: 256) -``` +| Qwen3.8-27B NVFP4 | upstream | llama_cpp_ex | acceptance | +|---|---|---|---| +| plain | 14.17 | 14.28 | — | +| MTP `n_draft: 1` | 21.22 | — | 83% | +| MTP `n_draft: 2` | 27.27 | 26.76 | 76% | +| MTP `n_draft: 3` | 29.16 | 28.63 | 65% | +| MTP `n_draft: 4` | 29.71 | — | 56% | +| DSpark `n_draft: 7` | 25.74 | — | 22% | +| **DFlash 2 `n_draft: 7`** | **46.60** | **44.22** | 42% | + +DFlash 2 (`z-lab/Qwen3.8-27B-DFlash2-GGUF`, a 1.1 GB drafter) is **3.1×** +plain, against 2.0× for the checkpoint's own MTP head. Its `n_draft` is capped +at the drafter's block size minus one; asking for 10 measured the same as 7. +DSpark (`magnitudedev/Qwen3.8-27B-DSpark-GGUF`) lost to MTP here. + +| Qwen3.6-35B-A3B UD-Q4_K_M (MoE) | llama_cpp_ex | vs plain | acceptance | +|---|---|---|---| +| plain | 68.27 | — | — | +| MTP `n_draft: 1` | 86.86 | 1.27× | 86% | +| MTP `n_draft: 2` | **96.69** | **1.42×** | 77% | +| MTP `n_draft: 3` | 91.58 | 1.34× | 66% | -Reproduce: +Speculation spends compute (a wider verify) to save bandwidth (fewer +sequential decodes), and this chip has compute to spare: it pays on the dense +model and still pays on the MoE, where only ~3B parameters move per token, but +the MoE's optimum is narrower. + +> #### Earlier numbers on this page were held down by the binding {: .info} +> +> Before this run the MoE measured *neutral* (0.95–1.03×) and the dense 27B +> 1.6×. Both models are hybrid (GDN layers beside attention), and the binding +> rolled a rejected draft back by saving the whole recurrent state every +> iteration, then restoring it and re-decoding the accepted prefix on every +> partial accept. Upstream's server instead gives the target context one +> recurrent snapshot per draft position (`n_rs_seq`) and rolls back natively; +> `LlamaCppEx.MTP.init/2` now does the same. Qwen3.8-27B NVFP4 at +> `n_draft: 2` went from 21.1 to 26.8 tok/s. + +Greedy speculative output is not byte-identical to plain greedy decode over 256 +tokens, and that holds for upstream too: `llama-server` with DFlash 2 or MTP +diverges from its own plain run on two of the four prompts, where the verify +batch's wider matmul rounds a near-tie the other way. ```bash scripts/spark/remote.sh --env MIX_ENV=bench --big-cores spark-1 \ - mix run bench/spark_mtp.exs + mix run bench/spark_spec.exs plain mtp:2 dflash:7: ``` > #### Qwen3.6 instruct checkpoints need the chat template {: .warning} @@ -382,13 +411,13 @@ than the marketing: - **Capacity: yes.** A model that does not fit in 130 GB runs. Nothing else on this pair will run it at all. -- **Speed: no, but also not the loss you would expect.** Pipeline parallelism is - *disabled* whenever an RPC device participates — the RPC backend reports - `async = false, events = false` and llama.cpp checks that before enabling - pipelining — so the two nodes execute **sequentially**. For a model that fits - on one node, the second node measured within a few percent either way - (see B1 below), because the sequential penalty and the halved per-node - bandwidth pressure roughly cancel. +- **Speed: prefill yes, decode no.** Since llama.cpp #18626 the RPC backend + implements async compute and events, so llama.cpp enables **pipeline + parallelism** across an RPC split (it used to refuse, and the nodes ran + sequentially). A prompt's micro-batches now overlap across the two nodes: + prefill measured **+16–26%** for gpt-oss-120b and +22% for Qwen3.8-27B NVFP4 + against one node. A single decode stream has nothing to overlap and stays + within noise of one node (see B1 below). - **Tensor parallelism ("tp=2"): technically yes, practically no.** It runs and it is correct, and it is 2.7× slower on decode. See the verdict section. @@ -485,6 +514,14 @@ wrong devices" into `{:error, :unreachable}`. After the load, treat the VM as th unit of restart. Real fault isolation means putting the RPC client in a separate OS process, which is a different architecture. +Upstream's registration aborts too since #18626 — an unreachable endpoint, a +listener that is not an RPC worker, a version mismatch and a malformed +`host:port` all reach `GGML_ABORT` in `rpc_dispatcher::start`. So the NIF +connects and exchanges the protocol HELLO itself before registering, with a +5-second timeout. That is what keeps `ping/1` a check rather than a crash on +this llama.cpp; the matching upstream fix is branch `rpc-add-server-no-abort` +on `nyo16/llama.cpp`. + ### 2. `devices/0` order is NOT `tensor_split` order Two device lists exist and they disagree: @@ -575,43 +612,51 @@ for it, keep the worker's tensor cache on, and do not restart casually. ### The control: a model that does fit gpt-oss-120b MXFP4 (63.4 GB — fits one node, so this isolates RPC cost from -memory benefit), 1024-token prompt, 64 decode steps. +memory benefit), 1024-token prompt, 128 decode steps, median of 7, RDMA, one +session at `785322d17`: | run | load s | TTFT ms | prefill t/s | decode t/s | |---|---|---|---|---| -| single-node | 64.8 | 563.6 | 1889.0 | 46.50 | -| two-node 50/50, RDMA | 151.3 | 590.4 | 1797.6 | **48.14** | - -Decode came out **+3.5% on two nodes** for a model that fits on one. That is not -what "the nodes run sequentially" predicts, and it is worth understanding before -reading too much into it: splitting halves each node's per-token weight traffic, -and on a bandwidth-bound part that relief roughly cancels the sequential -penalty. Repeat runs put both configurations in the 45–49 t/s band, so the -honest summary is **"no material difference"**, not "two nodes are faster". - -Load time is the real cost: **2.3× worse cold**, because ~30 GB of weights cross -the network. The worker's content-addressed tensor cache (`-c`, on by default in -`rpc-worker.sh`) took a warm load from 151 s to 139 s — much less than hoped, -because the client still reads and hashes every tensor locally to check the -cache; only the transfer is skipped. - -### RDMA versus TCP - -There is no runtime switch. Transport selection is silent auto-negotiation with -no env var and no endpoint scheme; the only levers are `GGML_RDMA_DEV` pointing -at a device that does not exist, or a `LLAMA_RPC_RDMA=0` build. - -| transport | TTFT ms | prefill t/s | decode t/s | -|---|---|---|---| -| RDMA | 595.7 | 1784.0 | 46.05 | -| TCP (forced) | 805.8 | 1310.5 | 40.90 | -| | **+35%** | **−27%** | **−11%** | - -So RDMA is worth real tokens, and if RDMA ever wedges (upstream issue #24813, -closed as stale one week before our pinned commit), TCP is a working fallback -that costs about a tenth of decode. - -To confirm which one you got, there is exactly one signal — the worker's log with +| single-node | 50.9 | 515.2 | 2075.9 | 45.62 | +| two-node 50/50 | 154.2 | 447.9 | 2418.0 | 40.94 | +| two-node 50/50, fresh worker | 80.6 | 411.8 | 2625.7 | 45.81 | + +**Prefill is now 16–26% faster on two nodes** and TTFT 13–20% lower: with the +RPC backend async (#18626), llama.cpp pipelines the prompt's micro-batches +across the nodes, where it used to run them one node after the other. Decode +is a single stream with nothing to overlap; across four RDMA runs it landed +between 36.5 and 45.8 tok/s against 45.6 on one node, so call it **no gain, +and noisier**. Qwen3.8-27B NVFP4 says the same: prefill 1410 → 1725 tok/s, +decode 14.02 → 13.77. + +Load time is still the cost — 1.6–3× one node — because ~30 GB of weights +cross the network and the client still reads and hashes every tensor to check +the worker's cache. + +### RDMA versus TCP, and the 10 GbE LAN + +`GGML_RPC_NO_RDMA=1` on either peer keeps the connection on TCP +(`rpc-worker.sh start spark-2 --tcp`); `--link lan` binds the worker to the +10 GbE management NIC instead of the fabric. Same 120b model; load is from a +run with the worker's tensor cache off (every byte crosses the link), the rest +from a 7-sample run per transport on a freshly restarted worker: + +| transport | load s | TTFT ms | prefill t/s | decode t/s (runs) | +|---|---|---|---|---| +| RDMA, 200 GbE fabric | 54.5 | 411.8 | 2625.7 | 45.8 (36.5–45.8 over 4 runs) | +| TCP, 200 GbE fabric | 59.5 | 426.6 | 2545.6 | 41.1 (41.1–42.8 over 3) | +| TCP, 10 GbE LAN | 75.8 | 426.3 | 2546.8 | 41.2 (40.0–41.2 over 3) | + +**What you lose without RDMA is now small:** ~3% of prefill, decode within +RDMA's own run-to-run spread, and ~10% of load time on the same link. The 10 +GbE LAN costs the same steady-state and **~40% more load time**, because a +load is the one phase that moves gigabytes. The −27% prefill / −11% decode TCP +penalty measured at b10362 is gone: per-token traffic across a layer split is +one activation row, and the async dispatcher now hides the round trip. +Keep RDMA for loads and as the default, but TCP — even over the LAN — is a +working fallback rather than a cliff. + +To confirm which one you got, look at the worker's log with `GGML_RPC_DEBUG=1`: ```bash @@ -621,8 +666,8 @@ scripts/spark/rpc-worker.sh logs spark-2 200 | grep -E 'RDMA|transport' # RDMA activated: qpn=33437->33437 mtu=4096 rx_depth=24 ``` -`RDMA activate failed, staying on TCP` is the line that means you are measuring -the slow path. +`RDMA activate failed, staying on TCP`, or no `RDMA activated` line at all, is +TCP. ### Concurrency across two nodes diff --git a/gguf_ex/_build/dev/lib/gguf_ex/.mix/compile.app_cache b/gguf_ex/_build/dev/lib/gguf_ex/.mix/compile.app_cache new file mode 100644 index 0000000000000000000000000000000000000000..6ea8115617c7526ab61a9974d506dd470d0bff9a GIT binary patch literal 4343 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 WEO1CCS>!r5WH5n!044yWixT+lb#lG{ literal 0 HcmV?d00001 diff --git a/gguf_ex/_build/dev/lib/gguf_ex/.mix/compile.elixir_scm b/gguf_ex/_build/dev/lib/gguf_ex/.mix/compile.elixir_scm new file mode 100644 index 0000000000000000000000000000000000000000..cb3dbfdfa7c6e6c11b1d3c70a29ff530ef142eb1 GIT binary patch literal 49 zcmZq9U`b@kV9I4+U|=)UGcwRK%4T3PvMd*N&B?6DEYkDMtk4T~_SFkWEXgQm&dbaJ E024+w%Qm5 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 literal 0 HcmV?d00001 diff --git a/gguf_ex/_build/dev/lib/gguf_ex/consolidated/Elixir.Enumerable.beam b/gguf_ex/_build/dev/lib/gguf_ex/consolidated/Elixir.Enumerable.beam new file mode 100644 index 0000000000000000000000000000000000000000..b4eef6e587a9fc699968338767de42224ceace31 GIT binary patch literal 15792 zcmeHuc|4Tu_wX#1nPHfaJ=rDMvu`7W$W~g&GR9cP3}eQKM4~97NXZoSgi;|&ma=7Q zv1MOMDkOw@LZ!U-ZKBEYLLl(?g@uJW#2OQ#cd$1_!GuKfBT#T|L_&m%i#N%G?BbGvqf#l}ZZs+( z&>v6s^YQ@(BJPTE9;Z z_6UCK`RkNG9|Qt1BD)hH5ZDW#hyfD#yA32AAaOu3sSp^KI0h=J13%4&;8Ka+5^YBV zo)`N_+NtPECIxCxC2TdE8;Zqp0sl5wQwWf`VofnX=8uH|{}EU?H_&M%3V|lFV9@H& zj8qJa>m3G~&yK-h;Y>^zG&czHP6EpW55Qocm8qgIE)+%-+QKd>isfd)!g-cp003?* z3ZshUfd`0+LZ7E90dQ-Spi}HhN>~XdEH@7pF1ZNGB!PtkU;y+QBdjDmKuHOTz@%aU za4rlKvF5K6qqtUPMsR_vMR5Z#+)FU2HUK_8o!xK@dMzIo#e?RlM)N=sJQ#n-WjLQG zYAurq+*A~9VyXm($6z3=7z_dfEEKVp3&RaX@Ghbg0MPL<&|>flXtCXJQDBrHw-Q>6 zTW2>n1}zCN6(xigMG2$Vqt>BCP$KAcsP$-JlqgyVC59G6iK7Kj5@>!Xf**^L1lWlX zz@ntUTo8+r26G`SN(Rh@v8WATz7C6$1#=NBY9pAh$D-uGTojAi1m1WFmbk%E>*sh~GpLd!rAGK;&8 z*nl+!b`Xk?#hTiH`9>^C70l&;{nmscHZ7vr44{z*&?o_XR6{GG)X@r1guy2n0Cmc7g(K?&lBYn}NgxBs7pXfCK{)FOc|v1O*b<&i_Lhgn^m_ zFOH1?%4|T=SndaLfo1Tg0wk~w;s75prRB0TkP9rA!8y2>%V5s6TwVj@U;?OxZ~_T@ zCPBJDTEIGp6Py=p1IsW=Zz`}Bm=sV3f2=?v943M#FBqNu$D;@b1zMOF)!t$ev7(?B zYsi(F*kYA+Sux^Zz#x_-?TCYe2o_Z&4(bC;!F$*b_{TgDQOy?Hp3L#`5G&;ii`^lh zO=yt>a6&eBLLi>vy?CU7&=7E-=wYA-v2sk&e>DdHm;n%m{m0`ITowB_;O}QQeH9f- z=UhIwS59U6$^rkA*7ydvqEzV|%OjVy68#sgN@rV!02KrswOj$T0v-Lm4CpgD`*L+r zUw-Rc(zqZS)EBwL1akHJw)~Gc|HH`T{Q!{sxJ`e-vVt9)(~^t_4F2v~8x5Ef-61tkR)ux&{t2Z9Kh z=>jCOOQ1iFPI6f`P${6o#}fhr=|~R>*$-%@5WpoZ7Jxp2KMrW%02**KfCAu218i6T zEz6Q3|3+ruqR|TWFPfjgLk2F1B@i$Y@C09ox}q1^kDy4Qkw^rJBAra}RU|Ch(JL9z z+wCt!z`9l-1p7dY-8{V^5Jcf&8{lC28qAn*a3uHFt?g7OIkij9KB!kSsDB@$$ncOf zCFxnjWm1IrHn&@bq=uyRF?-)$PuWa2OEik-(fP{!m3jL3LiGFGdH7IX_k?5UkynYT zj6sDnJv>&piak1KCK>O~KVpb!6?Q*kN@$a)muPFzI(U5Id8N*@8*6>lW4HS+x~3he zcsxE~LUbFR%&=oHDY-U&B5KyDQpcmcAJ1?WcCe<`iJ_k=Mf6O>9*u0v^JfpAOiH|X zR8LQeq(ASiO2;3r`8zn+RJ;vOX*>+9$=s)g(LM}q*Zx0=bdcmDjQZwQ^ zk$Ue<%7u(Ih>qCtNDUrb;#{;{n7aS{Y|g5!`k6z36Ag|m7wm($JRF0Kz1cq+&T#f##OoeU2_5_D=45^QT` zawPsn|b!JVWqC)_Ij&n_19P>p7moI^m5)&r}6i-lk4gq1U?LKB}~>ta3WJ6 z*)JC=4P4HM*Gx^YN-JZ6Y?uzMEgF*IxHQ+H{_~KAx7n><*K{kQ7S5Rm+sYWWcbu?HZmgvY&bv1s z&+NaE-0{TDm@`4?mcab24Nd7oz1_ZsH_xJv@^IDPP-62tJ9v(u)~?!Tg6wQLlXK6= zT4KCdb^O_|g%)CL;9lBMj!M#_53LS+yVef`t&#a+zJdC-;-iM%a9qv@i!a^mNkwT7 zH`~UI-j2b%&MyesM}FBNUqOU?J%o>h%Vzg&us>a*RCo6?iM(Ayt23TXx-NP-gP3pi zFmBDIf(>uQ7e;n@sI|=Mq-j+K2-o?cCvI#U9&+duIbi^yXRX04f`h7v3Neog#6OUHxZPaF16+R@nU-KS?duEi`E za3!6rG-?0rqZ#WrMZ4w0m)|zzab@63hQVCsGse#MPM7&}lSGH5j5v47zZTCP+=?p5 z9WC%VUfOVNfZ7;;{_KSK#UL6BboXPJYXMt%&{|gHZW?lknmxk*aGeO#KJ{l1ZHEk9 zF31!gb*d@AF}%|C$z4^&^JziTHV<0z7eeLHp{6{VDj8oJ<4w0R-z~QK+S-3zh{HPR z6k&($Q(p&?-K{Q%x1GIr#wyu3KRHnyRSWyu-yO;n%P4oUz|ywdbU6EE!mcon-+`;r zWV*FakVKX*4sY@QY`}g;3~G5Q~>q z^qBiktL*|NUu0gR)n71zU&T};PJdtyCrAi-x6je>x(|E_AQX$mZD>xgs?VBQxTY+M$ux zifsE1?y`RLqULH6wG;cKr{I=uTid&F*6DyFxe8{tX6`cNUkxcs21h;h%zSfI-u`s> z!Cpd6!OOj|Dy1Q!wvrW(cAG`o3mPizvNlq7#z!Q$4{*z$k`JTac5an^5xs@WueR@Q z$d{Bi?S;KJv~JAMJf6MJdr`cNP0U8{NgBCAqWI70Oyi@Ca#sYg8%-UG&1|FH5-xly zAF$8t%}#yCq1UzhutKglTFd4}8FtH?2A@sn(@&3dut>9RLwGB1u9mUoZ`;IIV}Hf8 z^@s>@uTAys(}IQj96q-oHl`;F&fn*9c9zbpHZqglL3uwN{oo6x6rxoUFG(14Uenn= z@v)AW&@SjTb6`i0gnUws9yVQIV({gg)Eh3smjl<34b`w%~dOvB{)A0mA)ZgnvknjWI~VI%5zQa!({RsJ~>I|id}-fzTVKA zGGZswhRRyrcO;Bw-AhyDF(b$%eT}@>S9)|t(BTvARCTL~G^#-_Ly7h3j$qDvIU$yu ztVDOa&DR7^7hks9bdsmaUr~t}x_)<`jT%}hU*5DIJ`v_WcWL45)C`p7D`pG{q0TCg_pUo; zz7~CWc0>Ge^2DUNeRA4%Pn@;m6-G2_QlsjYh9Y`WGZuP~@TASOcYsQAh2soO)<$Bcz{Y36SeejqM((l4sz z;kn$=+|=BsZ*$Fe&(4q{rSu^$;G&5b4Gv+=L&ahkF3+#RA9>A$_vbm=(`mEgFE(&( zc{uEvPd*lrZ`>T5h*E_{=#{+o>AH__I<62+l@CbiBdF^sj)CK0M z*&Vj|f%d9<89CflnvR_&`^@btxp!q&H)hLT+M8O|$wVVrS>(#3BPZ6T5o1$;KG_V>e7nb`nTTX?z8Hl$ovfUvtU7LP+tl z5$1I`T&sfo6xrj}&B;+;GKUJklNIZrCZ2T+%Q*Iqfh;re)o8|eecrRSwCTLDM$t)o zR32QUp62X%w?MG+f$pY_w!B^)`Kq@II+ z-7wx#6YRr2kFun&_wONhvT^F&md78oBkGtVCv&zXHfKavhCM1Pb7A#pxMe=rZOjX&bv(dm6_e;ZyYUhK0H)Z#^ouDsd3CbO-#?00pA$fNvdQUVh-7#j5S_8_iD+IaM^b}a5R^58KC zE!E+>nx5xnd>K2BCHNwX(9-$d^r`fQ56{ZCXU%#5ex5}Ax|B$=G_Brq=EsCVmX&Sq8oOA43p7+&{#-2y4WtBU`mFOZT8`oG_ z?m7Xf<4f#BRavmeA(YyE^KQ~>PZ>#4w=|6T8zxCaKEL^p`9xRNmZ5ouny_z7>6MJL z4;U29Eb$fu2Zl#%=!W9O;U>CRn@r;QUHR%ESKn;A5I;C;m~!plp}@mU1@NKi7;Nf} z)C^7hW`*6}G(H~RU}R~WhQ-B`hjX)Z*H&A+((Jb=6|>TGoy2~%`-m^hR=9?Lrg1^_ z;!`W5U^>Kn@A;@r+_gE|Cel)`8|P*>-;M2T9*;;o|L!`k9t27Jt&6OZ%c=;9?@ zeVEudvi`u_+u3K~O6i|fiO2xoEmoP^Op;iSDviZw4c*i7TW9D`y@%u#kLEvG+$L}- zbNDnXi)EvJK`y1gKa03|#N?uvO=%;2?ooZC#SD6D<%3R*8M~?b_X-qHS0v&$TF)TP zmQ<*ey#7+-Am3#3Vt3p5KSSPMV!J&&bKvbhn*K=FoYin*|L%DWZjO2#Jre1%iaAr& zz4B5S$F3lj0{Y{g!z}}Mwp3WYZILP(orY*ThfbcnvJF{#_82UVNux4OeBTX!{Q>i; zhad9YwC!mr#oB@=&zxPGZn$sL_Q!5lQcd~H>SNwXz4UxXsQYbG`Q#=qgS07aRwBI2XHg?MF9A9NPvu=p;j+^GNdF%T6!-WUdygbNp^V$28 ziY3|HmJR702BeZ6mq}z;X4w2drv5@o&{oG%Z&mhz;cyb)!Z`~a{bRSvm1jCC?j{|Z zGya1dKot_?v;Fdf#UfnY(`f^N1BB|5)TbKNLPy%8*?k`9CKfzcfK+`zv61^s|_1@ zdM}0wV@m9#7%Z>Mujk%=s@wjQBQ0EE;8S129a2lsN7~m%O}Evjl8W}QJNbT|OnB_2 z_fF)IN-v((A}j;qwC8chDRaED>Fq}%#i{~3lS`zr@neq>8;W9{is(-XJ`NN;vu^_S zDe^J|u}w*op?6yz6U(e@oY7HfGP)&ViltP*^^cU`9Im37JqS0Bjk!9BZnMWMFEzU& zP8PW%PMIZ2h<-SWGQ7uXJPm!a&IfO4`cVuLReQ~7Lq|zKJ8nzDi{AI=Uj|;jAlr;E zg3L1L8zP-WYwC92?;)uu$JR8?X7}yhwWZ8)b-o|Vl z5dsfx+^V9zCTQ~sl>|?2hG*S&dGSvNa5H7LXD9fhSUX;>Uso;KLPu5y52hz@$ZicN=2Klr#!Z-3uR2|eelQ1blJUcFCaqgq@iKBlaZDla@H@q(~JC5sih;J*; zjA5=RSyPR})>>TgAUSO-ThqKo-$c)h1?eiAqbaqmAwB|;CzszHPqdTemT30nE?|}Y zkV=GIjaFb8oU=L!=arK%5v=pr+jF%>D9uX3`sH@!$=v2Q(;=!`6?5}R0<-2JXE?1! z&{C)LJYzSjD99!?I1W*e-q&JA4`va@piWvBTO}T)>^qlvYs~XN>1i`d4^@_tAuU7B zbu6!+x_PU3M@!W1WoEL)`b7v|jqnoEZM=5K(!MfgCJU)6ijvG)3!hrYbo0|yv{ghq z|EUJ;%@79T+6$S)qUm?1cA3mHX+Mutxn|x?qADN{+bAR_o`ywg#*w>E`eynuT==Uub=X#*7fg(aUuw7JNp5ufQhwkE?KO=61Ov)q$AT-9#ErQ1f6 z*Zrx_y(_8S12%uws?Vp`JR@{it=5K|JgPwg!fYxv{9@o>*5(Shok!HcqKdQ-){FL_FTae#Yi=jq zHG#$VP4%EvWw7)ocLG#H-P2lbpK(1kTR_Y&QGF~a=#!IrGa%dF2wqf@RpW@oFijXHCkD)QW{=0LD)ak(fDFxWLlaGktCxuSOy=Ld1 zd`#v~M^N1}uL`lN-?F%lqm%D^m}I-G1}XFMhrBQK%9kPI?=}}Q`u4;3o&A);Y=T~M zi_oT$8pE}JQ5)KtzmVi$u%{h|*5@dBY1VN3*&d`L1y_AYWY)_OcDpoWOiA5FE@g5H3)|Y=mL^gHHDr z&%WzV8WiglVjkaVtkBELcR!KHTjk23e)&k}gva>j_K=t_4-?nAvoT;C4{`-cE?)1Y zwA!oNOy=h?^c*XtvTxlqbn(whjP_BiXVxDQwLH^eqVOdARR%3KQAj!5N04Q`13PX6 zS4a={YGA0sWv{SfoC0s$h$kj!azWO{Z7~ih{UCVV)RT5qW4?G2t+@Y{AY)KQ!gH?i zVwoU+<=#hC6Y_RqwntAyvYsh~8yVg&`rKK)+3ir6O2X%1E4x2u!aNi!dr$0T?}+GC z(Qpz?lVf`GS}3-+zC1YCo%~9!Of&T9_HMOvH_6Xr9v-e?LuO5A$M>hcnztOLHNCFG zwH?%nA6GwmCeiOG4ccs6p4$}rp)ExE3kgFCWYPY`Vy zOXwGy9W_h1(k(r2k@BTBrpa&me5>2w#dvh-yYX3EVbubAfZ_VC>2QcgvFs6(U?X1$ zL~t1N9<5pWJnn+`BH(=q6qg`PD)0dx_?*8SMFM_!M|goAE{<F_{r zPdXEcOd>2o{l&TPH!v%{mhT9>;J_z*Duqn)q{D%Dl;yAeix~*SL}wxbek3or8>~UC zna)HdQ2dtv;eI%OFJ?E@4#h1%H)OAvJ)Mc{Pgrul092#CN0uy2$AqJj{eTW;8VT@V zfNjWC{AE6?Im~?i&Ozq$&4aVzA@lj!MdtIXkId(ryK5;X#OJThu^M%=RNF zVkPzh2c@&Pc~gN6z%4A(=0>Le4XPDLCZDBkV0GV5!ufgQm$nh`;efM$_v$PGfwJ{o zG#15S86GU7y>B_ZJZ3Sm|y9F;>ptg zfUZ^Cwm!cj?Dz3KKT)>Yp8saitArk{c#eNUytEat{LwxCV99^ug#PWa|8wNi>J(ZY zbNUAquK3NrJ?y{RkyW_%ZQN>t0>5~(8T@cfpyfQUjBi2>1uotZ-*VQ~zeGR^iU_s2@%Pz~EUn zQ-0FOOXd!V38MCS)9C*v1`lXdELuK50WkG8y@`|hUu^)b(E80>TiuRYIj%ncMp!^& z7z}U$jH4fe&;Hgr0z3XSmVxkapZ^kL88jr>e>fPvDW`w!+@EeoDEtt|{?pO^ubum^ zox5~}MqxQ%^(O&YdSCh1&Ru+M1$50%A5H!*e@gg`KK$3tT~hrk*5UV$SWx=^Gj{Hh zJ@Y;KdNph2=g)w!e=VEk%Vz&2md)~ayrsQg?PK7#Nd5nbc)V%ea?|F2 zA|s3biho~@{)=9YRy{m?=uE&(P{Q}CQ^0*5;3g>W9wi5)l^=Ldj2TE!E@Ta|9a)T= jvxTrN-VIs05CYk`-ya+U-e&{vzroip0C#<`5Xk=lwpzv> literal 0 HcmV?d00001 diff --git a/gguf_ex/_build/dev/lib/gguf_ex/consolidated/Elixir.IEx.Info.beam b/gguf_ex/_build/dev/lib/gguf_ex/consolidated/Elixir.IEx.Info.beam new file mode 100644 index 0000000000000000000000000000000000000000..f34f29fbe2fd59ec1280606268a406193e39c19f GIT binary patch literal 9928 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≫J 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 literal 0 HcmV?d00001 diff --git a/gguf_ex/_build/dev/lib/gguf_ex/consolidated/Elixir.List.Chars.beam b/gguf_ex/_build/dev/lib/gguf_ex/consolidated/Elixir.List.Chars.beam new file mode 100644 index 0000000000000000000000000000000000000000..dd3d5345efbd5355509936214ec893540176b783 GIT binary patch literal 5348 zcmeGgX;>52c7_QsKvKiL$&SckSVRiAlmKE%i-N3D%L^eHLLkY6ECjSw6sdIuR6s0? zU{t_r5m8&w0u|R5L9Iyfp(ui)7H}!JRoNca0Kqutc5^;{=JtxHuO}XJaBlfiR5dXO45($z+a+XEITv zw|464FU1A#q7%kI&EK9Mz>`J*lL)z}>Dz9 zLjUS+!2MsluM13uu7%`g|c~c}9gP=g1g8?7Wgdm6tfOrlAa0Q?PQ;Q%qJzFYl zJqO7*M)hW92V{rK5-@SpYT1_TilACA*q#0hq7T#Qdf**KXF#Bdr!%Oa5z*DaJCly+ zgTY1C5S*()r8vPmi>PXPkEn1BnM$Q2Bog%sG2@XPorI)Psc<79Q5zs_W8+2EBq~LB zP7Ff*%b2dM+xtr|+)Wih3dGo2TaOfkFszXvhC70MONBJ4RFn$j4CztzVN|KQwh0qdiqMOQ9XBxK0?=Q<( z(iveyYeCnxCR$5i6c-q^QnIlDY=EgLc3`Wv6kBaOiVcj~DD8;asutRT1vD77S1z!J zV00Q`UaC8cI*gG3kLjozxot1qD(07?fafZIj5p*YikS0KTWx~El znnXzG3=64{!HQ?uTL#Z*n>ScgHoOchNCunJng}?`S@J0=WyhmCF$d-FSp1A-AY%}W z0AY#{m$Sq|=6I?h=m=q{|Kc!{3C?dUnBWewjWW(MfjL;h47s{8{Uj5%3Jew|g65`j ze}qWQG)yc3$tDHT@Njo^cb!Sl#-g)?V5lxP72-^Zh$R;?Rf$tf#C|p=k;t_Y#kc^F z#Tcbkk=T-k1mp`gmIBRnOTq=1 zn^-0kVq!NrE>3a7l=*$U;qwwEqeRMeBXY0A6-y`fIzNHS10P9WRv7SQwe;ey*e=}8 ziyAt-tA!Ex!zByU#^zz8-Tuvt=2eh|-fB(z=0m-FhqyuC;q&+RNBF!-Ggw@y654n;TAsp_+^3n!ELt(b{9e1ls%}U<%`5GS9G2DJ*z1`(IGPB zRNqhEZ0yOjTAny}?e^;)MJ|$Oo%?@&6%|agJC~YP7r*VsD6GAbsm-g@;}mW9)YHkC zV!TGNn`9$R+TG#Y%W=woVHU$IyU41ozwUf+gKOco$G)4cQ)ya;BM!~0$Xl9=_usa? z6Mx_{X+up2bCep9Ulf1N=ligeSG^B@*|h0=HY8&!mPsNW9Dkm3DC6;ThJ|Yx;jVk`HeaI9(=!60yBbUH8bzz8JM*n>)qabfO4yQNggZ6;Zo?%v(4-wL;M{*`nauSm3%+2~KK+L67mP%!h2@k_NZerDS@yI0PUJXqeGK!?}P3I#`Y271_`ZIE9w>(DtMj!vM z{_pSu!>8Be+6uLr@=wavt{~qc$N7w!k4_V~Z|_0lfP49NRcVZJc* zg`+%np#0Xzw&yQWub;Wpuu$==Ms_#uu3wY}Un66L+));qw@QZ-e?i(OzPOI}RIxCy zWVqDUSpW8F!;F#UkgxukSP?Q5nzvT>QBB>^i|b;aR<^9Jf3i#*Rw&C^dgMxEYR1R+ zo1YIqIU16K!#Z=9uPiid>PcF?HR<8PObnsjJJ53E?#`uME0!)FIBH#CT36?%y}V*D zqA@|I!aJ=hD&hE1e8W!v!@K&v?zh_XSJ&W)_4>Gt%Wv0>Z`835=@$~pMF#Dco z?ct)EuZN;_4vEp5Uy(n9@Z!Ee`W4NWAaS*1mo~)>E^b{T-)47i6Zy7P>8j3tjXOj0N`uz>)*X?!JEjkAmCdd_d-B#9Zr<&A zMXB~n^y>#_9AAe#kuCemaL7_;?VsNSGWv&Z+3yYvrI{SRyDo}5BsB1QaF8eeqb+q~ zJ-xkO5W%u=tjqpc_RMPItC}z3f6WQDTC=y;yJ`pHh@|c_Q%&255<}nAT3&s{c~6J$ zcRQzF+l%J63?=N{(FIo>D~Q=2t%wp?Y9@X;!t0lKu0P+N^x*L76XZw*q|?-~tF^!5 z>95CUd~@VXtH)JWYVOXKKyxhgt|*rQ%jqFlgk$VHC<_@d~;8g$IR-l z`)bdA{M7n$o9Bb@6!XUK2Di{UeymnEJ(G4by2mx7qPvgV~lTkD-X3b!DJC!z}1rQ|et-!Ijw3f4buY4)+6@$zW7yQ%P1XPc~XPtBs; zmj>#h*GVe-cUtfV6g^RUuj!V&L<(=`>;mx)XG_3!L7Rwor2O>a{SouTr}L!y115njS^OOw<707`pCe5MZ=?* z>@?Pg7OwD?T(4*$!a<{{Jk zX7ux7ZX=G_(BUWA`$vddvUDrY?}(>>>N|*9bS| zv(jD-EcNc}ZT&jFAD@vS386c6X+HD_=|1x0>he%zbIip;!>e8gLiQQ#$iKShi@#FL z{t?bOQx@k|?o{6_Xe@c8)i89Z+&D| z1sj8`;MmgqhEFb`xe&F|j+&}TZM7w?{Iq!1cjS022$nHT< zP04#FVq%xO}{4&ZNueYaU4m$nsJ#F61ij0&?v5b(na_#jbFjz468DC>AVEyKl-E>W?(QKmqV86sj0 S@lS#H2Z30Pf;yBALH`18xd0bP+)=4hQB@hTiWmO1^SlPm+hyp?VN%&jE|)J#5p%h_ zFamTZWf8bc!V?Q6d;z{I8J9?L9!B8F6?l$BEG1-IVX}WgN|uO6@Wmooq7dUr#WEJ? zOcaWfvjljejF4vW2$qO1NW`TAOqAM}iWA(SLB&c1gqRDE00RYlp+vw<5lflTDVRWp zM`vS#EF2x9uAMX-)jkqRh=tlm zX7XhOI$GOWQ~AV@Tu`mMj}#GjDlSE>watwXh%w?kmn%^!1ebe@2b51N;3q@X42gys zAY+5G$J>+eG%TAh&XNx48V?f)k}zI|47Cs|bOsY})qNEjT8WPE;EM!M$vjjagqODm zYNgTpet9@zqaGQ)Bp3@5C*vd%g-arl=%Bz~B`E%&7?bJSNE8c4I@w_|vc(d$@X4Q= zKPM{*m&WB~ZO$*_9P=l$*fj`)%w}7F|7i9!5~vc{)99d*uqohwB^zOY!PyQZa)AMz z#vmgtYN5wLra2&-X)FX;Lnj&1=_nnn(`P|vkWmHe)KPRYYFH=$P7R?4>Q^!KsW+KfNz^)Ls{fuS@ z;BgSP^Pr6e@JA3H?MWL0;PDV1qYx-+uaJWqU?0ey=3=>$>P~Z((wwLsG{-U;lZ-MI zB1awB(}4WQs1tiyG_0N3R8LsD0Ac%((Xk3LUVw}%ATu5?%A$Ql^`?y@qvI6kgMOr( zI37&!BcpDL2|gq;>JE>M&LX28LtTJ|=ljD%y%fE^pqCXy^CF|(inbqU`vlRv$*8ZQ z?GM_1K{Q{41U{&_P`M(75?K3zq6Z2M6jM+rpfErg0SXxu*gsMOhB#zSj$&>yfKgC< zl;fUC7*r&8P`p5aG+aS(Q^F3Q9;JlMK@D|XwT_t*HU>511NKv9@(I8v`2c|7&j1w8 zDgpS{OQXn5G{0|*40=$NVOO+_R4wLEQ|(1CaylR}YLyWD(|{alPISv z8){pp9)`A5Zl)YonO(VwvO{6ta)}+&psAsT180w3!5@v;h00O{`>N7>MWg-P-5uFqv z8=UR@z`M9)^>fa`J%_$XhpVYgrvghYA(iKcIA}5-6XbphVhOkm=r9wB<(O2&RRtli z9|8UUjRK`Z%EKn8se?#F;W4;C5|}7guCEA9(xI5bB1I{n>Qw9xE@_xO6c%KV47^#M zEKeWUH{@qzkf6TYS_Fa}2__eDl_8ZBdNCd@lgW)zq+%iHmIBQHSP%eXxC8?orl14M z0vrIP2T>OwYcS-U)NCpv9o0txJ_5KU0~zpqJUoLG?3E@K;$G4$kqDQ1$;HwPFI*A( zsVV_KNfQL*KtSfjgAt)8o|8@rPfF#34dAPyNu)8{oRYSLwoRRWba5duaQc^0PF~PC z!tBY;Cr@+2tHPGrH5h$<>-%Rmr+*?k1vZwK51x^{>t@X^@e{VTH5KtN?ujphs;vj7 z?6kgL>K3)1b@lMl?e%}FUg~H_zccbta9;p{b59mWg&%4R+=4jj?Ju0kw&^sSNF=YI zFcan!XXd_~VjuMTSH9m|XL^x~OU;#6mh)>~MJ|ZE z{l@WS>V_Y`UEcg@c+2gVIr?P=f4@H6E^4}@+xT%|S44JS7&XQ@>ak#Zt;5aAtdI_q z&4-@dV|E;Tp5nK9Qqq(&Ce3!9xy8=sy<9r)ZLMvsTjBlpyDRohx`ywHzErV!)kp3D zdg15&HeYb>U{{DO!kmLPJG&Fpx0YOE6xC6fZJ%F~hNn;p7Pb@FjH@U2vvwQp`F(qg z*|b%5k4MkVEWY!==34Sqj&eQ}cajuT`+HF>QQp*Le0+lI9fO0r?dY>&_uLDO>z!^|d24Il z^+!nC>vik$ipmFUiw=x9aOoytD%}&Z)YjLrYeCfu%JtKf#aEX{#WMeSd!s$NXsUj+ z=~Y{#E$2l)C;x?U--vBn%qHIN+}f8BF{z$u9^fmM-AkAhdoORn2Jar%>cJS#s^UW> ziR}ZmtDh~iYhG;Kx3zZZ*cA`Cckj+Ak9o)|w3)Uu@f)X8a~5rXt7qx$vw(Nd{?U!+ zb{{X_v{roi^u~QFc1(Y>liAXBrstfL-g#mf!|p(z#D0<$(~vQK-MHn+j=_HBF`Tx6 zE0;*kyEusZPTiW+73_06Y;4N-j?vq`FlLzLrc@@EmV5R#eM_x!+}KptIDS)= zZTUd_%D8>wnM92Ar2m7M=!HLFkEX6`5C?fQ_+032s&u-OOO7o4Z2A6XB=b8`2+BM) zFKpx*VsW)+s{yv;Mg31>1V4v_ylRLl`N&O}9lWgR`J~x8vRCnbC$7zx~MDe|g#4H+PVtw1&XTF4v#9 z?3hw)*f99plwYS?ahe$2q#rl*PHucznjYNJa;7srGP7rAaQvsZ{XDY!U5pSjt{u4R zcC+*Gs-sSmXIMDhuAJW0W50GgW;n1qb~-X!wxrQN;!xs)v2U%)u6941aNGG)-a4sc z(dOWP#d5w;~?NnH{F?7Wj z9^YQPQtXl4Ez&Ffr++AKE3Ln2R^8#eh4TApr(X0#1fSz9SoXx$BQN8me6{22j+k|c zGe($HTSY#;)OW_n;^c>uvSlG(3NMykh^Y)xT|=`jRy8>X0DA&AR!M9Kq_{ z{S)Rbs=Z<9XYjR0`24Py-@o-hLZi~kh%G($>k%}29cR3`)roig%=T8vnIjHWrLF^w zzZ#w{ILodM`20rkg^W~=Mc*fkz^=UKdneZs{OUJn*ZW@>aeX}gHi6oD#Gs_^#1+O{ z`YRTrqUX)2M9YKo;)Q$S9)&DJj`c*N<1Izod-ocnzpvjX|9RiN8!fi`IuERFel5J; z)xV_Y@aeLrGnRjryQ8Ni>rG~y{8)JPmy>9#(p#SdE;;$x0<&<=KLRdZsXW|&b^pt& z$8o0_uUiJ9{Hyjla;iA-GqS@^ticQ?`I{Q;e;6@&)5gdJN2X=1HR5>}T(p^QSTWk| z+?ZDmSj~|gM^~+`yqI=54JmAU;k%Q+o`zK>F6>%z!eo~)bp9-Po!ozH(Cz0xJ@HB& zdAt_5if}Pc212Cy(BA4Za!S6PJ4<|rP0wm*aNf7q!qB;(pjaBY_gYNv0gLkX8hxXl zmp?opCMNX$tu1SU`NQhI*lm@ad)5}v*R1cZzr16juh=nS`P?MzPNT<$->l=M9auW)*O*x{f2U%!cy6fet+c=|=x;+03O577eMqrLgtI!;6g@xuW- zcCR(Q>n5_}_$D@O+b7xBQP2FXey_oISnS>O3tc6li`)`Odl$QA+EFWa=I%CjjbXez z8DX<{^)Ds9361OG7fwDl-8R)U_J05Nwv>tW#tG;=$CLHub1q-7s2}y#VJR1}`C?>1 zSt;dUc|_Rj%yU??tH>|jy71Hdx>3b%yO%_LGO_Rz3;WpJd8V@yT3zgli?&Cm@>piG z(rU*3;$(B_9=)XsYi_iA*8R$^e$yfMnG*=C^r80;H*#wqv>hGYRpfZ&J7-hl$9agRdsF2^JcLr+e`j9WcP{44(}0RA-U~- zGaRrtv4KXj_Z_V%+hVd|)cVf;GcK`jEC>1r+6ueUqNkm-IeV`6ORsU8D93u9Ru#=2 zH#oCDF3P7h(zLdJP1lNtQ`apuDm;Am;QhO;W_ICzWxUrrUVU6?X^~g+?aKRuA$E(N z_Lk@G^;%9&VU+Cz!FEnq28fYoz*yFNC>-GO(r{h|F6Cwi5I_q-_@d17D8iRC3cxf~ z2Wg5cHAaSrWH}<^r^@w2ViB&u8Wv3b364fU|DHw~0-_c|Di)P3 z6kS8OdcZ;o0XwJ&PsL#N2X>RvhY#v!iIgK`xz>CMjMG7&q(RppiBAYI35Mt(r8}cB zoE`#*r6Ea%`~bOJPb|TQ0${*6^?iEk&zV-;C*U0+JzWP&T6d?IHEefEZb?+W;(v2U6_x)gmi2Tj zqxDSS^-XgP@Z}6?2*Q(aKj2KX-UM|X%)d_$YUNL_N&oN%@TbyXcqi4#mR4ygW@*!4 z{iK;+egHQbmtvjF{8`pjt7P;&TB1IH7u5w{c`4V)k5-LUP1GhIN**ob19;Mv7|>;Y z{?lByru_8On!npBK_{<*j0Jap0qdiTMuAVl8q^T1+Gb4XYqon`2 zc~E`RdlK@8c9t$jK!W1`_$#?SktGq}z``IJsHiG8jgjRlLo@haQBcil*I}Lz@FoMZ z1b`{cWZIB3g6{ket{4vJX+H_lzm)`KBtKH;8I#qN-#hL9_XAE>i{D-mf|v~Z)U+z) zUm*xcL#tmCJr!T(Fsc0&g1~TDt3g+$dNqyYUm=L%axoMl{S|_MWWJ_$sDsD9LJ;|X z9D*oap2o|DHkT)d?on|s)UaOv!|rcLMuy3`B238VDX--q0s?R5`1|)V(oFDV4&nq4 uco|pzOhB!8^RqCr$s{r0OT!_i9WbK?i`<(gga?YGRbLPzT z@wdR?rXF!}b@Xx+FPMqL;kS*9jFh7quCd%iuF%XaQWD{sXy%$I;0VQDY(YAc$>l}x znamQlSS;j*O2izIAdDX;;Kp)F!Z`vVCyXuTgjaGB1$?1c#Ec8K-V!0wIX#XeW{0!I?0$~aY$jka1#FQBCGq&c2su0vQ^<+qi#fg=p^z`6@nZyH5b}kh z%27C1o+OSH!HpGjgsAGTDty^O5l83?I3ms#sXfd%wxCYP373R%moEs-%V1M78@#Kocj99iv%;JS6 zK^M`%d3rcEo@Dw18dFK94r+!5>On+%( zKHU_?i7DNbCF>Wc|0Os->Py(6A|^i~Lc|f1rjVwxWGq8!oci}`q}^a{F$#%NOn>y+ zD9&`#k_4_e3cL;HB(h{Z$q3`~#Ed9*toR=;urOsw1Te%P0{;VyZrU%C{m=*_9pW+v zocLKWmlw;0c!HDvQek0=szO*~t-jxB0E%I~FA3!c7p#`#X6q8f#uGL}v{qCt~aW#El= zUz1glRT-*yhfbu9K_F8KXi7AaEm0G12Sjti<0wvelA%3?sHwpqs1a2O>JN}ch9Mql zmnRXa47}11e+V+dG-=2)!tOmep`~s^X zg(VZzi6jIiVZf*gX$BpO6^%qH$5AwJ1q>w`%}JF+QJ@jE=m<)NRt0pFL+C7J~^te8;1k|PszXb7rh zMbySK+-ML|R2#E^gjqljKuVVj!qW+c1S4F!9PTayF@)eiK;)sVDYP{q>IUH% zDkM6o6c4de$CF8*Usr)di~|jN1(l%77_6g>Wzb~(MloXGtr%{;_<}kmlAut*jipM` zNGFg8CWOgygeiE!R5w8pQQvAeQ9sBE>yK#^2cjW@>N9|2SmCApumJjD!7u%=K-v$U z&<_R(YQQiAE5NICLl_!huBs9}eI_vw?}%5WSP=s$MMNV|U?fvu2E9EIL5&y$GfY82 zqf|uzs0jE)MSxVrd{AMGpvKa!o;aE4jJGHvP6D(^GBk5Qn~b277zA@ETDug@577L6 zLGzQMIRTmpf|^LtCM%J)OeWglgN%HOh*JP^iVSi(Ku$x@DGb7NDP+GC(gz@Yeu4Cn zLfQi4R0N$Wg`AeEKq|oi@l%Nw&{Iee(G-A9{{}WkP}A?gC`pR!1;}2%AbUxX>40p8 zpk`8Jb3m@dkmU9k41ChP+V@iOxWvn;Nk}NR!QhzNEHTvs*w_{9qwHi zML9H50ZLXP^^+Lb-~n*Fyma)?0lxqx!R^36PzdgHFnGGm;AwccV;zWA2s#}b4p`4( zJ%&=Gc6)=}-oM!GEwy_l*lmfRmJCBx1hpz6S_7c<-w~LBpw^=i06?q%EtCy{+DJn% zgOrY0&LG&S;*F%^Uky)Yz{r~k)iU#KF<<&+yj>B|9yHtk;)(-;+W+E;s#L!(xZ?YZ zE51@!9Kn@Y2s%sZibD}`HUQ3+0b&CW0ycYe;Qesrzd_AG&^c097%=p{dt?6}-Z=j7 z#tHMLUFMB*5zz&dyZr5qkppoqg1X4Ofu5H3jGELPe{jeD7kB)n?#u&sToKfjVQ7S) zbBl;>favzOJ01w?_Mh(jHz;=mb(gy1K@!Nu)GQBFsQK7r=TAzd<#%jtn@2r#|r-fR1GTw3L3E@u%ONziUkK@=7q%PH{8z#`1W6Wmk@j`GrbGFs*=+#xZTv#|wRz*lz&XdJ_B z3l>6NfdC{P;5~m2QAmMgHkKv}0tNCjxHv(cMx@PxhXtZYgFz!MrxOJTDuDbf?}Vqp zB&4N8LREicUQ#&&GOs+A_j72t0#sXxj;fJZ-}9t&RC>z#Vfpv;>4hiLz!IS%jkpRy zMW7NhRSXw{W!_+!#FiKjA&$q>Fg+}6a;3vFjwSYxQ10ujL9)bf4e_p)a)u0N%R_iD zTgRJ$sv~GTfMy_Q0tf)i7lvmdNP-YFsel0jKZwMNu{3zNf?mg~VhMUQJr0Q=}<674iT|Lp8vfm9qW; zE)8=!UD_J~aJtHYn2w;UWkCo8L52fyHG*bJZF-%J!OfSY;{lr_3@-|S;809ftGe>!>y)6)ikI82PeaFFk z!Q@yQm!IUWqdeAr9?f#h5hu~-un_d6-~YXGHM3aRQd*=paL)1qoZu}O&%JI#Tv-*W5mE? zhn5sdHIl>Q2-&e_*h@KA4DYEDA-qm0oXLn%NT9%*HQ-2JRKLGsWBSJlIi|kO{;t!@ z@?7>II80=|EHpM|shP>r@TrrRnngtLm?m@VB!ZN1egZEg65b6bV@RTRf`N3_ThU6kG$Q`}-1b<~RgJr4hv;a(Hh)FnbPz9U2zSiHMBiM#sd)@%Vz} zLXlV!pOBceV#(5wWlYw;*C(f>u1rf`wK^j+YfW~}+I8zUY}~YY%hud&+jr#U?<^?X zRaCrtPs!eWzm@JUJ85&z-NXsl9Nq?$YHeSFhFo-f;bo z8#iy=zSDTO>E8VZ4<9{le)6=Xwe4B^^A~@1bauUb)&2TSPjBDb{&#;3y#Mg=)91l2 zLtnoQkNjWv-_gn0#dWTmyT`owo?hNQzJC4zfeRJ}Eec-z|AzlCjbL}ye?La>E1>~K z|9p%{Z_0nJlSzk1MwI?rJy!ScZAS1=m;G<`Apd@({gaOGl~Dd;J&b~{5QEP^*o5)R zfnEEPApIx)R~EsJUq#s2e~L7J9HVW?|9W5zNI3O>Jw^fk|0q6;y0LS#boF<}CUNXY z$Nshg{nU>mp>U2(vWRq^*ZdLZ?}KbDE?AoyN{yw)P|eoklyC@BX$4M+YDSHKACJmh z3nvn)APF~y8cyX?6R13ljij=vVk&0^j!I=xIn+d|fGUD(5`gDIWfWCBVTCmL;S@8z zPx02$DgOU-Y6jEwe@qyvPt(Ql;z?5!kA&;?i6&3YF)Y1G z^^}`8x8`(oG|t(B7Xj_-rS0*MSC!&9LJ_Rv$KVt#=w@`Y>6i=_r?I7d3`ag;0_0?o zfStgDb#Un?0U=W$G9vjP!V>8190?4`Mk?@%UD`UB#Klssy16baM zr%~ujm(WNqbeCxcMBk+{v8Z>cQlic^wF@gBdYm}lvG0oJv?ZsHY>SJH-C(@V)DxFs zn2lR|C8Cel$9t4qo!{!PIo#93IMd1>?N;`1e_Q*hE%|M25IL7r)cmxz^-T52&d+kp zzpnkBEqRhOvTMe%n>9(6<%@IQ=Pf@T+?jaDK;(8NS4Vx&b=mVugNM1LH@^11T4<`i z{zI-#lU0_vjr9?NQ9%9;FO_Y_2i5)9X;r}m%xO2xZ7TOs8N}Sf{RR~Q?FyFp<%|3x zOYQtS${NZovpdTCFI(=*d7U%WT1#hH(INku;ed|y4-;BK>mT_2magGZu|b<)rccaQ zXlmWAx?!Gmpz3jkzk6=SV!3O6Md5*7+&rt??TK68m#kaUjaFU`%9Ee&Td%h4@|2*f z*5d64Lbr$&)=rt&dQ^ScpBxXhLyg^w59iTpYf4{}51w#Jc2&;Z7f!5oa9k2#(3w?H z@@%?saO^|lQ=W}aUsMHZdaOR2fBI12@cdkx$U`|(dUdYtJm|OAT6f*NsqTkE$4|SR zxlx<$c+hyV)iS|4iE&Af^;Lt`GTWE?BZ|X6EEiofzNB}iCCYM*SM|(3pTaY9b?p>U z?UQSC%jh|a!!{QgP03~Zr$-+**}LXpAl<`n^QHHW`9>mQDa)fuH_6sVx%bk2^(K~F3cRK z*8D|NKiZpYn(yDNZ>O!hZy7m6?Hw&4gJeHD-=j$1FFo10V_y5g5S<{^&L)*j0~&qe zC1-;tJt&${^t2*R{VuuqUMuR7=gBp;O{op>6m3^7@;%m*3X?V51Ol?CwF)JVx}A=c2MwWv!kG7urhh z71r&G%G$5Lqk6K}ny5+lPaWM~(z@%y1=FDZ_m^tN3_R^SD|y!YZs%}R*Xw_JyI%98?i+oHgHx9c9uB(LRdp=+n|9mhvKbdUkMfg;?Arz_5-z^1 zeVaU@H2d@3@o62u=?#6JG<)!nPg>W>JwsnLE_~i^p4M5;9Qrcj!r)PU+RN%^L&M`& ze*R5wq~pMxp+WPNgXPSTt}_>hzUd8rJ}_sb^Y+Ez-inJOf9^>bd9$1HY4GzM`?R+g z2FHA4eokL+cA=wge?B#({qkO=km2^J6*aH*N2q`9SwCSV>9g(DnoYyWA&g|r>}2nv zhPLEFipP`q-ZOu}+*w#KZW$6fAw|XU$oqAI#gvu3N` zczJHtZSyYeq#dE?x7+vX7cX0qG%bF?hKj@DPQN8jHzr$}zllk2X$;&WuT>Fq?{2Ol z+8jIWl#%gXyK#5YX{Tt5-sJDN_R+wv<5k~=@_unNW$^^p!$$Ktn`Z{Ee|auF@(HWC zYnRE5`lcA;^B?Q(3`~2~8UKzMiCKNzOQ{NR46v+^}_Ra+?N&{ zD}VkZyWPx@aXpW}|MzP_L}-xc{#sQztkVLS*Z{2LSgHoYlGITpk>%?k2w=Fl%m{v$bWii zG;%XJGspm z*OgJw=EuP-#;ff>b_DRFT#4-~SPPa6j$rj1zll(O0ch*JWkC z$=V>Ga_6~sl#@fQ+^kzL7}m36?ByA5_r_*=O4KV!cDQYG-c^b^0=EHoLsjKjE9N-X!DSU07s)!xJgE_%jbX7r*1`Z=bnO zMPHa@F-28Fe*K(QbBpzb`L<x zTaWfkhD*11hrh(PvBu5JUN{}#xcuKLd-!>+6YoqPKP1b>P zwFv!RtjBSljPY34zu2_yuD8P3Q#;Vat`+X5Z_hq3(R$h-w|2s#AMQaYn-=wE6Up|6mforeT8fwAvKg z*rJVV6;cCh*33V8o|)&p{0rW2VXIBZ8$ma2my=WF#;tNMV&h62<4miAI;Z9S;U36Y zD3`8}AA+#aw=K6A4xW$!M9h*ipA7GrJRayOl7 z)KrSQvTxnfm9Lxojt(5D{&-E>jI}ZQ?2+1f?V**a!;NRpZ|LPzlt1pcc4Fn*b*Xzo zn@*-1x5VgVTz$OhOT-h4iShRX78>Ej7c6_jjP4$;9`G7Fm}?Z{uk?QGstjsKcY4Ev zRb#Gif0T23Nsz<+1-p!IZq+gmy`)!ka<$Fn2AbfeaK;s%+GKV2THUt2Lc!a}Ccb*g zH;vp|Pln%Y>p8jHlK0&2kZSuE()k;^b^VP?SDbt?d(7!(6^l6i;)IPwVHr7fQ)t>J z4jb|_8ft70f9wd~{nU7o;?DR|`%TJMw{IlCGzK@n>F0aDej+%E^am(dpq&pWi15m{wO@d={;?_}CUaG5lnRW!Pla z1j;F66Wf-qMea3&i^`fyJo28hY0(WPXR>d|JN5<}sTj}G@4p{4FN1XQb<^pngBwpL zsf|<5Q>F1{XiNE^DL7!bM_6|L;6R ziN&I%a(%xs*>8m|=gu^2=W(8yc;{LT#E+BYY|SgZ?7qk@Be1r6XMQ1^Hkw9ud5RMY z4}{{`sYs6-E+ip*hhyN7;-cgM)e4K8K9#TP=3Tpt+b(r}(=a!0PU|S%ihOLsB|n`o zd>b{=OVDetT83*l#p^Gkuoew@(caeVz1KSFEp9{M97_)_((hg~ z9MGT5&p9$9r;zvNR>5U$ZI6-L@y*4OlC`##9Aj>w``W{d74w9(j!A-}?)tR^^{w@K z*Om@##vOT|dhA)wHr4JE!{>2YMw7p#SLETU+0OS>KXmU`{J^!!Iq!a=$!h%Z;yWja zu4eb9-CZB-*yOc#)6rh@Rzk%Mt*&XS^-p@v_jlj+#w4OQc$~i|{rBZZJNN5;&D6fr zX6|gW!U$1Guye6mV!~Y8y!7>94&cBrrLes!$=Y3&zT>|12zp06ois8b~;HIcZc zXXkxOM;vg)XM3ZT6R*w6RJ8xrkMHkuyW!E);#E(*GvuL{>g}L#@7qNG1?N<)#5qe{ zzZeC-Fj`u5dxY8>&=!AiN8r#~<*ThzdfZ+Xa4gnL{Iau<-r(@$)yY$A5^nIz!98cJ zbHxryT9?)zEIsEH8KNgnX6f18>RnY^rlcE9O|33Ic5lQ$sFW5z9&X07~(w1_#~ zyoQgpFY%wF@LKD_4->)b^f30`h!0FG%JTQ(Kc$cLDvW4uA(}SMse77Rv7Fx1 z^7P3v8&+N8Nw25dkGkZI_1lzN^=Kj|eJ_ewrDeEPiT*4HC++euH4C3Za9 znrqK}b2sY!^}Dx^MxWYsIkDF%qGkVP_iXy`(E6U-cw(?pbDPSd`^FY%*z*JD);v)y z)vOV#<>Vbo-}`uLM40U+gZ-8DGx=Jq$k@8`>()$BG{iYR-`#`D*IM-2UnON|_`cCR z%c`|+(`MB>y$Wx$8BcwXO{SXWHm(ixIdNp^igv%eD!Gcvy(SOjg9OJYhflsBiw#^p zIe4adhMldgtwxM(eJ6+CV%JPuq8&e9-?Vx@i&ER4)pF{|s##HIeH;4rxhcIs#vR=A z;lTEl5v;6cU)|2R_Q9viI|J#D#)BD!Xi?}nAk)yS1 zXMAg>hxO5k!?jV8zS6rZ3#R-pa6R)VT+t`hmMH|$7;MYs z=w7@ZLiGDy%pVeY*ti(=_ZhZR@5hH2FD?2F9R(4c&QFc?F zuk5Ytuk5bus_dj3q`XMkM|qkuUD-l;I&Q+hE>Q(02{3(nK-jl5CA|?G1BD%5N;n#g M1_JCr;4|U>0>Iu_p#T5? literal 0 HcmV?d00001 diff --git a/gguf_ex/_build/dev/lib/gguf_ex/ebin/Elixir.GgufEx.File.beam b/gguf_ex/_build/dev/lib/gguf_ex/ebin/Elixir.GgufEx.File.beam new file mode 100644 index 0000000000000000000000000000000000000000..bba49b7cb9477a5998dbdc8181dda007c8738c17 GIT binary patch literal 5640 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 Xk!ey~4}UYk?@O>nKg7-;lA-?r(iO<4 literal 0 HcmV?d00001 diff --git a/gguf_ex/_build/dev/lib/gguf_ex/ebin/Elixir.GgufEx.Parser.beam b/gguf_ex/_build/dev/lib/gguf_ex/ebin/Elixir.GgufEx.Parser.beam new file mode 100644 index 0000000000000000000000000000000000000000..bc2d288ab87deb0432b3e6a90da69dc9ebebd7e5 GIT binary patch literal 16436 zcmaib2|QHM_xOw~xmV54d_q`SFUQ1CZc!{lpjjIjM zcR30r+WY(W?@Wl~z>G|YpcjmP6ehVXd|Zfqz! zCN`4ED5o=GIgC&mk3nx_B*d~gJT5hczAQhC&kE&5vRT~V7+NTY&7}Zja15KyXEK7h zJPtpUM`1-WgBctqjTQbOoWY|`UljI~PGd%fv#9)7f(}8KLXV6iXy*%2F$@;3d`3lA zS}XS$ME1qaMeGU zkt`Y~kwRlKA>s_77qEF`48s9&Q9dIf6pRWC1qMAcJcQPobroU|n9HN_Ai@kQg3 z3WdQA`v3;aX2vn7Gd2bWpz}i+9?VECj|=)^(P0)XhVg+R%oD)J1is~RAp(dVAR2gp z%3;K?d5m&e2zSPX!7Rk_T!=I+b2e~7K-kf_!Q4<9lLow_ZwblpSP)+Axx(y)2TJ9 zR^wkO3@PaTmnHQLb-|>dyHuB8@&CL?(f#ik$VV9J!P8?XXHgkU1~Lh7gQv3tMr;I; zbR${JNEU;xJ3CY9FV(eU(-|m~bSVmjA^<>s%>V=d6ww3$N<>DLfF_$`isT^~gKXPu zFFvrFZw7x?c7?<7WoQa~9z#UKunhS3fE`ib5DYsKz#$eE0srYRh6paYkx}UUIRyM( zbh&^aBJ+uiZcGs)6Z|j)KOz|enq)r=MH*>PKw}06&oqhXa{{u6430!V_e!D&FqW(a zJCcb4ia5nXcNn8NjPRxm6Mzh|G*JKpDZ!xWM}&zw!{8rHpb!pXH z!fGU#s4fT=CF3(K{4l|Ik~~bt6DfEZG$bR4O%Ve+kvyb{1TxtcLr`;26E(EOkTEb( z4OS=V;FZW|Xn~*?2-gI{l_g^-_42SNN!Htj?TF?w}3Z61cP7>n5P#irBfpzQU z3F-n!S`^0fV2t`Kktj^U2p}0z!re0bLf|kE69S01L5z@3C)%o$)i#Jx^3~K*#3&$o z(*4xZL1zRyOvJ$S8G$5GauX~{1R`O3wOR~<6%|0TKoR#p5|Q!l6LW+y1bK*n)5huG zNOas1b(}5_C-Q=SjfKUZ}vq(c6f$; zu>hI}*p~rzjVk;SVC!lkhTM$TA<9FtAOzuboUsVB&|j^xt`f8esOdl?6EHYcayrr6 z4^xiUl806BnoIGTXh@R)lV`Gq2vpS)Knfr{Kx&qoqJIA->fp8gh>d92F&G($_H0&~ z%w{D(>eLW{yA(Hwk@NkC`5@Bu*85@7E%CZ&Xvqe=9w8qyi$g=Ye}%Fzko924SVXeE z08#>@S`LDaqJv-RM?8m~$pPFvp$(TxQa~sYX0sWZ4?>P@i$RGZjub!(z-dYe-hc#1 z2*D^}Dw>WRx&@4FE9`DS%k{&s4AsnF@?3ctbQ~D1a6U6GQ!+G(xAgPmH8SktZXm zK}J%80(3JHidqIlAQOSH079lbGmtYTbvSb}22+huBlGc=z>{Ep>?M#5oAH*@uGGOV z2N*0F#>#uc8|^Idrf6t6j5YFxkJ+IiQvsxsA{Gn+x>uSA8s&b5upjXWQ2?pVo_T)= zO%aQ2l=icO2zH=F1`TOxq!sKJ3dw*oVyFNDX@SsqfAAKPcta#6+LqI~_O#tbG;rfAGaL2l|3g>uXg)jgj=9%IHflULaZHlBVuxp^uu4{l@z0i;stfr2J zyo>QZq*A<(A4w=O2#6H5#DgLFz_=hH5cj{!@CN$A@Q{aP(cK+20%lBhy&IN zAVc5)8klp|f$A|c=QQJkF!H@PGP3@lI8xFHhB#H2V7CO%@FSLkWkwK4#b!M9FPg@G zX{6B*RY(&oq=5+2g23@_Nh)Y4SV%?to2v1@sFtE3nvg1FnuEVSiIKf@RpW_B!}5V25L9h(UlofOWwd(a;VU zH%!PB{zn0OiU^!O%MuP)Xp#gE*bZ4=3Lqm;VpRTnjTtVK5b>v5AR+yaga{y^^Dha@ zfCTmbmJlJ75G9l_?Y=**F$etk7 zF+8&q&qPC!U~nM86~U}NAB{{2$Wj;?X4L;Ci21Le=;?*+Ajh(m5@YC|rv} z%)e^605TDl^B6)fvYH^{LW#nIB2qzE0%$o1SvxTCv#anNFwHfCfBF3B#mek@Srfm0 zc7+^|k44r(pa3jLM-e3nWRO#$hcKdKu*efYreID{npv35EOBH1QN>KC%KBMV7{r4_ zpph?Tb_orc3kf*?Fj)w3TmfVWR1E{!#?!&`fd|q}w$Y=osgE?ZpIR>8uay}9tcOD;yhT?4P zQAV2hcpE>XavgkvpAobWxG0}LGebTwYl5vkK{zHOWJ&~e$OaS)CD5t; zbf>mRr{EM>kAn{Fz-c;Yl91a3q=?!BJ1#KACt}L*$58n5EJ!fIh4rqPVn;zk1xO$if>i_T)bODY)ohJWhPFmzJK=qx2Y7Y@?gJBWL25V+bzGtyE=d#@Xo#a?aLGj61`-nJ z7<-INFo?9>U?KvCJwj)s0B7vA#P7kNP~eH354g!!uzxX=h%2$Nw(o__jB7CzV{ zqfkyUv493$4Cqt=-~mVh5SeKs&v$0q(tovO{%R9v+Ops%2LSXelp{ZbpAU`;0H9~^ zi@|Z0M(Z!U1!&LqWjWKf0Y}>znib&aIMYV-R0M#?aR%T50FmzszzqN*#~pwNfZ2XM zXYdG(*9;zMBQ`?hAbR@Gv;)9#R%Zmi1^^;+Er4}1?O7dW<%i7R?ZJ@_0Kta?hyZ}_ zMgw31n8nA;;1M~9&1dDr&EOGwD$;gHKzxKU0w4;22LPeXn`wgsDhGfQ00eIh0O=2D zi>%cbI*ij_9i> z;W&&6b0HIF@5IfUGWP|~jjU~Go zJR2No01#dz#{B>wv4Z50Hvoj*0e~3*gvJB_*xwS;P{45+0HiMs07f%yb#OG8X{&&v zCICdHG5~}QX)Dc~BfQ8Mk#nRkWbPpWK=4TH%>{t;D`5ln%D_?MkJm79T$V5{Sp-z4 zWnzU~H9BM3w9m?Qx!EA0W|rfcQ{nGd#kc>A>zhm6FM2>!SL7@T_slL!WJB=dH7+`^^DlH( zoWntNQR(vYUwsLQtbVzzcS#9eE-np zgvv*s`jaOHUrh#_>TBy$yz|heI^awAuC#|%CfX#N#IJfoMf{p=AFnKEo~mWBV}{mG z9a7rad;gX3<+mp9i&JhXNIu+14Pf(!Sm{Yg!v&okIXXf26h2=r>5m-_V_W$1{md3r zzrEx4bE+*loS}xw`Tg#s;^?bXpW6Xnw_CTr{38Co&X9BO!LOkKrIwpfeUZGOX6ky2 zqxY7WI#j=Q$2(?z9J!*O+_2qxtbWH(`J4CUO{u5eu>-mH0!z*7O@^wt?XpIlM~|47 z9C+K~kQTXZjU{^kt9bfOy^%}mM01})yW7>HqG|7QI`qXl8h9B7#gFl+`_{bUUtZTE zV0EP(-s^BJmGMN%@u~H-&a!BmzD+iV+&0?BL^@8zhCO%}t3EQZqWV#v{!2 z+D7HeWDcdyJs79apmpi_+qk!t?J0hdK08I-FKxRWmwkkzWLMNBfAj7BW|OEjw`@Ig zlhpMry$XgtJ{E6X(ED*DialB@Tj*3?+b1j2gepn>RB<-I9A8r9nS7wH$Txf*K3HtM z@1~z2ANoR$T1W8%J4X7I&IEPwEjnbb%bI-aW-gzcxLehpq+_4O_Dqmd+VD&L zX`aE6pH0%VDf70UdMbakY1?_@AC3dOp?jAnU<=RHSM?hvZl8A!KXRzU_1t>PTlxh7 z$|I4F6eNq=Cn7@TURwQ2#m6tYtIcSxNyYAg*g#k9toNZFm1_ubMu*_Rn#_p$!2`Zr z@yti$Z#0+sEuKgH#y+3M?{E8!8nL=QA{Dh~)#E*j4N|C4+Ex1Y3U|IO;)|;CSK<9i zwj1`Ej6Si)n;Uyxa67Rn`wq6j=E-57Q@5cNBe}Ou^m^_5-jX!&py{NOp<8v+Q~o;k z#dcM@R{|;LJ^JCRj~6+~vETYGs{BTg>lu*ic$3kz+k|5>gpTg^sa~d-z0=NUai@M& z*CR@=@4Ph!JL)7cF89y+Y6k7l*kfaxD~Q<;(I{r*tU}Y0bk8U)rX&n{)14w8sXS_ecfY zF!a5aRJtJQ!OatPMjd#y9W~bztF%)4#KzdAy3wx``gcc{s(eU&rLemQG(4<(q}+{q zq)fQi4N1)<;o6(_g^#PE&!Pb1L{N6aL>)otVoa(UtPN;`gv-#?8~WUS`Sp36PBc*}3QBE{9(j`O+Wg%UsK5{4um)H!g^ z9(pikDih^3V3GG==hF)wtd7o{8@p;U6-s|v7u{NE5zkIZd0n?`N&ZUjqo?v~-YF#V z3J1eqPgvw76<({9Xo->hs&?)Meed`}Y^dD+&IQjLkGqTV6n->K*c?@AtZL{Q*Sww) z0$JqqROHb_lh?OsJPT8WqIW63i z`E7@+!)o18jXIUkx?#DK`Q9Bi)ja5fl-er8&_`GtS4=-ElW%txa zO*=oocbLSib*H3WNKedv(GLZVKOV_)7wOg{bxU3Q<%nHi}viL zw?41qItOBYx4Eltd4n^iey~Y-+4iY0YQPFzwg_1x|4H)xzbRQcU% za^T30&2_ofQs1JK7pYM4q;#JZ5fW_|>{;tA`myP{7RNS1O)YFissD-_bXP)K!bXj) zwbx@(7N6K_X`#fNpLFq^tnMir`5g*#+UhaNcW!Q4tl*yW%{$|aQT2xXSQhPO$S)2SY{mu}DX}M4 zaXJE@YvN963UU-BQs+(`&?dF7ynXj`=S0Ohp9|uCq(?EeaEgw&4td?)FX+3kY~Axt^D8Iy+8L&UscYwcO-9v_PtbXqL%(^L zXklFYR_}w@oG0O<*qp|>0mS!=qAJ|eAVGfY(E;iAMUz>{mo~@l%P{dA`NbSkbv3OY zIk{|@z+daqD&uM@n$}y&fs!BXyNPquZDp$;=qn2J6*b)#-`d#CZh8IdgUg;0 z_^Vu63|yCsK5o>Qf8L7e+T!QCPdh6)#`gS~FvpgApNQ|5>70+mJ+iMAKPK;6bM4V( z6=(KyZKGjA@rBE0s&;9FyYP+QPhhpawk;SA>Tz$q*PvOgl|Vf7zUy)%lp}k8aJl`P zn6*WV=Vx#SmS^1`Y`G`wAQW^!b8ImI9pGm>*l8zIcl^})+}ndK0sA=6P1^HE9#;!a z95Pe-`ZB99xo}uc6P4vMy{MjhSEZ*_gHcKOL9|JBS7yFdSP> zy_ROvKTqiDoWCX3M?E4k$0uS=uvS-tLVAtbnmMa(NhY{-r$0!lezo<*89p0pxA0fP zUdK!m*Rq|jSt-tTdy1ND;E8x!in{8f3Duw`qu{TeZ!?2^*&Wy zO#c3c!!~FeI#J#|2pD3_+fKXoE$ZHNHpW37@$Ll5>!|-P3dNdA>OUCT#<>QQ3tti){{N(Pty6J*buCvtx(>_6X3*p%HpSm$? zrzApBBaAnZobso9wR4{(J6*x7)ok0AmSgf7@=Ol)tFdkF5bdm+XU^a&(YXB&SKN{7 z*UlqRRh&EM(raO^_vgRJ^ZXT$9MfZnyZRbr?(U=(?K|Sf4SpEe5A0i(E7^K5a8p)BpU8gi&NUUWht_e;m_-wHrynV4 zwgg_7t@Go^{n$^SDacY>XHP83IrOmdR+}J9|U&ArF zRB+$YbOF1tLW-SJ!6mm{;T{co{yuj(etBi4;v6xDKHZ)dt*;J-G`aYnSI#s)`Z|5c zEYNW7Q^!sV`5oG>YYCsFivA1)6v-RXMoVjmP*VkH~HIHic45<8g@?`ar@S}uO z`Wi>lL)(DKYf0UK-r`d01Gy_4bBDkF+}&Skr+NM%{Pf_F2D7PK2~Uo1Nx#B*)IEvj z8>}j#Yg}-i2wlHQ{b8i%miO=Y7Y0gB=RIu2#1NhGn#5Kco_Uw@u&*>qM=TW;f;dXxWyT>g@M>X zS(5EhO2Gv$)TZa>f1)hK$2SM`y~sRL6mahR?u7YnciXAkk08xP<2xU*5>E~{S-4sfO_oW~>sM}kEo*t#b2L)oCk)h? zdSQPiRrL-3QRH^U+T(A3Zp%~rw(;P`#4w#_Wj9O$rGHqIHN3$qoVeAeJW=(w{+7vQ zFL5KC#XFr}6yF^*$Ek06T;==5yt2w_1NUO6AkoWOq>#GOm>5^QX}8ns_5KCDG}(^g z57_p-&iO7PmEUg3bv&3`-?2eUcC-F*KDW6|`h?CDOdtHM;dA$Df9Yw>aVOf=&KJkK z>(4)!&{02-F2;J)UD>&AYV+mRgZ@7%_67@rwuG&*h&$bCU7b*M+(AjYiSA0bf7k6u z&(g~@S;Jp(*!7+NTDi$HPkw2q8d_ae$C7BO9%vy`t? z+hi%fimozHv^!SfC#w1&VEM(-V~Z~rU2V_qz3^i)pRAGdb(qy1t#oPIrJ$YSzvwFt z_1FJZ0sg=W$TMz4EBj|^@p>#D$=k;+!~l8D*tr(byC zMXljzt)H&XRhh3cowco5Uk{%>(9mu;iXrQ)<*kWJe)}aV!ELWnMmWXz^orfb_g20= zoi*1MJ9zBvt@hBJ%VIOmih1rFNS(N;x=6Fap4Zm_SIANBd@iAfd7Dj{{fFqQRwS9AVLMfJ=kGZU2iIRd zr*g2$GQV6{>YuL+uakNc1|O)%9HP&=ywI~dgt_~w@x_uCu7!CYT(k8)_J5E3>elfn zLYmsBt-gD#yzGtHqufoaoiv9m-Oo;V$a(Dlp0K$2Sq)wLu89m3x#i=}Dznt9PILOa z=RUsp+AL+{z>Di*VGlG*tqk6*64#MW($5$_)q6Z(v}cnd#eHW@)Fvg{)&<9vq9ny* z&V1WdQVU;E?%utmyW8vgnrPdBkbLQ;vayV+lfQHqZNTbiiudV;7JbrnIaE1hT6?%? zlUiDV?2Df8RiwfK{a&>>y~$Kw$vPK|z);azHk*H&RJ@p-h< zR#JQO!i_df75W+OPL<9b)JtW`-;$R}6KW-* zuZGMIvk1-;7RT)m>ttq2t)o|#)MIS#yx)CF*=TUx79S#2)qJ%5@H26@x?OJErGdmP>Y{ z3ulv)gW`@-wHJM{p99){-8(A!*3V=?)BRkzThS`{TfDmrHQNRQmBbH^8s)@iE`YmYS)^!uK`Z0GyBX?dQ`(c%P;_?ouLy@H$eH}jcq{^Gzn}=W4Y%Ck?>08jebvJ3^dmd>b(brQ&w0BSLH_mSB+86F7 zB{a+6qDiw67uRdQ6c=MMz9omuxqa5Y(GGXws_0FZj0;cOmyq&2bm9%3J#R!`o~l^L za@m--deBhmh&*b=`!&zZ?fr5z?#HAT^k3M%?Sb#Eni`I^cE#pB7h3BbeSiP{qJ2Z@ zxv2cWS^ zv2!jyPl8N)c%dIKP}1%Gx#ZV4@%!Ft$?dns(qE+RtmVwls4y2;4K&L?`&bwtBVj{N z_l3FY5hh-Dl`jXy%eEbz*zF*<8z-LZ6>#+|w(F(*H<#hg^nG0uCU+Av^r20G1d&1K zGvwFxn8H-6e8REr1~NbDv@!Yn zvsYVPKgM~zoZC`mUUqDVJ7;XQx@UO8@Q8%lz888&(=g5z1??}a9#@sGDfYJC+$b0r zh^k&TA3s%lWH6?Mv;CMLoPO+wdguDX9@>$5pB&#{GP-UA+@)pS)7@3$9ej=C@JOVy zplV1Ox8HgZ@%Ck}Q!5X7Jr3|ljV|@H3zpezgv&1bWt7^V8#6L=HzMZFI(EZw!o)F? z`CosY*~rQXcf?DnO&nwQ4F!*-A0KggKKfu=QT@5mUCh|B=FS(Fe~IKh(9SBp<3His z_WINr;`z(AU!AgVW>x2mFuR@PG}-JO2N!BoElbw({FX6UlF^pyC`PAV9M^e~%Q%D6 zfWH;QZm{EA2sj*HvaLUA^j@DtXk^zf6Xz-CR3F)6+|k@X`tnOtlc$utdBjq;Zz?#PJFvA z!@nDQY@l}8kAj3PW6p0DU-qf<-}-6GL4%lZy$b!t z)iOF_q*Y_B)F%oL_rKRfwSVHEJr~~E_M{8WeYehiPLB9WXN{LvMZTf(JlfhE1vZU> zO}X^0ZO=s{{eEFRN+0eX?_8)6TGu)d)B7lHqiFcMvv#JYmkw-Lj8vm*?PDh;*2>bK z{~+)wTaIgLvJFp0^*x^xztpkfc02iMiMYud>6>liObP7EoTw_b(tBMgDX!+@9Bk)~ zsIbB?1J%!kOJ4`lTikIap>b=CR0rQlro@Bj`^L}Mm zmob=t_T*U~`l2@?QvPNGR+n*1%ze)Bc;ddQ8(9W2tg-%eO4-k9zmndss>csCDnHw| zHcL75$ReslkFEBivekOK-V}J$8P(o)sk^=ZelkQSbx^c_+I4Il6x+V&`EEwmXt-5& z%k@)|8Rxt0qR3wTPwT(hT!Vl8@Ydn^a$51ifLfHhl(O1;)WEHPYv;F%86B+-X&u#MtXN&SQq_IU#QW2}V>hkK zA6bSDNZ3?93J3o&W-lX~Jjbn!7bx`E^v)f$@GJOG+qVVlj($ut7^_&ur@Eql z^w#fVY;T7vs&#LdILNei6V!Vf*3B7=^dKtLo#(0vXKtEfYJ5bbPp1F~0k~$u~l6v)r zV_43S&94j2gLLn4^m)5UBZtuZ_~hn_!CZGs%{z9Tva8M$D>IJ2X?iUup^J_;O)hfC zENu=7!8Xo~aw|$ntUym1n5I{0RGzKhzHotl-wpG^1($X^^-8Y|nD_qHROq>5$-Jv- zSWVMt$Okw|s)p4--VRo3@^=(~K2^C6O12xLZ{L;$Z zJeXC)o~zlGsipt+WG5+a*l>%5v4@(?-t;SIZ@DXtNr(EcJQY#W-`{VY?C8W;V|x@2G5hYJnAe(HHn?mmF01L;bDUVM znRHimz4Mh<%wEPzsmc?Wm|x{CrCvelc8*z*2}jNP3^nVs>)cxlCu4N=W3M+fnWdiT z_I~Yjf4p&Q^aZ0*Wxl@RJ#%GWXJR#pr+KAB@v?|#tWnWo1zcH?(+Z2-E0LRYSi9|X ze_P4AZ|I-ri*j(eS8V{cVV?D~jq`1-UJdBE8#RxXJ02?`CT{NOwP^g>c>k$i;KS7L zfiJHvOgermI&*KK*zdLTS{8)gX?xdy!F`NIICi2hs{Z1hXO9E&jN!RA+v0ac%815Q z-YUO4Z^znKEmZ7W*tqh8QER)U?3Ty$C8k{^3LU4d+$zLBer@_ye#$s#!J%e4>q%U4 z<%_4o9&|@VS>IyMqi;$6Ax|&SJ8VC_eWtl@(&L+0huN21+o1Xf@NqN6ujYDz)r-Fk z1Z&?d+j+P;J|MrLx4+2WiaFZ!Bs{)%TgR>6`u3|$d{Fl6P%hY(w?y`%F&PQPG2X7+ zJ_^Cr+gU;W*9GP02aYMNF|%tOhUZc)NO~N(`5L^s;9_>wD3jM!{;x3NnYWGEA4W4v+we&0|~h8%9NhqxaEJa#fMno;|_KK3DQW5<9lBg>w?wG>R zK1wk^qF9U=FQSMO0j{91ZE+!|3Wli5_zuk3X%-mqbewUW#pF^DWS4>F$2**^))@@r7 zFp9ZXDczrk>s{QnE?A{0=dNyHMy<8>#1TdeIG3CAboyRM`kNiJ>}2b*j+WV-`)EXkTomVCAIR7Rpsg!RX3 z)uiF^-v`IGej)w{h##RYtK2OAz9*zmsp`|4#I^SKR8P8|`jvfq^RvG1ziYHg*{9Ob zMymQv;FSx91Uuw?r)=aE9qE}*Ktm%Kq0tNuHEucbE)IA_W9BpHnOBei3V@yeN3jhXG!_5q^9M zq^$xUJ%YnE0JA^j9Wdlw7_^L*rIxXliPmy#F}4g_j^$#LwNP3ZEm7<$tSiyGun zdSbn>-dJC3H})nr3>%G&#in61u$kCgY##PD_Aa&`dk^~n+lSS{YGZY$Xz5q24N zIo4cDTnnqEprwR8ggt^iifzJnX=!NbXz6JgY8hdlV_#xlVMnkZv7fNx*a_@6Efp>`pD5mV_1&CHsGUc?7)Z2EOP7>gR(oAn(_Z7ygFH81QjA@*|T02Kk{; zjBJo*FIyfgx<7T+he*Z?z6*A4zOkW27f4C6L k|BXi2888tVr5Q|~mhn3sAqKy+zqOjSBTD689H0{YKYnHTZvX%Q literal 0 HcmV?d00001 diff --git a/gguf_ex/_build/dev/lib/gguf_ex/ebin/Elixir.GgufEx.Tensor.beam b/gguf_ex/_build/dev/lib/gguf_ex/ebin/Elixir.GgufEx.Tensor.beam new file mode 100644 index 0000000000000000000000000000000000000000..54a996c252c836d999e1667501476f3a7d6d18ac GIT binary patch literal 4660 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 H`XT7wI01uI literal 0 HcmV?d00001 diff --git a/gguf_ex/_build/dev/lib/gguf_ex/ebin/Elixir.GgufEx.Types.beam b/gguf_ex/_build/dev/lib/gguf_ex/ebin/Elixir.GgufEx.Types.beam new file mode 100644 index 0000000000000000000000000000000000000000..02b09a290785a61bc6d390e4f6c8dcfa55d22001 GIT binary patch literal 6724 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 F`X8&FLgN4c literal 0 HcmV?d00001 diff --git a/gguf_ex/_build/dev/lib/gguf_ex/ebin/Elixir.GgufEx.beam b/gguf_ex/_build/dev/lib/gguf_ex/ebin/Elixir.GgufEx.beam new file mode 100644 index 0000000000000000000000000000000000000000..2ab010081d039512b18537b2f578a72edf2fd426 GIT binary patch literal 3060 zcmbtWc|26>8=u88ks33jvXm`Kwkee@OM|5Bl&u=qs{Lm&_nOG`@=?G7x4guyp*q>F+bB;jN-gA>dpld~y8A)gT>5<&tVmCNQaSWq?% z;_)FWMF`PKAPJAl7YfL1+Kz-^5r-;da5;iNHigRP3W&fM$mY^SEGSSQM9uN8t+~4B`7Aci6}; z`An~Ff;w6I7GOZ4Tn7~HmK zQnaTi2;v`z5M7GSaVXt^B-+-a@km=+9GKm09T7kT+B#x^;Mt}00uGHpcnSI5@W!3kJXmfAkOEKuSOtIrfX}7~fCRt;;J)hLVvyjj!nw8p z(f|YiI2O)_-`J34adj>z-z!d%9$aA>+A)92W;1hWWibpN-X#9Q>7rmwe<3{ zqac~Uzb29mX6(@HG5rXuKT2rrzh5X^)O2*_QsH{={^9ycUnPDw=tH1yTCNS(LLU=w z;B}B3EJD-YZ{#pk2F`mtz4|S|L z7w~&j8E#0;<&qP1xG{w)u3oZoC8r4kum^&-$laqVVSc^BySg?IN-(x~bh_65uxqSZ zSy{y8ByPv}x=ke8Rg@y{vlGo74hISYfBnJc$&MMkw+fYbm8a58(r#3?N14yN6Shs* zs`hpnUaYvQc_%O;CP76Ql+Ix(uY-Zgd#={SR`n9{H1_4yjm9YJp7%7np3(Y? z1z~f$PIX@9gW^^;{jcc#NbcOn$*i3xNA!t)qN)Bj(O&M={q5Bsgbz3d(QWdQ=cat~ zUv{nS*^u?D=O?;C!EoBXv{#IgrGtBB=B$gAnE26bSKQSsU7}6$hJ)P@?tb~J$KsKAuQ!A0SHe12J#@$M z^w@jls4oBUm~J;tyv5ilRkHT3+lrhE(_2U1DYtf>ygDJiqmuky@oIgGO~}u;<|@N> zm%M6HuK7WtP3Ijq815fDDKVu_6~A;@#NSXv=Y#gP=TZfr$(!L`!aS0svr`7*`s@i$ z#g+cCH5wc&?>M1MOE2!8d=9DD|CUl;ZFp>fJE!1TX7|&NtVv}PlQ?|G-d$4h4V_aP z)0N#y)!9Zv66@zjUhH%0bZW%} zK~5(va8UKCxF$a{Bg^X4oE^c}`u$9untsJdsn4*orEcuVBH>mf$)b*^w==z9%Uz|;CbHOW?Q7l;677DIPcpa1Y*c5V)~`F`l2pI@zhYTb%A9n8V9Fr;hfbsKf_W+n;h3&XQ=>wYMx{udO;UaY z6_=H)VkhipW34B;g_YdO#{IvrF(_oTM`(az$mJT64{KeYLGaG=e!uyf>zQosDSUq7 zs(qbw%a(Pqj=0u5V$CG&hLfA!i_Pb{Wu1=e3v(Ow3idFEZ%dnV-^$L5>Sr!GZM{yo z>1+3{mYND3Zt;-SyMB44UVUZw6oUUyP5uf6qorKr%o+&GxqW})t?%BwrU!HTnv#+d zY0h%;ht3r1mC!_IUe5PKtx^qG)EH>InVfg&DGA5IRqB17owZr)rzGg*7h*DxbfQn| zG~aQ1YJ#U7G>yuza=7g&`>C(uk*l>b9T&fVFFjvjcrGz7&iG7{#dPbT`-hEv z`_wI!?=|!>538v?5qpa!?`!WqeRpkFGq3x!uiaFK>-dCxo%(CA#!G>}}}1wB>wv!E0pRpXqPTJ+Ly&5T6S zrK&fr%=!#D!nrFhZ%O+nn@d~<4$9nOJKKwYO3k=I%wi)#g##E$ZI?^_*PY(OI~JB;?N(fNz?E#4Z$w-y*>;R}os~uViWnL=A=b z4u#F2el>=`H0K+w`G1Qs#ZrL4LSmVJ&Vq0T>=o=!58&I70m?G>!mY4ap@UfU WJ!Jq+@8di;M-Bkygh=%z1mbUa@x+z@ literal 0 HcmV?d00001 diff --git a/gguf_ex/_build/dev/lib/gguf_ex/ebin/gguf_ex.app b/gguf_ex/_build/dev/lib/gguf_ex/ebin/gguf_ex.app new file mode 100644 index 0000000..e38c734 --- /dev/null +++ b/gguf_ex/_build/dev/lib/gguf_ex/ebin/gguf_ex.app @@ -0,0 +1 @@ +{application,gguf_ex,[{modules,['Elixir.GgufEx','Elixir.GgufEx.ExpertMap','Elixir.GgufEx.File','Elixir.GgufEx.Parser','Elixir.GgufEx.Tensor','Elixir.GgufEx.Types']},{optional_applications,[]},{applications,[kernel,stdlib,elixir,logger]},{description,"Pure-Elixir GGUF (v2/v3) parser: metadata, tensor infos, and absolute tensor byte layout without loading tensor data."},{registered,[]},{vsn,"0.1.0"}]}. \ No newline at end of file diff --git a/gguf_ex/_build/test/lib/gguf_ex/.mix/.mix_test_failures b/gguf_ex/_build/test/lib/gguf_ex/.mix/.mix_test_failures new file mode 100644 index 0000000000000000000000000000000000000000..002e9d79caf0621ef4cb8f933fa9a484a64e60fc GIT binary patch literal 10 PcmZq9U`k{xVE_UE4bcI_ literal 0 HcmV?d00001 diff --git a/gguf_ex/_build/test/lib/gguf_ex/.mix/compile.app_cache b/gguf_ex/_build/test/lib/gguf_ex/.mix/compile.app_cache new file mode 100644 index 0000000000000000000000000000000000000000..6ea8115617c7526ab61a9974d506dd470d0bff9a GIT binary patch literal 4343 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 literal 0 HcmV?d00001 diff --git a/gguf_ex/_build/test/lib/gguf_ex/.mix/compile.elixir_scm b/gguf_ex/_build/test/lib/gguf_ex/.mix/compile.elixir_scm new file mode 100644 index 0000000000000000000000000000000000000000..cb3dbfdfa7c6e6c11b1d3c70a29ff530ef142eb1 GIT binary patch literal 49 zcmZq9U`b@kV9I4+U|=)UGcwRK%4T3PvMd*N&B?6DEYkDMtk4T~_SFkWEXgQm&dbaJ E024+w%Qm5 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 literal 0 HcmV?d00001 diff --git a/gguf_ex/_build/test/lib/gguf_ex/consolidated/Elixir.Enumerable.beam b/gguf_ex/_build/test/lib/gguf_ex/consolidated/Elixir.Enumerable.beam new file mode 100644 index 0000000000000000000000000000000000000000..b4eef6e587a9fc699968338767de42224ceace31 GIT binary patch literal 15792 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 literal 0 HcmV?d00001 diff --git a/gguf_ex/_build/test/lib/gguf_ex/consolidated/Elixir.IEx.Info.beam b/gguf_ex/_build/test/lib/gguf_ex/consolidated/Elixir.IEx.Info.beam new file mode 100644 index 0000000000000000000000000000000000000000..f34f29fbe2fd59ec1280606268a406193e39c19f GIT binary patch literal 9928 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≫J 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 literal 0 HcmV?d00001 diff --git a/gguf_ex/_build/test/lib/gguf_ex/consolidated/Elixir.List.Chars.beam b/gguf_ex/_build/test/lib/gguf_ex/consolidated/Elixir.List.Chars.beam new file mode 100644 index 0000000000000000000000000000000000000000..dd3d5345efbd5355509936214ec893540176b783 GIT binary patch literal 5348 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 M1_JCr;4|U>0>Iu_p#T5? literal 0 HcmV?d00001 diff --git a/gguf_ex/_build/test/lib/gguf_ex/ebin/Elixir.GgufEx.File.beam b/gguf_ex/_build/test/lib/gguf_ex/ebin/Elixir.GgufEx.File.beam new file mode 100644 index 0000000000000000000000000000000000000000..bba49b7cb9477a5998dbdc8181dda007c8738c17 GIT binary patch literal 5640 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 Xk!ey~4}UYk?@O>nKg7-;lA-?r(iO<4 literal 0 HcmV?d00001 diff --git a/gguf_ex/_build/test/lib/gguf_ex/ebin/Elixir.GgufEx.Parser.beam b/gguf_ex/_build/test/lib/gguf_ex/ebin/Elixir.GgufEx.Parser.beam new file mode 100644 index 0000000000000000000000000000000000000000..bc2d288ab87deb0432b3e6a90da69dc9ebebd7e5 GIT binary patch literal 16436 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 literal 0 HcmV?d00001 diff --git a/gguf_ex/_build/test/lib/gguf_ex/ebin/Elixir.GgufEx.Tensor.beam b/gguf_ex/_build/test/lib/gguf_ex/ebin/Elixir.GgufEx.Tensor.beam new file mode 100644 index 0000000000000000000000000000000000000000..54a996c252c836d999e1667501476f3a7d6d18ac GIT binary patch literal 4660 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 H`XT7wI01uI literal 0 HcmV?d00001 diff --git a/gguf_ex/_build/test/lib/gguf_ex/ebin/Elixir.GgufEx.TestSupport.Builder.beam b/gguf_ex/_build/test/lib/gguf_ex/ebin/Elixir.GgufEx.TestSupport.Builder.beam new file mode 100644 index 0000000000000000000000000000000000000000..256353430ef259fd67e9adf44edf6785c029b999 GIT binary patch literal 8300 zcma)i2Ut^C&}fny;3g2c5SkPTRazkQ4wo7cl^`JMu0S9GLkTen1P~Pk1r(*IXch~i zf+8yRg0hODhz-$9FCATF)?ulHV8=OW$=X7%!IV~fDG$!u1Fk~CJ>|w#n!%Qykrhnm=hh% zUMgP{ zlfsS@rivJV7?YC9NlWI&h{VFQI5C6IOOD|RliB=)!33^2da_X_DTkfROW;SR2@p$! z&fxIU5errM z$4}<*xf~z|R-=Efd=Drf%rBM0#o-jz;BYtu0QNftzz2Xb9+Bb*s)h)j<_>MugjMa< z`mUXy7RwbztVt_dTNQBJ5zj!IASxb3Rl%2qGI5}YL750B1SkP~b5Mv18t2h)_!4=9 zg5oQs2tjq2hOb{CM+4m;P|zYFLY(hv`8uqaJVF;5md=)2)<1z2C36z z5!H+x{81QpI1fx$u{e>9wm5{ytPgp#$WQdCBC_=z~3DrEuU!EgvA(ZEP; zsx$`F5oZQAaTg}J zUqf!MA%-u65TzyAa!5`%HCv9B<6z_q;h(O68#HM8j*Gih$)Fw zV^Jq92du=PqD&N$)+^8|fk-3=0rlLV9Tygddc) z0n3`w@G#;^QGs@kL_#q%@=PTLtxgjmqEurrEj3gPlD;4!6k}|5#>AiOK?C+sJ7|nq z3ni)*AT;UVq|Kx+ey9Nq%VelwQ^w{VNtDeKC=v<$BvS=eafe1UVJ)&5MUQMw(Is0@ zbjX$zZL$?*I+;$@c#*k%lsH>@X zm@0);Ffxq(pp#J0peBV?Wev2S8h|libtz1hH6TAVAfQ15gcAr_Lp-c0h1LE=mX;J& z|5sVlrLe}o%F>p?n*SPR1n` zHIYyb*$|8{lES)RgcBHHyqjVMfgnMdENB3?SQsfrl-X5C&>Ql*0N7v=;}7kQAm7kw;j9Ap)6$;H!#x%?e9eWE60uW0?nm zf!fxSG=SOsNJub4ItY6D0M@n`Ybp_IGlGaT3gS$$BO){;fCx=8wL=)lK5VwWn6`kA zy)*}m^#fxaTq%xVvW^e~AXI=*8A>sXI!zi;4K;GWQWG`Y7or)XD!@81MyN4R+yJZ; zUw^Q=fIu~%JgnmDkE6=^f>uMY-VCL%(T^oJm7*9RMNO_aDQrBo*kBW2G&QDx>Kjf2 zA#RApN{+E6JYzBi7-K2mpT$R$WdYgZo60=Y5^Qm@WUCZK9jK^31XOqMFF;sQ*c7B2 zOfe}uQ^wW-#0ZvHs8eZ0mSC`)iTMDe02E6^APxCCAU}fY=K&z8t&l?yVx$_4il8)L zQHC)@RmGO4qdbk`g@>KM%z$A7K^!~F!v4oHhDfM0#f6H{XaQ6RixHO}PML>X!o#jo z0T{{zL)}~{9>6Ca5JL$C*$i_9(30warDZ8>hS}HG7&AW+m>D>0Lhu+Zj42WF^CifP|E#>Qc?kk6%-G9fII?PJY^v>3#jMi zN%6$P-m;(!0>OlOQoJD?E=(*82Y+{oOlCx2P>KM}TngD8 zI%WfG91f$;;faAPyggP2KN!Hw++^^DmJ%d#vh5rj4^Rl~F=dGSGxhdd_ zWS$H`3j@1sp%RDw*%cO;vy^j}LRcG4_F-d~vWzcYBA?6?i<7z7cm>&bOnDqPR}8)s ziJWXF%qB^Q*k+imAc4Ssm@N+qCkM8Y1OmHaHUtVllmi7IDoO}E7dGHKx%Xzn5(w;- z*+6HoU1k$O0XmT-gfy2aHI_-_Cl3u0yagMxtfNdeCIgJaPfEl|%o+cK;f)^@@;vL;-z5cxJ1BLUX+?9jN>NZ{B0sc;OJ$; zPhksF)4&1BCQR01lbp;>VMoUa1kv0Kn*?x##7b~N5Zj0*50N&qFysoYxfzN6u?ajJ zPKl7q!r|sD&)D(o*M7-^7WLxYnSM01Wf(T+HVil|Bdi{tO|~ilDe4)sJ$?B+mAK`} z!KEfgt(ZZ}$9|U>-~7$;w%+ZQmwqAM26f{N_McY#x#xq$WnqOAbIBF4+mU6*b*xyO z9*&;5S?NbrZ(W~oZy!mBk1x-ado{kRUH7wisoY3o=ZtoTKeBaHQuNcAJI~Z~uG;T6 zQFAZmMb@{E{iVD!2Q|aptLKgvHCJ5AHyBw*sR{9ra4N1`3;C-h>E61O&0e;Pb65L> z=q$Nr{$(4b+j(7F)W$d4pE!9^G&;mD?r9A1I>{Q$P0XM}%-@_&t+809dnVGZxORVDXXOg~GP|oY~}H zw9PRk7=1`N66Rl~k9(aRSSGO&oBow>gFV*w)nNbXLdGex#-1-vVy`b~Q1yRCII{1z zC&g9m)2)>n7fmFiloPjO&$m{kmh5`1kW;bY6f2@MZ$YifU896Ou0^_?egj!Y)D2!+ zOAare_*Oj2`T727BTY&g;fugzVt$!{pTCkDhy371x(UzTuPRi>qi9C|xC43+*kT}^U@2FJhxs@JN zvE>-?tHfZYRl?Uf#^zUux5ro=&P^62_R%eIJMVtV`@_hhb&>C~PmFx}P2G>%_6@0g z_!^vOSE$$RYg+T#r`p6mFKWy93@;teT0)~l;ge^J#AarU!Lx1BoWq?Dd&fM3*P8L9 zy01=uczC*I|LKdO{ABa)C85&3v$1`DZhYWPoG2WAv*DJ9LA%|yH^wzvb4!{D26D?b zCwfWeoO`#fuh4#7_WEd(u!rl3@Ux)mTKcp1g-iYjj(3eb6yqa*hHhyWXX+hKedgWl zuel&IyVl-pAaPF>x%5mKq7tiC_Uwje+K%_~Pe#i%;^?&mTZe?g^WO@3JHq?Mx*wkZ zcA%!exH;`>Xz&x&Yr9Klr<9JB^qM@~cF(SK^>(v?{D`rfvq@`{iKS;=JFVeVWI5T* z*WTPdt7+keTGXSC*7_~ayffT#{K3Q4Z~JNnLYlXJ4GM0@IQ4npSGN~b;)e!T&(`N8 z>Zo|?l)iE@T^+eMf(OOB&_IjQ1P= z(wH6?ye3h3iRRh^>XH`~D@;$SkbMg`Cns3@Ck-tqKE27$zhy&OzMf}r6X|QZ)evXs z+GFP%s>%Jdi~Ev_&xQ2V$$R!ys=XYoaaF7nd}%Ltk3IJ07;{8L_gs?PP1{E*Bf9JL z59Vdxdlyo#D)CHIJ~19Id~vcn{NwI-np(z>BS%j3D(YD7Z5nMsp4WWyR2eto$`7ZO>w(3dms*Z@3i5oVRwvSEMTF^!00bT^;&B`24MTQ<0#I^K}g z`jBj2Kvzdtcb5A^d`0Sf_wKiNy=E{$P>@rFF-aY0X`x@$Ovi%r4Hw|vw z(t52aU%2qVQ}?qkSM(_@3DK=yLwL`5F1<789yWcYf_=7?qV zgMyy#AJfjMPfMYo;n@>#b)WkI)ft4g`BiyiLxuMonqTZ@E-REDgc{BfPtM%u`Qg&E zvL&xM?Ut4$$+q|A_b%LyQr21x%{Tn*{3c)PH#?8st}3~CVZE7MYgB7w{RzL3%U|{m zT+TLsUt5&^x;Rg1;e4K|Z@JI5GB>%a+BosKVh*u^)9YYm@kt|@&74K8{cI(NA( z?u6V*U8U>KUY>Zcb-Zv_g>Q>UO4^{OLn1>n)IbV?l0z)n9lRI;Xa(d%4{KrcZ~SwQW{K zCO+VuFyHqm*Q)A(H_q8%ysEdH_0VfpRc6_R(B^A)*aZ*tko_*$s{Du-uW65cgcq;Ra-)f7dblsQlwK-N%l89n1Ub zl)zJSa=HBc<`un1Wu}ilr^fm<9zCn^{ueFSt;Eg#&f?FSjl{&n$Gg>bAaC{p}~^?lrC(Lv+{J zb{~E>*f7!e@@2l{X*{p@zE);FzISweSa;quf=!U6)}5&0zAyWy58oc2MZW*+!Q#e( zg0e1oZQ`4g4sUNc9=tQbHtHFV3QIjo?td3i<=osWM_f@;bK=utx8W84Sg4y6Jn~ zQaXK>cZ`OQ$;SEk&@<;EPAv{Em}^~quqTtT(L=eq>`ytdLE4CW*>1fVylq`ZCqLBg zePecAZxch(!c#Wz^!8eCCLj6K?Aqa18WOd9d$qh|=KHaC|U z%dUK^Htifx=<#h0EZ90{)!xOvw5tJilA5z4uZ}7=9eNlL^E{`^U-QIf7xzQGUsrpc zT(iHtQ-8aYW0SkyZw>5rUOdDP12-yg-XL$W91FDc+!0b@P(e2n(zhAp$gsOr5& zzj<}^Wt%_!xh)_46S1!{BgbxT6S@`Oxt>+q zWf5&$c&W@h~I(7EPn8_9#eYfb3}jpJH_^KJ;kU!&ng8{>o; zDn~Vgko3nhEo+w@P5v{ZbJexulo%!0`J#Rx}*W8sYQFg9(ind=( zU%c#N@Y6e0Mdu2(Jupywwbs#v)_o-9@cVX)v-wZgOxrV2w=(?hSjdx|h3iL(U!6w1 z?#=A<+_dLhif44{bI0!AZ8})jZyMuA$?IQ7Ee)#7nfNxQ!}n2Z%*_l)8aSEX&>#1h ze>ZL&>r>1V)&-5}%&+tR*!$Pp#*D12iJ+XO6RT}zx$;1nC86FAcw=Mv4iV(tlfJ0P+P!N4R^;B zP1d4|RYpDS4Mt1ryslTq-IyjWzA`HK<;)Ys(Nop%qSpGGmz;JYfwvbZwXQ~w8SE*@ z8j>%##k4V!Z&fI}wr&A$z*oWQ;*6fB?gZumb~dbK;jS$lV=H&Pc=S>4&@Il}t7e@i zLaj|0n#CV>YbCukx_$a@=Y}GWT`!bYd3_p>ExK)K5_0>%U4^+WpRK*-C^hTMqc`mh zoyF6zP(;IStX}b_5_4yhF5RnXXszJsH|00FU7@&u48J6BF>pH<9K}_p-Uj2Aa^sS? z!sv7t?8*fk{ij}Cr>=cK&+ivMSUb265%Ch1LJ~Rfg3A?3An@oayKGoWkQI|Wh}eth zQYeK1kQgLek^{+=#3aoo1(RGz3rUMei%CmJ@gz1WniNG!AjOhm zNJ~j^Bn~N&6hT@*3L&vbp(HnwC&`QCO+rb&BtMcPPV@h99fQM#gC|`ea~=Tfu9B=j m0d%0n&;Ty`LEs+*uwM=VydNsSxF0Q39q>59|3#aL!~GAA%qh1@6jjac*2j6EFC`SAH51Q9&=6TOE&&=-5?9P66GI4rx z5Q$_rE;c?UF-DUXP9l-31_lOB(U|d4iB6&l;O7)%$Lj)8iBTAyZ1E;@T{+QY97%HR7yBu}-N_Y19H)7N;`1KrYfq6moTjOej(*)NF8O z$P`%xQgMb_qbd+-*m8+9L#&btMR8Iu{+B#MPAgUpJguC<|A1ee8@B^P9hRcT8LR+Vjy|CU2$^NvxO zWFF4~@+2Og1SW&WXMj=iD3F)%s7$Dw#v+j`jTm?uxwe`?vG{{QZj7YX+0Z6p4BQJd zhh%|!VoclvvjnyRwg$Gr-LcWQ8)l2UVs^L-W{ zm@96Jx#6QRciaZ^z^yS)i1C7YZ`=wSgIi)gI1}^5Eigaa9P`H+SimzZ@D9elgaw_z zf^lbZE052D^KIwx*&RUz!rf!fE@x40DAET8!d^V?C?5L@9@CBUp5W1R20or{jz`fg@Nsk|9!a;v z$I`9v2)Z>MPPf6s=%aBi-4^H2?eI{#Jsv`Lz=P?Ico5wQXVYErK)M?qK=;D^>E5^> zeGKkP_rZP0G#@xMCvf09Xk80bCFS0JtIu1aL#Z25?6Z1mJ-n7{C)j2!I!Y zPylZP9Dp$hxBxx~!T@{`gah~?hyd_MFcu&HK_oyRf^h(B1W^D%2*v{hBZvkFLBInD zMGynPK@bbTMGyxNhF}6fID&Y92m})W#vyt7iAtA;;^8wh6#Skl;N*B11|UVlbo`kT{S~f72m_KteHNAejxZ z30PE*{FDTV2F}O84jBDnAcdAnA*be2w5Iw?zmN<*RZ{p+ZU?w6HFfLC%P& ze!k0LLb2)D{>-~a{|q|WYD;>8c1QNxF#f;!MEgF?_RhoH+Ii3cSCWs~9d6bTv!v*Droe9VxY-#1}W>zg63Nff<|p{FD)sjnT^ZKBgIXYXG8qa zf7Tb{La|B>x-_3;6vPf-2Lz+_MWH05Dw;3@t*u-ET2ZK#3x*`FN}yCJL}ImCOD7g0 zkwPWbnn4r-s1qxN;4lS;ut1{_NMuL_=Rv2b!f4hkeMSPkqi?{lSm|+0bR}7S##C) z9Lwio*_CM*LYLFKljqoF&%thGL_X;+qlltROwt1Y%VO5up*UsGS zSm`v1Vs>9xvbeO#KgVgqvYLYxywc6uN6%|@a-e8{<*c4@ud=pI?(UwhZ> zTbuJ;q{#0S$xAl+$}X{FbB}C~Ic6leP{h4n`_+cY1+6cnANG8)MSOh4(Vlz0iAIuk zX`bKKs}oB#JMzbKu>7_4rzTn&i=RnLa(${C`#t1`R&}my`Q+$K2I)6Vww5G)(O1+X zd|hn*EV6vjhT75J*xY~mWb+-}uK#=Jw<+LkENB1h$x%P=SSi{!_4X|9zDEaM{_Qv0 zy6ESk%d9s0vnO~R1IFdj6D=&+_ldQKwmH)m*e5rq%8t~2_vUYM-D~Nkj>C*ioxjOA zx_gpU?sxW-crB^UzPhY%c20MMb*uXOqO+Y3D!KwUzTDM(e!}Vb4GThkpLD#%?feOy zd;AskQ>ANsSaQ?zZi~fUWno4ANtmLy&)4vwqf@|@H{Rvbt(vq&&GU)_%U8C3X?b}4 z@l#me2ji<${p8KI5w8}SZuV|9`|I54?&--onsQ2pO3lkbLVmV*W+vN-QnD>LCph04(^}b{0F+@iyM{> zjJ?s~^XN!V{v7%nrt#yfoQko!uG*t1rWd)B=A8c1A@I>BWfv30DT~wdKJAUaai(%n zhpD7Z+?$n%N7uObe}awATW;PRF>a>EC}ymnLb-N!c$&vH>z_Ml7tb9tNsGEGKJU6(T7%Kzc!mi^9Yxs#da zXCLvlv;XX*#%j*5)6~g39i>kypLNWCKJC{u?JLilmp82bFs*P!+wmJde%G>AUz_p0 zP5NcKgL4~%6@}a9Oq?rQx@6nTmxaeqJ><5{xcl*p7W}EBuk_afwQt=ghsr{4PM%Wi z`RK?`#zotHTsBtuV?WtPmgA2by{WqvxQe% zx(eRkuR8WDnvpqnu5X2AU$38TYUqvleO79>;#bS{DHzD;*s_(>-DPj{QlXV$G`+KqDfY{i9rsX@M1`s~+PmBxAWZpo|( zn^#jOO8({9M*r^XsUQ3HtEp|7OLmF6IZSAx^t8AAuaWRK|&Izn~wwL`S5pMeJRZ-Er z%0QDp(qcAQ-rmW|dC|Mr`w+{db|HDqyoH7{HRV<;QBv3EXB=Yuf8eWHPR4%o)kap} zg|qfY*h{~dce(j=!NNPM?yqCBEsSrPFvA!(mi0?bO?KO)rQBLlJ?@ePT2~b!c;ixZ zXk9hfr>m(*IXbPA$4I1jG|XLev;CGsoYezWu4&b$Yo?U!vUaDnJiY1Ixmw38zH)8; zDSFzG`sge3Bk4Y@j*Io#+MMeLUwA&8`P+n(W9Mzk+&;GU^F7UH<~Cg3vSlq@mHOF) zna8dsbk;?>OLJES1n&8;#AQnzWnTbo)I?kSqY2g2>0P%+wVys{=566U>C29lTN6&2 zd{K4oryctr7pL!=BX75uiO0K8cl+MCrNuwXypUN?KQe2UibG=EFj{SS^uoZJ~N>7-t9dYKl7 zagJ=S3_kO);?Wf*rzKZ5X&^hU71u==K0oK&Bb)x6U#^>#hpAC<>ZdV|i`#;}PcJgB zYrg$$>Y@dQE^<#=Ze=9rta#E?DwDSDKCp2kCGq>*ilxgv>!`v@RpOHc>~HpzF6wFj z+2O*jp7s-;^MBY!{py1`EjM4@-L2WPD9S(n!PWZfVJWf`dn*FJZMerDxc;oB>C~V6 zuX8^*}OtUV?J@ban3pB(X_Sa;x^5y&xx!r-A_Rm z%Jf;eolQZF_Ydx`uWD^rY)Ye@+i7O)Xum2sIjAee`$X*3`F#RX#3JkuUdP2u<2~BZ z(V;Dy?%y!pd+YZxzebDBt`A9meYC~wKz{nd)s*7?a~U}?FYBEe3Z3^A7oPad(vE9l zR4DPZIq)%kOmw}CyL49`_o?*!*PZL}P~6%1$5K{_anZxf9&xs=s=>u|w^z)u_2ahO zvN=(caiCjr<5I&lqq*TC7Ik;FUWgnp;WmD15wD8_A!fuu!q8kyY`+Oaxnfbi zSS2V7*T5YL5@l#_ZRj%zBH#N^LV;v0RV~TMrD_df!w&Y=kZaIyAk-*i(9Ezv4(bQ_ z+_VNrPv=1_+8xW&BJB)0DB?U2^`O0x0g;FdY%Q95?6(~4jMcoFoT~Us0f;N(6ICJi1Ep#{5MQ6E}-Q9zhN4@gA6qV zN~t)Pn)%nURpnYEkyN1;XQ82^4AvWEN;EQ|Qb>EJmJ8=u88ks33jvXm`Kwkee@OM|5Bl&u=qs{Lm&_nOG`@=?G7x4guyp*q>F+bB;jN-gA>dpld~y8A)gT>5<&tVmCNQaSWq?% z;_)FWMF`PKAPJAl7YfL1+Kz-^5r-;da5;iNHigRP3W&fM$mY^SEGSSQM9uN8t+~4B`7Aci6}; z`An~Ff;w6I7GOZ4Tn7~HmK zQnaTi2;v`z5M7GSaVXt^B-+-a@km=+9GKm09T7kT+B#x^;Mt}00uGHpcnSI5@W!3kJXmfAkOEKuSOtIrfX}7~fCRt;;J)hLVvyjj!nw8p z(f|YiI2O)_-`J34adj>z-z!d%9$aA>+A)92W;1hWWibpN-X#9Q>7rmwe<3{ zqac~Uzb29mX6(@HG5rXuKT2rrzh5X^)O2*_QsH{={^9ycUnPDw=tH1yTCNS(LLU=w z;B}B3EJD-YZ{#pk2F`mtz4|S|L z7w~&j8E#0;<&qP1xG{w)u3oZoC8r4kum^&-$laqVVSc^BySg?IN-(x~bh_65uxqSZ zSy{y8ByPv}x=ke8Rg@y{vlGo74hISYfBnJc$&MMkw+fYbm8a58(r#3?N14yN6Shs* zs`hpnUaYvQc_%O;CP76Ql+Ix(uY-Zgd#={SR`n9{H1_4yjm9YJp7%7np3(Y? z1z~f$PIX@9gW^^;{jcc#NbcOn$*i3xNA!t)qN)Bj(O&M={q5Bsgbz3d(QWdQ=cat~ zUv{nS*^u?D=O?;C!EoBXv{#IgrGtBB=B$gAnE26bSKQSsU7}6$hJ)P@?tb~J$KsKAuQ!A0SHe12J#@$M z^w@jls4oBUm~J;tyv5ilRkHT3+lrhE(_2U1DYtf>ygDJiqmuky@oIgGO~}u;<|@N> zm%M6HuK7WtP3Ijq815fDDKVu_6~A;@#NSXv=Y#gP=TZfr$(!L`!aS0svr`7*`s@i$ z#g+cCH5wc&?>M1MOE2!8d=9DD|CUl;ZFp>fJE!1TX7|&NtVv}PlQ?|G-d$4h4V_aP z)0N#y)!9Zv66@zjUhH%0bZW%} zK~5(va8UKCxF$a{Bg^X4oE^c}`u$9untsJdsn4*orEcuVBH>mf$)b*^w==z9%Uz|;CbHOW?Q7l;677DIPcpa1Y*c5V)~`F`l2pI@zhYTb%A9n8V9Fr;hfbsKf_W+n;h3&XQ=>wYMx{udO;UaY z6_=H)VkhipW34B;g_YdO#{IvrF(_oTM`(az$mJT64{KeYLGaG=e!uyf>zQosDSUq7 zs(qbw%a(Pqj=0u5V$CG&hLfA!i_Pb{Wu1=e3v(Ow3idFEZ%dnV-^$L5>Sr!GZM{yo z>1+3{mYND3Zt;-SyMB44UVUZw6oUUyP5uf6qorKr%o+&GxqW})t?%BwrU!HTnv#+d zY0h%;ht3r1mC!_IUe5PKtx^qG)EH>InVfg&DGA5IRqB17owZr)rzGg*7h*DxbfQn| zG~aQ1YJ#U7G>yuza=7g&`>C(uk*l>b9T&fVFFjvjcrGz7&iG7{#dPbT`-hEv z`_wI!?=|!>538v?5qpa!?`!WqeRpkFGq3x!uiaFK>-dCxo%(CA#!G>}}}1wB>wv!E0pRpXqPTJ+Ly&5T6S zrK&fr%=!#D!nrFhZ%O+nn@d~<4$9nOJKKwYO3k=I%wi)#g##E$ZI?^_*PY(OI~JB;?N(fNz?E#4Z$w-y*>;R}os~uViWnL=A=b z4u#F2el>=`H0K+w`G1Qs#ZrL4LSmVJ&Vq0T>=o=!58&I70m?G>!mY4ap@UfU WJ!Jq+@8di;M-Bkygh=%z1mbUa@x+z@ literal 0 HcmV?d00001 diff --git a/gguf_ex/_build/test/lib/gguf_ex/ebin/gguf_ex.app b/gguf_ex/_build/test/lib/gguf_ex/ebin/gguf_ex.app new file mode 100644 index 0000000..ded8731 --- /dev/null +++ b/gguf_ex/_build/test/lib/gguf_ex/ebin/gguf_ex.app @@ -0,0 +1 @@ +{application,gguf_ex,[{modules,['Elixir.GgufEx','Elixir.GgufEx.ExpertMap','Elixir.GgufEx.File','Elixir.GgufEx.Parser','Elixir.GgufEx.Tensor','Elixir.GgufEx.TestSupport.Builder','Elixir.GgufEx.Types']},{optional_applications,[]},{applications,[kernel,stdlib,elixir,logger]},{description,"Pure-Elixir GGUF (v2/v3) parser: metadata, tensor infos, and absolute tensor byte layout without loading tensor data."},{registered,[]},{vsn,"0.1.0"}]}. \ No newline at end of file diff --git a/gguf_ex/tmp/GgufExTest/test-alignment-handling-data-offset-and-tensor-offsets-respect-non-default-alignments-bbd0715e/align_1.gguf b/gguf_ex/tmp/GgufExTest/test-alignment-handling-data-offset-and-tensor-offsets-respect-non-default-alignments-bbd0715e/align_1.gguf new file mode 100644 index 0000000000000000000000000000000000000000..e7b9301c6474a43a402448a91232d1ee818628a9 GIT binary patch literal 179 zcmZ>F4|QW^U|?VZVi17Qf)Fl4dTL&3QDTl>VoqjyUT$h$2@6ny5sE=-Dmaihl`!ok Y1|T&cgV6z8g&{}F4|QW^U|?VZVi17Qf)Fl4dTL&3QDTl>VoqjyUT$h$2@6o70f-r)3Mx2|IF&H% cB?cgQkiqBxuEG$cf)z=+0f{}zq*Dk00Dxf&V*mgE literal 0 HcmV?d00001 diff --git a/gguf_ex/tmp/GgufExTest/test-alignment-handling-data-offset-and-tensor-offsets-respect-non-default-alignments-bbd0715e/align_16.gguf b/gguf_ex/tmp/GgufExTest/test-alignment-handling-data-offset-and-tensor-offsets-respect-non-default-alignments-bbd0715e/align_16.gguf new file mode 100644 index 0000000000000000000000000000000000000000..75babb1eb509d776be2ee638552690e886cb88bc GIT binary patch literal 208 zcmZ>F4|QW^U|?VZVi17Qf)Fl4dTL&3QDTl>VoqjyUT$h$2@6m{0Eii(3Mx2|IF&H% YB?cgQkiqBxuEG$cf)z;`WGck~0GIy?g8%>k literal 0 HcmV?d00001 diff --git a/gguf_ex/tmp/GgufExTest/test-alignment-handling-data-offset-and-tensor-offsets-respect-non-default-alignments-bbd0715e/align_4096.gguf b/gguf_ex/tmp/GgufExTest/test-alignment-handling-data-offset-and-tensor-offsets-respect-non-default-alignments-bbd0715e/align_4096.gguf new file mode 100644 index 0000000000000000000000000000000000000000..219bd49206589566e9e88beb54ddbfabd4c415a1 GIT binary patch literal 12288 zcmeIu%LxK85CG8e2OhN%(I(sqEMN~|5!M`J58Ay6nnlDC-atqu^Ete(yPQ`Mu`H)X zyZ7%jhLqF29}oR_9r7*ZXF4|QW^U|?VZVi17Qf)Fl4dTL&3QDTl>VoqjyUT$h$2@6od0f-r)3Mx2|IF&H% ZB?cgQkiqBxuEG$cf)z>H0f{|im;i;E3gZ9( literal 0 HcmV?d00001 diff --git a/gguf_ex/tmp/GgufExTest/test-alignment-handling-data-offset-and-tensor-offsets-respect-non-default-alignments-bbd0715e/align_8.gguf b/gguf_ex/tmp/GgufExTest/test-alignment-handling-data-offset-and-tensor-offsets-respect-non-default-alignments-bbd0715e/align_8.gguf new file mode 100644 index 0000000000000000000000000000000000000000..686b03f25402fa67ab95da3b1cdba5de77393ae5 GIT binary patch literal 192 zcmZ>F4|QW^U|?VZVi17Qf)Fl4dTL&3QDTl>VoqjyUT$h$2@6ny1Be-+3M!B}l`!ok Y1|WHm!RP?4!Vsi_6-inEiA^*U0PAQ9djJ3c literal 0 HcmV?d00001 diff --git a/gguf_ex/tmp/GgufExTest/test-expert_map-1-MoE-metadata-without-fused-tensors-4b69cbab/hollow.gguf b/gguf_ex/tmp/GgufExTest/test-expert_map-1-MoE-metadata-without-fused-tensors-4b69cbab/hollow.gguf new file mode 100644 index 0000000000000000000000000000000000000000..35c57c05bbc44690ac46a8673e7fe159c23c34e2 GIT binary patch literal 288 zcmZ>F4|QW^U|?VbVh~`0Pz)kaIz2TnwJ0%1FR>^&BeNtmxumoxl>;aTQ=iKRRhX-n yT2YW%R1%+@Uz%6K0u%))6NJi^F4|QW^U|?VbVh~`0Pz)kaIz2TnwJ0%1FR>^&BeNtmxumoxl>;aTQ=iKRRhX-n zT2YW%R1%+@Uz%6K0u%)qB>|O9%E{I<&`V3pi!UvR2P!PqD^JZ#&nN*|4N?mNFdF6r Ii0B|E0j3cc)c^nh literal 0 HcmV?d00001 diff --git a/gguf_ex/tmp/GgufExTest/test-expert_map-1-dense-model-returns---error,--not_moe--8120b491/dense.gguf b/gguf_ex/tmp/GgufExTest/test-expert_map-1-dense-model-returns---error,--not_moe--8120b491/dense.gguf new file mode 100644 index 0000000000000000000000000000000000000000..f23d9e0af38b6b64346a3f7edab2367e612797e7 GIT binary patch literal 256 zcmZ>F4|QW^U|?VbVi17QA`mV^dTL&3QDTl>Vo`ENW=U#tNoi3k2T+a`DxZ^+n42gF i<&@-Sr{=|{<|d`+m8WK=XOu7jB|xe{fCWMgG7F4|QW^U|?VbVh~`0Pz)kaIz2TnwJ0%1FR>^&BeNtmxumoxl>;aTQ=iKRRhX-n zT2YW%R1%+@Uz%6K0u%))lYq)5F4|QW^KmaBvQv^z0u3{DCF5!4dV literal 0 HcmV?d00001 diff --git a/gguf_ex/tmp/GgufExTest/test-expert_map-1-maps--layer,-expert--to-contiguous-per-projection-ranges-9c6a7ebb/moe.gguf b/gguf_ex/tmp/GgufExTest/test-expert_map-1-maps--layer,-expert--to-contiguous-per-projection-ranges-9c6a7ebb/moe.gguf new file mode 100644 index 0000000000000000000000000000000000000000..6b1aa6c42014c0290cf22356132c9cd377003195 GIT binary patch literal 13024 zcmeIuv2MaJ5XSL{R)VpWIv}QwOcuOEd4kSS2uDDW1ci&}$fIK`XEl_iVg6f+tR&~p zcfZx@`|Bl1lCgin8g*OpVS6E!G}+N*O}^W!;M9+`?_QRob3Xf5X|%hyLUFH>>UE zTWiQ0zNgqr?Cq{6``Mpu`OIt<(C?_r89du($Mcvpc(%Dg zvmt;00tg_000IagfB*srAboVs(BI0oVs(BI0F4|QW=U|?VbVh}*5vsr+GT1XNlAQb{Y3<5CK5FR-s0QX`7PXGV_ literal 0 HcmV?d00001 diff --git a/gguf_ex/tmp/GgufExTest/test-parse-1-round-trip-parses-a-v3-file-with-all-KV-value-types-and-two-tensors-5c283608/basic.gguf b/gguf_ex/tmp/GgufExTest/test-parse-1-round-trip-parses-a-v3-file-with-all-KV-value-types-and-two-tensors-5c283608/basic.gguf new file mode 100644 index 0000000000000000000000000000000000000000..06d7d7cbc330681150b020493f19cda56ca5e95f GIT binary patch literal 768 zcmd5(J5B>J5cMWN!l$6%0F+cKWp`zzgNmGhI@%=Otc8`899y{p$D%``;U@GnEc1*9 zt(6Nfl07qT-u&#v;^}cLgc#9*T>mO@6ZKZ@l&wu(+jXm*T03vmlwv0_?$q8*26pb} z@cIPP^Ng@B=`Y*)iUPk&`-JRu?f}&<06N%Zh8z66qF=tgbjuj2_qyd)L-3Y3_51V|Hu{ z!2^9$9r#E5y|dt>KmSwMoBUQ8)3I~ttl98Xq1%q0T5XVw!^vd+*;xS59x~<~>-?bf cwsnZ|Uk}p*n=a Date: Mon, 2 Nov 2026 08:41:54 -0500 Subject: [PATCH 06/49] Model.load: default to upstream's auto load mode (no forced mmap on iGPUs, +17% decode on GB10); docs --- CHANGELOG.md | 11 +++++++ bench/spark_overhead.exs | 5 ++- bench/spark_spec.exs | 25 ++++++++++----- c_src/llama_cpp_ex/llama_nif.cpp | 24 +++++++-------- docs/dgx-spark.md | 19 +++++++----- docs/performance.md | 13 +++++--- lib/llama_cpp_ex/model.ex | 53 ++++++++++++++++++++++++-------- lib/llama_cpp_ex/nif.ex | 4 +-- lib/llama_cpp_ex/server.ex | 5 +-- scripts/spark/e2e.exs | 50 ++++++++++++++++++++++-------- test/option_forwarding_test.exs | 23 ++++++++++++++ 11 files changed, 168 insertions(+), 64 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 0c9c10c..35c08a8 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -21,6 +21,17 @@ numbers behind the entries below. ### Fixed +- `LlamaCppEx.Model.load/2` no longer forces `mmap`. `:use_mmap` defaulted to + `true`, which mapped to an explicit `LLAMA_LOAD_MODE_MMAP` and overrode + upstream's default `auto` — the mode that skips mmap on integrated GPUs + (#26081). On DGX Spark (GB10) a forced mmap left most gpt-oss-120b loads + decoding at 48.5 tok/s instead of 57 (+17.6%; an `nsys` profile shows the + same kernels running ~22% longer), and about one load in five came out fast, + which is why single benchmark runs disagreed. With `:use_mmap`, + `:use_mlock` and `:use_direct_io` all unset the mode is now `auto`; any of + them given resolves as before. Metal, CPU and discrete CUDA devices support + mmap, so `auto` maps there exactly as the old default did. The NIF's + `model_load` now takes the resolved mode instead of three booleans. - `LlamaCppEx.RPC.add_server/1`, `ping/1` and `Model.load/2`'s `:rpc_servers` aborted the VM on an RPC build when the endpoint was unreachable, unparseable, not an RPC worker, or spoke another protocol diff --git a/bench/spark_overhead.exs b/bench/spark_overhead.exs index 0b121c0..79c04b7 100644 --- a/bench/spark_overhead.exs +++ b/bench/spark_overhead.exs @@ -38,7 +38,10 @@ defmodule Overhead do def median([_ | _] = xs) do s = Enum.sort(xs) n = length(s) - if rem(n, 2) == 1, do: Enum.at(s, div(n, 2)), else: (Enum.at(s, div(n, 2) - 1) + Enum.at(s, div(n, 2))) / 2 + + if rem(n, 2) == 1, + do: Enum.at(s, div(n, 2)), + else: (Enum.at(s, div(n, 2) - 1) + Enum.at(s, div(n, 2))) / 2 end # Consumes an enumerable of chunks and returns {tokens_after_first, seconds}. diff --git a/bench/spark_spec.exs b/bench/spark_spec.exs index f527587..7a8f30c 100644 --- a/bench/spark_spec.exs +++ b/bench/spark_spec.exs @@ -44,26 +44,33 @@ defmodule Spec do def median(xs) do s = Enum.sort(xs) n = length(s) - if rem(n, 2) == 1, do: Enum.at(s, div(n, 2)), else: (Enum.at(s, div(n, 2) - 1) + Enum.at(s, div(n, 2))) / 2 + + if rem(n, 2) == 1, + do: Enum.at(s, div(n, 2)), + else: (Enum.at(s, div(n, 2) - 1) + Enum.at(s, div(n, 2))) / 2 end # {text, tokens_after_first / seconds} def run(enum) do {pieces, first, last, n} = Enum.reduce(enum, {[], nil, nil, 0}, fn - {:error, reason}, _ -> raise "generation failed: #{inspect(reason)}" + {:error, reason}, _ -> + raise "generation failed: #{inspect(reason)}" + piece, {acc, f, _, n} when is_binary(piece) -> now = System.monotonic_time(:microsecond) {[piece | acc], f || now, now, n + 1} end) - {pieces |> Enum.reverse() |> IO.iodata_to_binary(), (n - 1) * 1_000_000 / max(last - first, 1)} + {pieces |> Enum.reverse() |> IO.iodata_to_binary(), + (n - 1) * 1_000_000 / max(last - first, 1)} end end opts = [max_tokens: n_gen, temp: 0.0] IO.puts("target: #{Path.basename(target)}\n") + IO.puts( "| config | median t/s | range | vs plain | acceptance | output == plain | ms/iter draft / verify / ckpt / sample / other |" ) @@ -75,14 +82,18 @@ IO.puts("|---|---|---|---|---|---|---|") {runner, cleanup, label} = case String.split(config, ":", parts: 3) do ["plain"] -> - {fn prompt -> Spec.run(LlamaCppEx.stream(model, prompt, Keyword.put(opts, :n_ctx, 4096))) end, - fn -> nil end, "plain"} + {fn prompt -> + Spec.run(LlamaCppEx.stream(model, prompt, Keyword.put(opts, :n_ctx, 4096))) + end, fn -> nil end, "plain"} [type, n | rest] -> draft = case rest do - [path] -> elem(LlamaCppEx.load_model(path, n_gpu_layers: -1, load_mtp: type == "mtp"), 1) - [] -> nil + [path] -> + elem(LlamaCppEx.load_model(path, n_gpu_layers: -1, load_mtp: type == "mtp"), 1) + + [] -> + nil end {:ok, mtp} = diff --git a/c_src/llama_cpp_ex/llama_nif.cpp b/c_src/llama_cpp_ex/llama_nif.cpp index 395df6a..e8ec29f 100644 --- a/c_src/llama_cpp_ex/llama_nif.cpp +++ b/c_src/llama_cpp_ex/llama_nif.cpp @@ -956,25 +956,23 @@ LLAMA_NIF(device_list, ERL_NIF_DIRTY_JOB_IO_BOUND); // --- Model --- std::variant>, fine::Error> -model_load(ErlNifEnv* env, std::string path, int64_t n_gpu_layers, bool use_mmap, +model_load(ErlNifEnv* env, std::string path, int64_t n_gpu_layers, int64_t load_mode, int64_t main_gpu, int64_t split_mode, std::vector tensor_split, - bool use_mlock, bool use_direct_io, bool vocab_only, bool check_tensors, + bool vocab_only, bool check_tensors, bool load_mtp, std::vector device_names) { + if (load_mode < LLAMA_LOAD_MODE_AUTO || load_mode > LLAMA_LOAD_MODE_DIRECT_IO) { + return fine::Error("invalid load_mode " + std::to_string(load_mode)); + } auto params = llama_model_default_params(); params.n_gpu_layers = static_cast(n_gpu_layers); params.main_gpu = static_cast(main_gpu); params.split_mode = static_cast(split_mode); - // Upstream collapsed the use_mmap/use_mlock/use_direct_io booleans into a - // single llama_load_mode enum. Direct I/O still wins over everything else, - // but mlock no longer implies mmap: b10173 redefined LLAMA_LOAD_MODE_MLOCK - // as mlock *without* mmap and added LLAMA_LOAD_MODE_MMAP_MLOCK for the - // combination, so :use_mlock and :use_mmap are both honoured rather than - // the former silently forcing a memory map. - params.load_mode = use_direct_io ? LLAMA_LOAD_MODE_DIRECT_IO - : use_mlock && use_mmap ? LLAMA_LOAD_MODE_MMAP_MLOCK - : use_mlock ? LLAMA_LOAD_MODE_MLOCK - : use_mmap ? LLAMA_LOAD_MODE_MMAP - : LLAMA_LOAD_MODE_NONE; + // Resolved from :use_mmap / :use_mlock / :use_direct_io by + // LlamaCppEx.Model.load/2. LLAMA_LOAD_MODE_AUTO (none of them given) is + // upstream's default and the one that matters on an iGPU: it skips mmap + // there (#26081), and an explicit mmap on GB10 left most loads decoding + // ~15% slower. + params.load_mode = static_cast(load_mode); params.vocab_only = vocab_only; params.check_tensors = check_tensors; // Upstream defaults this to false so that non-speculative callers do not pay diff --git a/docs/dgx-spark.md b/docs/dgx-spark.md index f552722..218acf1 100644 --- a/docs/dgx-spark.md +++ b/docs/dgx-spark.md @@ -280,7 +280,7 @@ And the settings that do **not** matter, each of which looks like it should: |---|---| | `flash_attn` | leave `:auto` — it is already on, and `:disabled` costs 24% of prefill | | `type_k` / `type_v` | leave f16. Quantizing the KV cache **loses** 2–7% and buys nothing: there is no separate VRAM to free | -| `use_mlock`, `use_direct_io` | leave off. Both cost 3–4%; "pinned in RAM" and "resident on the GPU" are the same DRAM here | +| `use_mmap`, `use_mlock`, `use_direct_io` | **leave all three unset.** Upstream's `auto` then reads the file instead of mapping it on this iGPU. A forced `use_mmap: true` — the binding's default before this run — left most gpt-oss-120b loads decoding at 48.5 tok/s against 57 with `auto`, `use_mmap: false` or `use_direct_io: true`; about one forced-mmap load in five came out fast, so single-load comparisons from before (this row used to say mlock and dio cost 3–4%) are not reliable | | `n_batch`, `n_ubatch` | no measurable effect; the default is fine | | cpuidle / `idle=poll` | **no effect**, single-node or two-node. See below | | `taskset -c 5-9,15-19` | hygiene, not speed. But never use `-c 0-9` — those are the little cores | @@ -591,17 +591,20 @@ This is load-bearing, not hygiene. ### The headline: a model that does not fit on one node Qwen3-235B-A22B Q4_K_M, **142.1 GB** of weights against 130.0 GB of unified -memory per node. 512-token prompt, 32 decode steps. +memory per node. 32 decode steps. -| run | load s | TTFT ms | prefill t/s | decode t/s | worker RSS | -|---|---|---|---|---|---| -| single-node, mmap overflow | — | — | — | — | **global OOM, killed `avahi-daemon`** | -| two-node 50/50, RDMA | 538.4 | 1281.9 | 423.5 | **13.69** | 344 → 580 MiB | +| run | prompt | load s | TTFT ms | prefill t/s | decode t/s | worker RSS | +|---|---|---|---|---|---|---| +| single-node, mmap overflow | — | — | — | — | — | **global OOM, killed `avahi-daemon`** | +| two-node 50/50, RDMA, b10362 (sequential) | 512 | 538.4 | 1281.9 | 423.5 | 13.69 | 344 → 580 MiB | +| two-node 50/50, RDMA, `785322d17` (pipelined) | 1024 | 575.2 | 1432.5 | **760.3** | 11.67 | 348 → 628 MiB | There is no percentage to quote here, and that is the point: on one Spark this model does not run slowly, it takes the machine's memory out from under the OOM -killer. On two it runs at **13.7 tokens/s**, which is a usable interactive speed -for a 235B model. +killer. On two it runs at **12–14 tokens/s**, which is a usable interactive speed +for a 235B model, and with pipelining its prefill is 1.8× what it was. (The +decode gap between the two rows is within the load-to-load spread described +under the control below.) The cold load is nine minutes, because ~71 GB of weights cross the fabric. Budget for it, keep the worker's tensor cache on, and do not restart casually. diff --git a/docs/performance.md b/docs/performance.md index 296f93f..030f831 100644 --- a/docs/performance.md +++ b/docs/performance.md @@ -276,17 +276,20 @@ Additional options when loading models: ```elixir {:ok, model} = LlamaCppEx.load_model("model.gguf", n_gpu_layers: -1, # Offload all layers to GPU - use_mmap: true, # Memory-map file (default, faster loading) - use_mlock: true, # Pin in RAM (prevent swapping); implies use_mmap + use_mmap: true, # Memory-map the file (unset: llama.cpp decides) + use_mlock: true, # Pin in RAM (prevent swapping) use_direct_io: false, # Bypass page cache check_tensors: true # Validate tensor data (debugging) ) ``` These three flags resolve to llama.cpp's single `load_mode` enum, with -`use_direct_io` > `use_mlock` > `use_mmap` precedence (`dio`, `mlock`, `mmap`, -or `none` when all are false). Only one mode is ever active, so combining them -is not additive. +`use_direct_io` > `use_mlock` > `use_mmap` precedence (`dio`, `mmap_mlock` or +`mlock`, `mmap`, `none`). Only one mode is ever active, so combining them is +not additive. With none of them given the mode is upstream's `auto`, which +memory-maps except on integrated GPUs, where it reads the file instead; on +DGX Spark's GB10 that is worth ~15% of decode on large models against a forced +`use_mmap: true`. Leave them unset unless you have a reason. ## Complete Optimization Example diff --git a/lib/llama_cpp_ex/model.ex b/lib/llama_cpp_ex/model.ex index 91b7c63..cc7a0d5 100644 --- a/lib/llama_cpp_ex/model.ex +++ b/lib/llama_cpp_ex/model.ex @@ -47,15 +47,17 @@ defmodule LlamaCppEx.Model do * `:n_gpu_layers` - Number of layers to offload to GPU. Use `-1` for all layers. Defaults to `99` (offload all layers). - * `:use_mmap` - Whether to memory-map the model file. Defaults to `true`. + * `:use_mmap` - Memory-map the model file (`true`) or read it (`false`). + Unset by default, which leaves the choice to llama.cpp — see "Load mode" + below. * `:main_gpu` - GPU device index for single-GPU mode. Defaults to `0`. * `:split_mode` - How to split the model across devices: `:none`, `:layer`, `:row` or `:tensor`. Defaults to `:none`. Only `:none` and `:layer` are generally usable at this llama.cpp version — see the note below. * `:tensor_split` - List of floats specifying the proportion of work per GPU (e.g. `[0.5, 0.5]` for two GPUs). Defaults to `[]`. - * `:use_mlock` - Pin model memory in RAM to prevent swapping. Implies `:use_mmap`. - Defaults to `false`. + * `:use_mlock` - Pin model memory in RAM to prevent swapping. Combined with + `:use_mmap` unless that is `false`. Defaults to `false`. * `:use_direct_io` - Bypass page cache when loading (takes precedence over mmap). Defaults to `false`. * `:vocab_only` - Load vocabulary and metadata only, skip weights. Defaults to `false`. @@ -101,10 +103,15 @@ defmodule LlamaCppEx.Model do > > llama.cpp collapsed its three loading booleans into one `load_mode` enum, so > these options resolve to a single mode. `:use_direct_io` takes precedence - > over everything and selects `dio`; otherwise `:use_mlock` and `:use_mmap` - > combine — both true selects `mmap_mlock`, `:use_mlock` alone selects `mlock` - > (read into anonymous memory, no mapping), `:use_mmap` alone selects `mmap`, - > and all false selects `none`. + > over everything and selects `dio`; otherwise `:use_mlock` selects + > `mmap_mlock`, or `mlock` (read into anonymous memory, no mapping) with + > `use_mmap: false`; `use_mmap: true` alone selects `mmap` and + > `use_mmap: false` alone `none`. With none of the three given, the mode is + > upstream's `auto`: mmap, except on devices that do not support it — an + > integrated GPU such as DGX Spark's GB10 — where the file is read instead + > (llama.cpp #26081). On GB10 a forced `mmap` left most loads of + > gpt-oss-120b decoding ~15% slower (48.5 against 57 tok/s), so leave these + > unset unless you have measured otherwise. > #### Untrusted models {: .warning} > @@ -126,12 +133,17 @@ defmodule LlamaCppEx.Model do @spec load(String.t(), keyword()) :: {:ok, t()} | {:error, String.t()} def load(path, opts \\ []) do n_gpu_layers = Keyword.get(opts, :n_gpu_layers, 99) - use_mmap = Keyword.get(opts, :use_mmap, true) + + load_mode = + resolve_load_mode( + Keyword.get(opts, :use_mmap), + Keyword.get(opts, :use_mlock, false), + Keyword.get(opts, :use_direct_io, false) + ) + main_gpu = Keyword.get(opts, :main_gpu, 0) split_mode = Keyword.get(opts, :split_mode, :none) |> encode_split_mode() tensor_split = Keyword.get(opts, :tensor_split, []) - use_mlock = Keyword.get(opts, :use_mlock, false) - use_direct_io = Keyword.get(opts, :use_direct_io, false) vocab_only = Keyword.get(opts, :vocab_only, false) check_tensors = Keyword.get(opts, :check_tensors, false) load_mtp = Keyword.get(opts, :load_mtp, false) @@ -151,12 +163,10 @@ defmodule LlamaCppEx.Model do LlamaCppEx.NIF.model_load( path, n_gpu_layers, - use_mmap, + load_mode, main_gpu, split_mode, tensor_split, - use_mlock, - use_direct_io, vocab_only, check_tensors, load_mtp, @@ -166,6 +176,23 @@ defmodule LlamaCppEx.Model do end end + # llama_load_mode values (llama.h). `nil` for :use_mmap means the caller did + # not choose, and only then is the result upstream's AUTO. + @load_mode_auto -1 + @load_mode_none 0 + @load_mode_mmap 1 + @load_mode_mlock 2 + @load_mode_mmap_mlock 3 + @load_mode_direct_io 4 + + @doc false + def resolve_load_mode(_use_mmap, _use_mlock, true), do: @load_mode_direct_io + def resolve_load_mode(false, true, _), do: @load_mode_mlock + def resolve_load_mode(_use_mmap, true, _), do: @load_mode_mmap_mlock + def resolve_load_mode(true, _, _), do: @load_mode_mmap + def resolve_load_mode(false, _, _), do: @load_mode_none + def resolve_load_mode(nil, _, _), do: @load_mode_auto + defp register_rpc_servers([]), do: :ok defp register_rpc_servers(endpoints) do diff --git a/lib/llama_cpp_ex/nif.ex b/lib/llama_cpp_ex/nif.ex index ecb9ac1..58efad0 100644 --- a/lib/llama_cpp_ex/nif.ex +++ b/lib/llama_cpp_ex/nif.ex @@ -39,12 +39,10 @@ defmodule LlamaCppEx.NIF do def model_load( _path, _n_gpu_layers, - _use_mmap, + _load_mode, _main_gpu, _split_mode, _tensor_split, - _use_mlock, - _use_direct_io, _vocab_only, _check_tensors, _load_mtp, diff --git a/lib/llama_cpp_ex/server.ex b/lib/llama_cpp_ex/server.ex index c682421..5484b58 100644 --- a/lib/llama_cpp_ex/server.ex +++ b/lib/llama_cpp_ex/server.ex @@ -314,8 +314,9 @@ defmodule LlamaCppEx.Server do `:main_gpu`, `:split_mode`, `:tensor_split`, `:use_mmap`, `:use_mlock`, `:use_direct_io`, `:check_tensors` and `:rpc_servers`. The three load flags collapse into llama.cpp's single `load_mode`: `:use_direct_io` wins - outright, otherwise `:use_mlock` and `:use_mmap` combine; see - `LlamaCppEx.Model.load/2`. `:rpc_servers` registers remote endpoints before + outright, otherwise `:use_mlock` and `:use_mmap` combine, and with none + given llama.cpp chooses; see `LlamaCppEx.Model.load/2`. `:rpc_servers` + registers remote endpoints before the load so their devices can hold part of the model — see `LlamaCppEx.RPC`, including the caveat that a peer failure aborts the VM. * GenServer options like `:name`. diff --git a/scripts/spark/e2e.exs b/scripts/spark/e2e.exs index 065fc04..66e67d3 100644 --- a/scripts/spark/e2e.exs +++ b/scripts/spark/e2e.exs @@ -23,7 +23,10 @@ home = System.user_home!() big = System.get_env("SPARK_E2E_BIG") || - Path.join(home, "models/esatapedico/Qwen3.8-27B-NVFP4-MTP-GGUF/main/Qwen3.8-27B-NVFP4-MTP-MID-HIGH.gguf") + Path.join( + home, + "models/esatapedico/Qwen3.8-27B-NVFP4-MTP-GGUF/main/Qwen3.8-27B-NVFP4-MTP-MID-HIGH.gguf" + ) moe = System.get_env("SPARK_E2E_MOE") || @@ -157,6 +160,7 @@ defmodule E2E do def mem_gb do {out, 0} = System.cmd("free", ["-b"]) [_, total, used | _] = out |> String.split("\n") |> Enum.at(1) |> String.split() + "#{Float.round(String.to_integer(used) / 1.0e9, 1)} / #{Float.round(String.to_integer(total) / 1.0e9, 1)} GB used" end end @@ -173,23 +177,32 @@ case System.argv() do E2E.step("CUDA0 is the GPU and reports unified memory", fn -> case Enum.find(LlamaCppEx.devices(), &(&1.backend == "CUDA")) do - %{name: "CUDA0", type: :igpu} = d -> {:ok, "#{d.description}, #{div(d.memory_total, 1_000_000_000)} GB"} - other -> {:error, inspect(other)} + %{name: "CUDA0", type: :igpu} = d -> + {:ok, "#{d.description}, #{div(d.memory_total, 1_000_000_000)} GB"} + + other -> + {:error, inspect(other)} end end) E2E.step("load NVFP4 27B (server, n_parallel 4)", fn -> - {:ok, _} = ModelManager.load("big", {:path, big}, n_gpu_layers: -1, n_parallel: 4, n_ctx: 16_384) + {:ok, _} = + ModelManager.load("big", {:path, big}, n_gpu_layers: -1, n_parallel: 4, n_ctx: 16_384) + {:ok, Path.basename(big)} end) E2E.step("load Qwen3-30B-A3B MoE (server, n_parallel 4)", fn -> - {:ok, _} = ModelManager.load("moe", {:path, moe}, n_gpu_layers: -1, n_parallel: 4, n_ctx: 16_384) + {:ok, _} = + ModelManager.load("moe", {:path, moe}, n_gpu_layers: -1, n_parallel: 4, n_ctx: 16_384) + {:ok, Path.basename(moe)} end) E2E.step("load embedding model (direct)", fn -> - {:ok, _} = ModelManager.load("embed", {:path, embed}, capabilities: [:embed], n_gpu_layers: -1) + {:ok, _} = + ModelManager.load("embed", {:path, embed}, capabilities: [:embed], n_gpu_layers: -1) + {:ok, Path.basename(embed)} end) @@ -205,8 +218,10 @@ case System.argv() do E2E.step("both chat models at once, 8 requests each", fn -> [a, b] = Task.await_many( - [Task.async(fn -> E2E.concurrent({:manager, "big"}, 8) end), - Task.async(fn -> E2E.concurrent({:manager, "moe"}, 8) end)], + [ + Task.async(fn -> E2E.concurrent({:manager, "big"}, 8) end), + Task.async(fn -> E2E.concurrent({:manager, "moe"}, 8) end) + ], 600_000 ) @@ -221,7 +236,10 @@ case System.argv() do {:ok, b} = ModelManager.embed("embed", "A cat was sitting on a rug.") {:ok, c} = ModelManager.embed("embed", "Quarterly revenue grew by eight percent.") {sim, far} = {E2E.cosine(a, b), E2E.cosine(a, c)} - if sim > far, do: {:ok, "#{Float.round(sim, 3)} > #{Float.round(far, 3)}"}, else: {:error, "#{sim} <= #{far}"} + + if sim > far, + do: {:ok, "#{Float.round(sim, 3)} > #{Float.round(far, 3)}"}, + else: {:error, "#{sim} <= #{far}"} end) E2E.step("unload one model, the other keeps serving", fn -> @@ -276,13 +294,19 @@ case System.argv() do E2E.step("split: streaming chat completion", fn -> {n, text} = E2E.stream_text(split, "What is the capital of France? One word.") - if text =~ ~r/Paris/i, do: {:ok, "#{n} chunks, #{inspect(String.trim(text))}"}, else: {:error, inspect(text)} + + if text =~ ~r/Paris/i, + do: {:ok, "#{n} chunks, #{inspect(String.trim(text))}"}, + else: {:error, inspect(text)} end) E2E.step("split + local at once, 8 requests each", fn -> [a, b] = Task.await_many( - [Task.async(fn -> E2E.concurrent(split, 8) end), Task.async(fn -> E2E.concurrent(local, 8) end)], + [ + Task.async(fn -> E2E.concurrent(split, 8) end), + Task.async(fn -> E2E.concurrent(local, 8) end) + ], 600_000 ) @@ -309,7 +333,9 @@ case System.argv() do ] {:ok, %{choices: [%{message: msg, finish_reason: reason} | _]}} = - LlamaCppEx.chat_completion(split, [%{role: "user", content: "What's the weather in Paris right now?"}], + LlamaCppEx.chat_completion( + split, + [%{role: "user", content: "What's the weather in Paris right now?"}], tools: tools, max_tokens: 512, temp: 0.0 diff --git a/test/option_forwarding_test.exs b/test/option_forwarding_test.exs index 51e39b9..7389977 100644 --- a/test/option_forwarding_test.exs +++ b/test/option_forwarding_test.exs @@ -235,6 +235,29 @@ defmodule LlamaCppEx.OptionForwardingTest do assert key in Model.tuning_option_keys() end end + + test "load-mode flags resolve to llama.cpp's enum, auto when none is given" do + # Values from llama.h's llama_load_mode. Unset must stay AUTO: upstream + # then skips mmap on an integrated GPU (#26081), and a forced mmap on GB10 + # left most loads decoding ~15% slower. + auto = -1 + none = 0 + mmap = 1 + mlock = 2 + mmap_mlock = 3 + dio = 4 + + assert Model.resolve_load_mode(nil, false, false) == auto + assert Model.resolve_load_mode(true, false, false) == mmap + assert Model.resolve_load_mode(false, false, false) == none + assert Model.resolve_load_mode(nil, true, false) == mmap_mlock + assert Model.resolve_load_mode(true, true, false) == mmap_mlock + assert Model.resolve_load_mode(false, true, false) == mlock + + for use_mmap <- [nil, true, false], use_mlock <- [true, false] do + assert Model.resolve_load_mode(use_mmap, use_mlock, true) == dio + end + end end describe "callers do not keep their own copies" do From f6220fb24e8e43181b75d6f664437cae86defbbb Mon Sep 17 00:00:00 2001 From: Niko Maroulis Date: Mon, 2 Nov 2026 09:15:53 -0500 Subject: [PATCH 07/49] Server: prefix-instability warning only when the prompt diverges from the cache --- CHANGELOG.md | 6 ++++++ lib/llama_cpp_ex/server.ex | 12 +++++++++--- test/server_smoke_test.exs | 34 ++++++++++++++++++++++++++++++++++ 3 files changed, 49 insertions(+), 3 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 35c08a8..2a44ee8 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -32,6 +32,12 @@ numbers behind the entries below. them given resolves as before. Metal, CPU and discrete CUDA devices support mmap, so `auto` maps there exactly as the old default did. The NIF's `model_load` now takes the resolved mode instead of three booleans. +- `LlamaCppEx.Server`'s prefix-instability warning and + `[:llama_cpp_ex, :server, :prefix_instability]` event fired when the same + prompt came back (a retry, a regenerate, a benchmark loop) once the cached + generation made the history long enough — the whole prompt matched, which + is a perfect cache hit. They now fire only when the prompt itself diverges + from the cached history. - `LlamaCppEx.RPC.add_server/1`, `ping/1` and `Model.load/2`'s `:rpc_servers` aborted the VM on an RPC build when the endpoint was unreachable, unparseable, not an RPC worker, or spoke another protocol diff --git a/lib/llama_cpp_ex/server.ex b/lib/llama_cpp_ex/server.ex index 5484b58..09303aa 100644 --- a/lib/llama_cpp_ex/server.ex +++ b/lib/llama_cpp_ex/server.ex @@ -1156,7 +1156,7 @@ defmodule LlamaCppEx.Server do {raw_match, own_match} = own_cache_match(state, slot, tokens, n_tokens, cache_prompt?, scope, lcp) - state = maybe_warn_prefix_instability(state, seq_id, slot, raw_match, cache_prompt?) + state = maybe_warn_prefix_instability(state, seq_id, slot, raw_match, n_tokens, cache_prompt?) {state, n_match} = resolve_prefix_cache(state, seq_id, tokens, own_match, cache_prompt?, scope) @@ -1368,9 +1368,15 @@ defmodule LlamaCppEx.Server do # turns (e.g. Qwen thinking-strip re-rendering) — every such request pays a # near-full re-prefill that the caller probably believes is cached. Emit # telemetry per occurrence and warn in the log once per server. - defp maybe_warn_prefix_instability(state, seq_id, slot, raw_match, cache_prompt?) do + # + # Only when the prompt itself diverges from the cache: own_cache_match caps + # the match at n_tokens - 1, so a prompt that is wholly cached (the same + # prompt again, a regenerate) matches exactly that and is a perfect hit, not + # instability, however long the cached history behind it. + defp maybe_warn_prefix_instability(state, seq_id, slot, raw_match, n_tokens, cache_prompt?) do suspicious? = - cache_prompt? and slot.cached_pos >= @prefix_instability_min_cached and + cache_prompt? and raw_match < n_tokens - 1 and + slot.cached_pos >= @prefix_instability_min_cached and raw_match > slot.cached_pos * 0.1 and raw_match < slot.cached_pos * 0.5 if suspicious? do diff --git a/test/server_smoke_test.exs b/test/server_smoke_test.exs index e606d41..0d7beb0 100644 --- a/test/server_smoke_test.exs +++ b/test/server_smoke_test.exs @@ -78,6 +78,40 @@ defmodule LlamaCppEx.ServerSmokeTest do end end + describe "the prefix-instability heuristic" do + # It warns that a chat template is rewriting history, so it must fire on a + # prompt that diverges from the cached history early, and never on a prompt + # that is wholly cached — the same prompt again used to trip it as soon as + # the generated tail made the cached history long enough. + @shared "The capital of France is Paris. The capital of Germany is Berlin. " <> + "The capital of Spain is Madrid. The capital of Portugal is Lisbon. " + + test "is silent when the same prompt comes back" do + server = start_server(n_parallel: 1) + attach_collector(server, [:llama_cpp_ex, :server, :prefix_instability]) + + {:ok, _} = Server.generate(server, @shared <> "The capital of Italy is", max_tokens: 96) + {:ok, _} = Server.generate(server, @shared <> "The capital of Italy is", max_tokens: 8) + + refute_receive {:telemetry, _, _}, 500 + end + + test "fires when the prompt diverges from the cached history early" do + server = start_server(n_parallel: 1) + attach_collector(server, [:llama_cpp_ex, :server, :prefix_instability]) + + {:ok, _} = Server.generate(server, @shared <> "The capital of Italy is", max_tokens: 96) + + {:ok, _} = + Server.generate(server, @shared <> "Name three rivers in each of those countries.", + max_tokens: 8 + ) + + {%{matched_tokens: matched, cached_tokens: cached}, _} = next_telemetry() + assert matched < cached + end + end + test "empty token list errors immediately on both call types" do server = start_server([]) From 9fbd9f53d791a30347e6c5c98fa432b681e5eac0 Mon Sep 17 00:00:00 2001 From: Niko Maroulis Date: Mon, 2 Nov 2026 09:39:26 -0500 Subject: [PATCH 08/49] docs: single-Spark table, two-node control and transport rerun after load-mode fix, pipelining --- docs/dgx-spark.md | 119 ++++++++++++++++++++++++++++------------------ docs/multi-gpu.md | 17 ++++--- 2 files changed, 82 insertions(+), 54 deletions(-) diff --git a/docs/dgx-spark.md b/docs/dgx-spark.md index 218acf1..1040b43 100644 --- a/docs/dgx-spark.md +++ b/docs/dgx-spark.md @@ -249,19 +249,36 @@ clean A/B for what speculative decoding buys on this hardware. See ## Running on ONE Spark -Full numbers and methodology in -`bench/results/v0.8.43-dgx-spark-baseline.md`, and the two-node numbers in -`bench/results/v0.8.43-dgx-spark-two-node.md`. -The short version: - -| model | prefill (pp) | decode (tg) | -|---|---|---| -| Qwen3-8B Q4_K_M | 3500–4331 t/s | 40.5 t/s | -| Qwen3-30B-A3B Q4_K_M | 3287 t/s | 90.9 t/s | - -Three of the four figures beat the published single-Spark references; the fourth -is 7% under. **Prefill is this machine's strong suit** and decode is bandwidth- -bound, so quote them separately or you describe neither. +Measured at `785322d17` with every layer on the GPU. Prefill and the +single-stream decode reference are `llama-bench` (`-fa 1`, median of 3); +the rest is the binding through `bench/spark_overhead.exs` — `stream` is +`LlamaCppEx.stream/3`, the others `LlamaCppEx.Server` with that many +concurrent streams (per-stream decode, then aggregate): + +| model | size | pp512 | pp4096 | tg128 (upstream) | `stream` | server ×1 | server ×4 | server ×8 | +|---|---|---|---|---|---|---|---|---| +| Qwen3-8B Q4_K_M | 4.7 GiB | 3623 | 3500 | 43.9 | 44.1 | 43.7 | 39.0 / **153** | 36.4 / **284** | +| Qwen3-30B-A3B Q4_K_M | 17.3 GiB | 3282 | 3198 | 92.7 | 91.4 | 88.6 | 57.8 / **224** | 34.9 / **272** | +| Qwen3.6-35B-A3B UD-Q4_K_M | 20.6 GiB | 2918 | 2823 | 69.8 | 68.3 | 63.0 | 43.0 / **165** | 31.5 / **245** | +| Qwen3.8-27B Q4_K_M | 17.7 GiB | 1004 | 1008 | 11.3 | 11.3 | 11.2 | 9.9 / **39** | 8.4 / **66** | +| Qwen3.8-27B NVFP4 MID-HIGH | 15.7 GiB | 1278 | 1275 | 14.4 | 14.3 | 14.3 | 12.2 / **48** | 10.0 / **78** | +| gpt-oss-120b MXFP4 | 59.0 GiB | 1923 | 1990 | 49.2–59.0 | 57.0 | 55.9 | 23.8 / **91** | 13.5 / **105** | + +**Prefill is this machine's strong suit** and decode is bandwidth-bound, so +quote them separately or you describe neither. The dense models scale almost +linearly with concurrency (8 streams of Qwen3-8B cost 17% per stream for 6.4× +the aggregate); the MoE models scale less, because each additional stream +activates different experts and the step reads more weight. The binding's +single-stream decode is within 2% of `llama-bench` everywhere. + +> #### Measure decode more than once per load {: .warning} +> +> gpt-oss-120b's `llama-bench` tg128 came out at 49.2 in one run of a +> six-model sweep and 58.8–59.0 in fourteen others; the same ~17% dip +> appeared per process, with no change in clocks, page cache or memory +> fragmentation that would explain it. Forcing `mmap` made it the common +> case (see the load-mode row below). Treat any single decode figure on +> this machine as one sample. ### Settings that matter @@ -415,9 +432,10 @@ than the marketing: implements async compute and events, so llama.cpp enables **pipeline parallelism** across an RPC split (it used to refuse, and the nodes ran sequentially). A prompt's micro-batches now overlap across the two nodes: - prefill measured **+16–26%** for gpt-oss-120b and +22% for Qwen3.8-27B NVFP4 - against one node. A single decode stream has nothing to overlap and stays - within noise of one node (see B1 below). + prefill measured **+18–26%** for gpt-oss-120b and +22% for Qwen3.8-27B NVFP4 + against one node. A single decode stream has nothing to overlap and pays a + network round trip per token: 14% slower at best for gpt-oss-120b (see the + control below). - **Tensor parallelism ("tp=2"): technically yes, practically no.** It runs and it is correct, and it is 2.7× slower on decode. See the verdict section. @@ -615,24 +633,29 @@ for it, keep the worker's tensor cache on, and do not restart casually. ### The control: a model that does fit gpt-oss-120b MXFP4 (63.4 GB — fits one node, so this isolates RPC cost from -memory benefit), 1024-token prompt, 128 decode steps, median of 7, RDMA, one -session at `785322d17`: +memory benefit) at `785322d17`, after the load-mode fix. Binding rows: +`bench/spark_two_node.exs`, 1024-token prompt, 128 decode steps, median of 7, +two sessions each. Upstream rows: `llama-bench --rpc ... -dev CUDA0/RPC0` +against the same worker. | run | load s | TTFT ms | prefill t/s | decode t/s | |---|---|---|---|---| -| single-node | 50.9 | 515.2 | 2075.9 | 45.62 | -| two-node 50/50 | 154.2 | 447.9 | 2418.0 | 40.94 | -| two-node 50/50, fresh worker | 80.6 | 411.8 | 2625.7 | 45.81 | - -**Prefill is now 16–26% faster on two nodes** and TTFT 13–20% lower: with the -RPC backend async (#18626), llama.cpp pipelines the prompt's micro-batches -across the nodes, where it used to run them one node after the other. Decode -is a single stream with nothing to overlap; across four RDMA runs it landed -between 36.5 and 45.8 tok/s against 45.6 on one node, so call it **no gain, -and noisier**. Qwen3.8-27B NVFP4 says the same: prefill 1410 → 1725 tok/s, -decode 14.02 → 13.77. - -Load time is still the cost — 1.6–3× one node — because ~30 GB of weights +| single node | 30–52 | 491–495 | 2151–2168 | 53.3–53.8 | +| two nodes 50/50, RDMA | 105–112 | 418–429 | 2552–2614 | 36.2–37.6 | +| `llama-bench`, single node | — | — | 2046 (pp1024) | 58.8–59.0 | +| `llama-bench`, two nodes, fresh worker | — | — | 2460 (pp1024) | 50.4, 41.5, 50.5 (three clients in a row) | + +**Prefill is 18–26% faster on two nodes** and TTFT ~14% lower: with the RPC +backend async (#18626), llama.cpp pipelines the prompt's micro-batches across +the nodes, where it used to run them one node after the other. **Decode is +slower** — a single stream has nothing to overlap and pays a network round +trip per token on top of the same total compute: 14% at best through +`llama-bench`, ~30% through the binding's server. The spread on the +two-node rows is the worker's: the same worker served three `llama-bench` +clients in a row at 50.4, 41.5 and 50.5 tok/s, so restart it and re-measure +before believing any one two-node decode figure. + +Load time is still the cost — 2–3× one node — because ~30 GB of weights cross the network and the client still reads and hashes every tensor to check the worker's cache. @@ -640,24 +663,26 @@ the worker's cache. `GGML_RPC_NO_RDMA=1` on either peer keeps the connection on TCP (`rpc-worker.sh start spark-2 --tcp`); `--link lan` binds the worker to the -10 GbE management NIC instead of the fabric. Same 120b model; load is from a -run with the worker's tensor cache off (every byte crosses the link), the rest -from a 7-sample run per transport on a freshly restarted worker: +10 GbE management NIC instead of the fabric. Same 120b model and harness, +worker restarted with its tensor cache off for every run so every byte crosses +the link, two sessions per transport: -| transport | load s | TTFT ms | prefill t/s | decode t/s (runs) | +| transport | load s | TTFT ms | prefill t/s | decode t/s | |---|---|---|---|---| -| RDMA, 200 GbE fabric | 54.5 | 411.8 | 2625.7 | 45.8 (36.5–45.8 over 4 runs) | -| TCP, 200 GbE fabric | 59.5 | 426.6 | 2545.6 | 41.1 (41.1–42.8 over 3) | -| TCP, 10 GbE LAN | 75.8 | 426.3 | 2546.8 | 41.2 (40.0–41.2 over 3) | - -**What you lose without RDMA is now small:** ~3% of prefill, decode within -RDMA's own run-to-run spread, and ~10% of load time on the same link. The 10 -GbE LAN costs the same steady-state and **~40% more load time**, because a -load is the one phase that moves gigabytes. The −27% prefill / −11% decode TCP -penalty measured at b10362 is gone: per-token traffic across a layer split is -one activation row, and the async dispatcher now hides the round trip. -Keep RDMA for loads and as the default, but TCP — even over the LAN — is a -working fallback rather than a cliff. +| RDMA, 200 GbE fabric | 105–112 | 418–429 | 2552–2614 | 36.2–37.6 | +| TCP, 200 GbE fabric | 89–91 | 419–422 | 2593–2615 | 36.9–37.6 | +| TCP, 10 GbE LAN | 76–77 | 422–429 | 2540–2585 | 38.8–39.1 | + +**On this llama.cpp you lose nothing measurable without RDMA**, and nothing +on the 10 GbE LAN either: TTFT, prefill and decode overlap across the three +transports, and load time did not favour RDMA (the LAN was quickest in this +session; RDMA loaded in 54 s in an earlier one), so it is dominated by the +client reading and hashing the file, not by the wire. +Per-token traffic +across a layer split is one activation row, and the async dispatcher hides the +round trip; the −27% prefill / −11% decode TCP penalty measured at b10362 is +gone. RDMA still activates by default on the fabric and costs nothing, so +leave it on — but a TCP fallback, even over the LAN, is not a cliff. To confirm which one you got, look at the worker's log with `GGML_RPC_DEBUG=1`: diff --git a/docs/multi-gpu.md b/docs/multi-gpu.md index b5eff73..f5fe737 100644 --- a/docs/multi-gpu.md +++ b/docs/multi-gpu.md @@ -147,13 +147,16 @@ of a device being a network away — it will budget a remote device as if it wer local VRAM. The numbers are not nonsense, but do not read more into them than that. -### It buys capacity, not speed - -Pipeline parallelism is disabled whenever an RPC device participates: the RPC -backend reports `async = false, events = false`, and llama.cpp checks that before -enabling pipelining. The two nodes therefore execute **sequentially**. A model -that already fits on one machine gains nothing from a second one. See -[DGX Spark](dgx-spark.md) for the measurements. +### It buys capacity, and prefill, not decode + +Since llama.cpp #18626 the RPC backend implements async compute and events, so +llama.cpp enables pipeline parallelism across an RPC layer split: a prompt's +micro-batches overlap across the nodes, and prefill measured 18–26% faster on +two DGX Sparks than on one. A single decode stream has nothing to overlap and +pays a network round trip per token, so it is slower than on one machine. A +model that already fits on one machine gains capacity and prefill from a +second one, not decode speed. See [DGX Spark](dgx-spark.md) for the +measurements. > #### A peer failure aborts the VM {: .error} > From 77db4a66774e55bd3874f4e2dadcbadf4f1161fc Mon Sep 17 00:00:00 2001 From: Niko Maroulis Date: Mon, 2 Nov 2026 09:42:37 -0500 Subject: [PATCH 09/49] README: GB10 benchmark table, MTP options --- README.md | 71 +++++++++++++++++++++-------------------------- docs/multi-gpu.md | 5 ++-- 2 files changed, 34 insertions(+), 42 deletions(-) diff --git a/README.md b/README.md index a5cd92d..8424447 100644 --- a/README.md +++ b/README.md @@ -1287,10 +1287,14 @@ end) `LlamaCppEx.MTP.init/2`: + * `:type` — `:mtp` (default), `:dflash` or `:dspark`. The last two need the + drafter GGUF as `:draft_model`. + * `:draft_model` — a separate `%LlamaCppEx.Model{}`: a DFlash/DSpark drafter, + or an MTP sidecar head loaded with `load_mtp: true`. * `:n_draft` — draft tokens proposed per iteration (default `3`). The optimum - is hardware-specific and worth measuring rather than assuming: `1` on Apple - Silicon, `2` on GB10 (where `3` measured *slower* than no speculation at - all), `2–4` on datacenter NVIDIA. See the two performance notes above. + is model- and hardware-shaped, so measure it: for MTP, `2–3` on a dense + model and `2` on a sparse MoE on both GB10 and M1 Max; for DFlash 2, the + drafter's block size minus one (`7`), which is also its cap. * `:n_ctx`, `:n_threads`, `:flash_attn`, `:type_k`/`:type_v`, `:offload_kqv`, … — any `LlamaCppEx.Context` option; applied to both target and draft contexts. `LlamaCppEx.MTP.stream/3`: @@ -1336,45 +1340,34 @@ New `qwen35moe` architecture with Gated Delta Net (hybrid linear/full attention) ### CUDA: NVIDIA DGX Spark (GB10) -Same model and quantization as the M1 Max row above, so the two are directly -comparable. GB10 (`sm_121a`, aarch64, 128 GB unified), CUDA 13.0.2, driver -580.173.02, llama.cpp b10280, source build with `LLAMA_BACKEND=cuda`. - -| Model | Quantization | Tokens/sec (GB10) | Tokens/sec (M1 Max) | -|-------|-------------|-------------------|---------------------| -| Qwen3.6-35B-A3B | UD-Q4_K_XL | **62.1** | 43.8 | - -128-token generation, `temp: 0.0`, `n_gpu_layers: -1`. Median of 5 runs after a -discarded warm-up: 61.7 / 62.0 / 62.1 / 62.2 / 62.2 t/s — a 0.9% spread, so the -1.42x over M1 Max is well outside the noise. All 41 layers offload; the model -takes 20 799 MiB of device memory. +GB10 (`sm_121a`, aarch64, 128 GB unified), CUDA 13.0, driver 580.173.02, +llama.cpp `785322d17`, source build with `LLAMA_BACKEND=cuda`. Single-stream +decode through `LlamaCppEx.stream/3`, 128 greedy tokens, against upstream's +`llama-bench` on the same build: + +| Model | Quantization | llama_cpp_ex | llama-bench tg128 | +|-------|-------------|--------------|-------------------| +| Qwen3-8B | Q4_K_M | 44.1 | 43.9 | +| Qwen3-30B-A3B | Q4_K_M | 91.4 | 92.7 | +| Qwen3.6-35B-A3B | UD-Q4_K_M | 68.3 | 69.8 | +| Qwen3.8-27B | Q4_K_M | 11.3 | 11.3 | +| Qwen3.8-27B | NVFP4 (MID-HIGH) | 14.3 | 14.4 | +| gpt-oss-120b | MXFP4 | 57.0 | 58.8–59.0 | + +With speculative decoding the same machine does 44.2 tok/s on Qwen3.8-27B +NVFP4 (DFlash 2) and 96.7 on Qwen3.6-35B-A3B (MTP, `n_draft: 2`); see +[Speculative decoding](#speculative-decoding-mtp-dflash). Concurrency, prefill +and two-node numbers are in [docs/dgx-spark.md](docs/dgx-spark.md). Two notes on method, both learned the hard way: -- **Each run uses a distinct prompt.** Repeating one prompt hits the context - reuse path and reports a throughput the engine never achieved. -- **Tokens are counted by re-encoding the output**, not by counting stream - chunks — a chunk is not a token, and under speculative decoding it can carry - several. - -The first call after load is discarded: it pays CUDA graph capture and the -allocator's first-touch layout, and is not representative of steady state. - -With MTP speculative decoding, using the separate `-MTP` build of the same model -(the plain UD-Q4_K_XL carries no MTP head — `MTP.init/2` now says so rather than -failing with a bare context error): - -| | median tok/s | vs plain | -|---|---|---| -| plain | 61.4 | — | -| `n_draft: 2` | **71.2** | +16% | -| `n_draft: 3` | 61.1 | −2% | -| `n_draft: 4` | 53.8 | −14% | - -`n_draft: 2` is the optimum on this hardware, not the documented default of 3. -See the GB10 performance note under [Speculative decoding -(MTP)](#speculative-decoding-mtp) for the acceptance and timing counters behind -that. +- **Each run uses a distinct prompt, or prompt caching off.** Repeating one + prompt hits the context reuse path and reports a throughput the engine never + achieved. +- **Measure decode more than once per load.** On GB10 a load can land ~17% + slower for its whole lifetime (gpt-oss-120b: 48.5 against 57 tok/s), and a + forced `use_mmap: true` made that the common case — leave the load-mode + options unset. ### Single-sequence generation (Qwen3-4B Q4_K_M) diff --git a/docs/multi-gpu.md b/docs/multi-gpu.md index f5fe737..4d94c56 100644 --- a/docs/multi-gpu.md +++ b/docs/multi-gpu.md @@ -154,9 +154,8 @@ llama.cpp enables pipeline parallelism across an RPC layer split: a prompt's micro-batches overlap across the nodes, and prefill measured 18–26% faster on two DGX Sparks than on one. A single decode stream has nothing to overlap and pays a network round trip per token, so it is slower than on one machine. A -model that already fits on one machine gains capacity and prefill from a -second one, not decode speed. See [DGX Spark](dgx-spark.md) for the -measurements. +model that already fits on one machine gains prefill from a second one, and +loses some decode. See [DGX Spark](dgx-spark.md) for the measurements. > #### A peer failure aborts the VM {: .error} > From a3b742125271810dccd1e0afa077d06cbecefae1 Mon Sep 17 00:00:00 2001 From: Niko Maroulis Date: Mon, 2 Nov 2026 09:53:41 -0500 Subject: [PATCH 10/49] docs: two-node worker binary A/B --- docs/dgx-spark.md | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/docs/dgx-spark.md b/docs/dgx-spark.md index 1040b43..6c0023d 100644 --- a/docs/dgx-spark.md +++ b/docs/dgx-spark.md @@ -655,6 +655,14 @@ two-node rows is the worker's: the same worker served three `llama-bench` clients in a row at 50.4, 41.5 and 50.5 tok/s, so restart it and re-measure before believing any one two-node decode figure. +The worker binary matters less than that spread. `LlamaCppEx.stream/3` over +two nodes, three fresh contexts per session, worker restarted between +sessions: this library's `LlamaCppEx.RPC.Server` decoded at 38–48 tok/s +(sessions at ~38 and ~38/47), upstream's `ggml-rpc-server` +(`rpc-worker.sh --upstream`) at 40–51 (~50 and ~40). Both land in one of two +bands per session; upstream's sat in the faster one more often over four +sessions, which is too few to call. + Load time is still the cost — 2–3× one node — because ~30 GB of weights cross the network and the client still reads and hashes every tensor to check the worker's cache. From 80c069181cb2d1a4782452ef7bc7da53cf3d0db0 Mon Sep 17 00:00:00 2001 From: Niko Maroulis Date: Mon, 2 Nov 2026 09:54:20 -0500 Subject: [PATCH 11/49] Solution docs: GB10 forced mmap, RPC registration abort; CLAUDE.md rules --- ...ced-mmap-slow-decode-load-mode-20261102.md | 61 +++++++++++++++++++ ...dd-server-aborts-vm-dispatcher-20261102.md | 53 ++++++++++++++++ CLAUDE.md | 11 ++++ 3 files changed, 125 insertions(+) create mode 100644 .claude/solutions/phoenix-issues/gb10-forced-mmap-slow-decode-load-mode-20261102.md create mode 100644 .claude/solutions/phoenix-issues/rpc-add-server-aborts-vm-dispatcher-20261102.md diff --git a/.claude/solutions/phoenix-issues/gb10-forced-mmap-slow-decode-load-mode-20261102.md b/.claude/solutions/phoenix-issues/gb10-forced-mmap-slow-decode-load-mode-20261102.md new file mode 100644 index 0000000..c9515ea --- /dev/null +++ b/.claude/solutions/phoenix-issues/gb10-forced-mmap-slow-decode-load-mode-20261102.md @@ -0,0 +1,61 @@ +--- +module: "LlamaCppEx.Model (lib/llama_cpp_ex/model.ex), model_load NIF" +date: "2026-11-02" +problem_type: performance +component: model_loading +symptoms: + - "gpt-oss-120b decodes at ~48.5 tok/s through the binding on DGX Spark (GB10) while llama-bench and llama-server on the same build do ~57-59" + - "the gap is per process: about one binding load in five decodes fast (57), and repeated runs inside one process never change state" + - "nsys shows the same kernels (mul_mat_vec_q MXFP4/Q8_0) running ~22% longer in the slow processes" + - "n_ctx, n_threads, sampler chain, BEAM busy-wait, ASLR, page-cache eviction: no effect" +root_cause: "Model.load/2 defaulted :use_mmap to true, which the NIF mapped to an explicit LLAMA_LOAD_MODE_MMAP. Upstream's default is LLAMA_LOAD_MODE_AUTO (#26081), which reads the file instead of mapping it when a device reports caps.mmap_support == false — ggml-cuda reports that for an integrated GPU, and GB10 is one. Forcing mmap overrode that and made the slow placement the common case." +severity: high +tags: [cuda, gb10, dgx-spark, igpu, mmap, load-mode, performance, benchmark-noise] +related_solutions: [] +--- + +# Forced mmap on GB10 costs ~15% decode (load mode) + +## Symptoms + +Binding vs upstream on one Spark, gpt-oss-120b MXFP4, 128 greedy tokens: +`LlamaCppEx.stream/3` 48.5 tok/s, `llama-bench` tg128 58.9, `llama-server` +56.9. Qwen3-8B showed no gap, which hid it at first. + +## Investigation + +1. Binding overhead ruled out first: on Qwen3-8B the binding matched + `llama-bench` and `llama-server` within 1-2%, single stream and 8-way. +2. Per-process bimodality: the same script gave 48.5 in most processes and + 57 in a few; inside one process every context agreed. +3. `nsys profile -t cuda --cuda-graph-trace=node` on both: identical kernel + list and launch shapes, but the memory-bound matvecs ~22% slower in the + slow processes. So GPU-side, not CPU, sampling or messaging. +4. Ruled out: `n_threads`, sampler chain, `n_ctx`/`swa_full`, BEAM `+sbwt none`, + `setarch -R`, THP (weights are not in RSS), page-cache eviction via + `posix_fadvise(DONTNEED)`. +5. `use_mmap: false` and `use_direct_io: true`: 6/6 processes fast. Upstream's + `llama_model_default_params().load_mode` is `AUTO`; `src/llama-model.cpp` + turns mmap off under AUTO when a device lacks `mmap_support`, and + `ggml-cuda.cu` sets that false for `GGML_BACKEND_DEVICE_TYPE_IGPU`. + +## Fix + +`Model.load/2` resolves the three flags itself (`resolve_load_mode/3`) and +passes the enum to the NIF; with none of them given the result is +`LLAMA_LOAD_MODE_AUTO`. Explicit flags resolve exactly as before. Metal, CPU +and discrete CUDA report `mmap_support`, so AUTO maps there as the old +default did. After: 5/5 processes at 57.0-57.2 tok/s; forced mmap still +bimodal (48.5 / 57). + +## Lessons + +- Never override an upstream default with a binding default that looks + equivalent — `use_mmap: true` was "the default" only until upstream grew a + smarter one. +- On GB10, a single decode measurement is one sample of a bimodal process. + The ~17% dip also appeared occasionally in `llama-bench` itself and on the + RPC worker per client session, independent of mmap; re-run before + believing a number. +- Test: `test/option_forwarding_test.exs` "load-mode flags resolve to + llama.cpp's enum, auto when none is given". diff --git a/.claude/solutions/phoenix-issues/rpc-add-server-aborts-vm-dispatcher-20261102.md b/.claude/solutions/phoenix-issues/rpc-add-server-aborts-vm-dispatcher-20261102.md new file mode 100644 index 0000000..a73b210 --- /dev/null +++ b/.claude/solutions/phoenix-issues/rpc-add-server-aborts-vm-dispatcher-20261102.md @@ -0,0 +1,53 @@ +--- +module: "LlamaCppEx.RPC / rpc_add_server NIF (c_src/llama_cpp_ex/llama_nif.cpp)" +date: "2026-11-02" +problem_type: runtime_error +component: rpc +symptoms: + - "ggml-rpc.cpp:653: Failed to connect to 127.0.0.1:1, then SIGABRT (exit 134) from mix test on an LLAMA_RPC=1 build" + - "RPC.add_server/1, RPC.ping/1 or Model.load(path, rpc_servers: [...]) with a dead endpoint kills the VM instead of returning {:error, :unreachable}" + - "default (non-RPC) builds and macOS CI never show it: they answer :rpc_unsupported without touching ggml-rpc" +root_cause: "llama.cpp #18626 (d0132a680, 'rpc : implement event and async backend APIs') moved the connect and HELLO into rpc_dispatcher::start, which GGML_ABORTs on a parse failure, connect failure, HELLO failure or version mismatch. ggml_backend_rpc_add_server used to return nullptr for all of them. negotiate_hello also RPC_STATUS_ASSERTs when a non-RPC peer answers." +severity: high +tags: [rpc, ggml-rpc, abort, nif, upstream-regression, dgx-spark] +related_solutions: [] +--- + +# RPC registration aborts the VM since llama.cpp #18626 + +## Symptoms + +First `mix test` on a CUDA + `LLAMA_RPC=1` build on a DGX Spark aborted +within seconds at `rpc_test.exs`'s `RPC.add_server("127.0.0.1:1")`. The +published 0.8.66 does the same when built with `LLAMA_RPC=1` +(`mix deps.compile llama_cpp_ex --force` with `LLAMA_RPC=1 LLAMA_BACKEND=cuda`, +then `RPC.add_server("127.0.0.1:1")` → exit 134). + +## Investigation + +`git log -S "Failed to connect to %s" -- ggml/src/ggml-rpc/ggml-rpc.cpp` +pointed at d0132a680; its diff replaces every `return nullptr` in the old +`get_socket` with `GGML_ABORT` in `rpc_dispatcher::start`. CI never builds +RPC, so the bump that brought it in (v0.8.5x) passed. + +## Fix + +- NIF: `rpc_probe_hello/2` connects (IPv4, first-':' parse, `std::stoi`, + exactly as upstream) with a 5 s timeout and sends a TCP-only HELLO (zeroed + conn caps, so the worker never starts an RDMA upgrade for the probe), then + checks major/minor like `negotiate_hello`. Anything short of that is + `{:error, :unreachable}` before `ggml_backend_rpc_add_server` runs. The wire + layout is pinned by `static_assert(RPC_PROTO_MAJOR_VERSION == 8)`. +- Upstream: branch `rpc-add-server-no-abort` on `nyo16/llama.cpp` makes + `start()` return false, adds `try_get_dispatcher()` for registration and + keeps aborting only on established connections. +- Tests: `test/rpc_test.exs` — a listener that closes, one that answers HTTP, + and unparseable endpoints; each aborted the VM with the probe disabled. + +## Lessons + +- An RPC build is a different artifact; run `mix test` on one after every + llama.cpp bump that touches `ggml-rpc`, not only `--include rpc_live`. +- `rsync -a` preserves source mtimes: after editing a file on a node, a sync + that restores an older-mtime copy leaves make's `.o` newer than its source. + `touch` the source before rebuilding. diff --git a/CLAUDE.md b/CLAUDE.md index 283b4ce..0e1b4ba 100644 --- a/CLAUDE.md +++ b/CLAUDE.md @@ -71,3 +71,14 @@ release problem. - A test-side `:telemetry.attach` filters on an identity the test owns (`%{server: ^server}`, a ref) and detaches in `on_exit`. A linked server can outlive its test and emit after replying. + +## RPC and performance + +- After a llama.cpp bump, run the default `mix test` on an `LLAMA_RPC=1` build + too (a DGX Spark has one): CI never builds RPC, and upstream's registration + started aborting on a dead endpoint without any test noticing (#18626). +- Do not override an upstream default with a binding default that looks + equivalent. `Model.load/2` leaves the load mode `auto` unless the caller + sets a flag; a forced `mmap` cost ~15% decode on GB10. +- On a DGX Spark a decode figure is one sample: a load can land ~17% slow for + its lifetime. Re-run in a fresh process before comparing. From 95bf175be428a9d959938127e77f26cf9e0d364f Mon Sep 17 00:00:00 2001 From: Niko Maroulis Date: Mon, 2 Nov 2026 10:08:56 -0500 Subject: [PATCH 12/49] MTP: refuse a DFlash drafter missing the target's devices (VM abort over RPC splits); Model.devices/1; two-node DFlash e2e --- CHANGELOG.md | 7 +++++ c_src/llama_cpp_ex/llama_nif.cpp | 16 ++++++++++ lib/llama_cpp_ex/model.ex | 8 +++++ lib/llama_cpp_ex/mtp.ex | 28 +++++++++++++++-- lib/llama_cpp_ex/nif.ex | 1 + scripts/spark/e2e.exs | 53 ++++++++++++++++++++++++++++++++ 6 files changed, 110 insertions(+), 3 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 2a44ee8..7c1df1b 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -18,6 +18,13 @@ numbers behind the entries below. a DFlash checkpoint, or reads layers the target does not have, is refused with an error: upstream asserts on it. `n_draft` is clamped to the drafter's block size and `%MTP{}.n_draft` reports the clamped value. +- `LlamaCppEx.Model.devices/1`: the devices a model's layers were placed on. + `MTP.init/2` uses it to refuse a DFlash/DSpark drafter that is not loaded on + every device the target uses — the drafter computes with the target's + embeddings and LM head, and a target split onto an RPC worker with the + drafter on `CUDA0` alone aborted the VM. Loaded with the target's + `:devices`, DFlash runs over a two-node split (Qwen3.8-27B NVFP4: 22.3 + tok/s against 14.0 plain). ### Fixed diff --git a/c_src/llama_cpp_ex/llama_nif.cpp b/c_src/llama_cpp_ex/llama_nif.cpp index e8ec29f..454aa0f 100644 --- a/c_src/llama_cpp_ex/llama_nif.cpp +++ b/c_src/llama_cpp_ex/llama_nif.cpp @@ -1082,6 +1082,22 @@ int64_t model_n_layer_nextn(ErlNifEnv* env, fine::ResourcePtr model) } LLAMA_NIF(model_n_layer_nextn, 0); +// Names of the devices the model's layers were placed on, in placement order. +// LlamaCppEx.MTP uses it to refuse a DFlash drafter that cannot reach the +// target's embeddings and LM head (shared via ctx_other): a draft context +// without the device holding them hits "pre-allocated tensor ... in a buffer +// that cannot run the operation", a GGML_ABORT. +std::vector model_devices(ErlNifEnv* env, fine::ResourcePtr model) { + std::vector names; + const int32_t n = llama_model_n_devices(model->model); + for (int32_t i = 0; i < n; i++) { + ggml_backend_dev_t dev = llama_model_get_device(model->model, i); + if (dev) names.emplace_back(ggml_backend_dev_name(dev)); + } + return names; +} +LLAMA_NIF(model_devices, 0); + std::string model_desc(ErlNifEnv* env, fine::ResourcePtr model) { char buf[256]; llama_model_desc(model->model, buf, sizeof(buf)); diff --git a/lib/llama_cpp_ex/model.ex b/lib/llama_cpp_ex/model.ex index cc7a0d5..7b647a6 100644 --- a/lib/llama_cpp_ex/model.ex +++ b/lib/llama_cpp_ex/model.ex @@ -250,6 +250,14 @@ defmodule LlamaCppEx.Model do @spec n_layer_nextn(t()) :: non_neg_integer() def n_layer_nextn(%__MODULE__{ref: ref}), do: LlamaCppEx.NIF.model_n_layer_nextn(ref) + @doc """ + Names of the devices the model's layers were placed on, in placement order — + e.g. `["CUDA0", "RPC0"]` for a model split across a local GPU and an RPC + worker. Empty for a CPU-only load. + """ + @spec devices(t()) :: [String.t()] + def devices(%__MODULE__{ref: ref}), do: LlamaCppEx.NIF.model_devices(ref) + @doc "Returns a human-readable description of the model." @spec desc(t()) :: String.t() def desc(%__MODULE__{ref: ref}), do: LlamaCppEx.NIF.model_desc(ref) diff --git a/lib/llama_cpp_ex/mtp.ex b/lib/llama_cpp_ex/mtp.ex index 438f478..98dc9d0 100644 --- a/lib/llama_cpp_ex/mtp.ex +++ b/lib/llama_cpp_ex/mtp.ex @@ -129,7 +129,11 @@ defmodule LlamaCppEx.MTP do * `:dspark` - a DSpark drafter (DFlash plus a Markov head), passed as `:draft_model`. * `:draft_model` - A separate `LlamaCppEx.Model` holding the drafter. - Required for `:dflash` and `:dspark`. For `:mtp` it is the sidecar head + Required for `:dflash` and `:dspark`, and loaded on every device the + target uses (`LlamaCppEx.Model.devices/1`): a DFlash drafter computes + with the target's embeddings and LM head. For a target split across an + RPC worker, load the drafter with the same `:devices` and a + `:tensor_split` that keeps its layers local. For `:mtp` it is the sidecar head for checkpoints that ship one rather than embedding it (Qwen 3.8: `Qwen3.8-27B-Q4_K_M.gguf` plus `mtp-Qwen3.8-27B-Q4_0.gguf`; Gemma4 E4B: a `gemma4` target plus a `gemma4-assistant` head), loaded with @@ -167,8 +171,26 @@ defmodule LlamaCppEx.MTP do # Whether the drafter really is a DFlash checkpoint for this target is checked # in the NIF, where the model's target-layer metadata is readable: upstream's # constructor asserts on it, so it has to be refused before init. - defp validate_drafter(type, _target, %Model{} = draft) when type in [:dflash, :dspark], - do: {:ok, draft} + # + # The device check has to happen here, before the draft context exists. A + # DFlash drafter computes with the target's token embeddings and LM head + # (shared through ctx_other), so its context needs a backend for every device + # the target placed weights on. A target split onto an RPC worker with the + # drafter on CUDA0 alone aborted the VM with "pre-allocated tensor + # (output.weight) in a buffer (RPC0) that cannot run the operation". + defp validate_drafter(type, target, %Model{} = draft) when type in [:dflash, :dspark] do + case Model.devices(target) -- Model.devices(draft) do + [] -> + {:ok, draft} + + missing -> + {:error, + "the drafter reads the target's embeddings and LM head, so it must be loaded " <> + "on every device the target uses; it is missing #{Enum.join(missing, ", ")}. " <> + "Load it with the target's :devices (a :tensor_split can still keep its " <> + "own layers on one of them)"} + end + end defp validate_drafter(type, _target, nil) when type in [:dflash, :dspark], do: {:error, "type: #{inspect(type)} needs the drafter GGUF passed as draft_model:"} diff --git a/lib/llama_cpp_ex/nif.ex b/lib/llama_cpp_ex/nif.ex index 58efad0..046917d 100644 --- a/lib/llama_cpp_ex/nif.ex +++ b/lib/llama_cpp_ex/nif.ex @@ -56,6 +56,7 @@ defmodule LlamaCppEx.NIF do def model_n_layer_nextn(_model), do: :erlang.nif_error(:not_loaded) def model_desc(_model), do: :erlang.nif_error(:not_loaded) def model_size(_model), do: :erlang.nif_error(:not_loaded) + def model_devices(_model), do: :erlang.nif_error(:not_loaded) def model_n_params(_model), do: :erlang.nif_error(:not_loaded) def model_chat_template(_model), do: :erlang.nif_error(:not_loaded) diff --git a/scripts/spark/e2e.exs b/scripts/spark/e2e.exs index 66e67d3..78b71bd 100644 --- a/scripts/spark/e2e.exs +++ b/scripts/spark/e2e.exs @@ -350,6 +350,59 @@ case System.argv() do end end) + drafter = + System.get_env("SPARK_E2E_DFLASH") || + Path.join( + home, + "models/z-lab/Qwen3.8-27B-DFlash2-GGUF/main/Qwen3.8-27B-DFlash2-Q4_K_M.gguf" + ) + + {:ok, target} = + LlamaCppEx.Model.load(big, + devices: ["CUDA0", "RPC0"], + split_mode: :layer, + tensor_split: [0.5, 0.5], + n_gpu_layers: -1 + ) + + E2E.step("DFlash drafter on CUDA0 alone is refused, not aborted", fn -> + {:ok, local_only} = LlamaCppEx.Model.load(drafter, devices: ["CUDA0"], n_gpu_layers: -1) + + case LlamaCppEx.MTP.init(target, type: :dflash, draft_model: local_only, n_ctx: 2048) do + {:error, msg} -> if msg =~ "RPC0", do: {:ok, "names RPC0"}, else: {:error, msg} + other -> {:error, inspect(other)} + end + end) + + E2E.step("DFlash over the split target", fn -> + {:ok, d} = + LlamaCppEx.Model.load(drafter, + devices: ["CUDA0", "RPC0"], + split_mode: :layer, + tensor_split: [1.0, 0.0], + n_gpu_layers: -1 + ) + + {:ok, spec} = + LlamaCppEx.MTP.init(target, type: :dflash, draft_model: d, n_draft: 7, n_ctx: 2048) + + {:ok, prompt} = + LlamaCppEx.Chat.apply_template( + target, + [%{role: "user", content: "What is the capital of France? One word."}], + enable_thinking: false + ) + + {:ok, text} = LlamaCppEx.MTP.generate(spec, prompt, max_tokens: 8, temp: 0.0) + stats = LlamaCppEx.MTP.stats(spec) + + if text =~ ~r/Paris/i, + do: + {:ok, + "#{inspect(String.trim(text))}, #{stats.drafts_accepted}/#{stats.drafts_generated} drafts"}, + else: {:error, inspect(text)} + end) + GenServer.stop(local) GenServer.stop(split) From ea732134a8893061a03f58b15eee521f24f76d8f Mon Sep 17 00:00:00 2001 From: Niko Maroulis Date: Mon, 2 Nov 2026 10:09:09 -0500 Subject: [PATCH 13/49] docs: speculative decoding across two nodes --- docs/dgx-spark.md | 20 ++++++++++++++++++++ 1 file changed, 20 insertions(+) diff --git a/docs/dgx-spark.md b/docs/dgx-spark.md index 6c0023d..fd59e3c 100644 --- a/docs/dgx-spark.md +++ b/docs/dgx-spark.md @@ -705,6 +705,26 @@ scripts/spark/rpc-worker.sh logs spark-2 200 | grep -E 'RDMA|transport' `RDMA activate failed, staying on TCP`, or no `RDMA activated` line at all, is TCP. +### Speculative decoding across two nodes + +Qwen3.8-27B NVFP4 split 50/50 over the fabric, one 256-token greedy chat +completion, three runs each through `LlamaCppEx.MTP` (not the four-prompt +harness above, so acceptance is not comparable with the one-node table): + +| config | decode t/s | acceptance | +|---|---|---| +| plain | 14.02–14.03 | — | +| MTP `n_draft: 3` | 17.7–19.7 | 50% | +| DFlash 2 `n_draft: 7` | **22.2–22.4** | 27% | + +DFlash still pays 1.6× across two nodes. The drafter must be loaded on every +device the target uses, because it computes with the target's embeddings and +LM head: with the target on `["CUDA0", "RPC0"]` and the drafter on `CUDA0` +alone, upstream aborts the process ("pre-allocated tensor (output.weight) in +a buffer (RPC0) that cannot run the operation"). `MTP.init/2` refuses that +pairing; load the drafter with the target's `:devices` and +`tensor_split: [1.0, 0.0]` to keep its own layers local. + ### Concurrency across two nodes | `n_parallel` | decode t/s per request | From 9ff1edcc9805b2cb937612c076610c9c3fea2e72 Mon Sep 17 00:00:00 2001 From: Niko Maroulis Date: Mon, 2 Nov 2026 10:20:30 -0500 Subject: [PATCH 14/49] bench: two-node concurrency through spark_overhead (SPARK_RPC_ENDPOINT); drop b4, which never ran concurrent requests --- bench/spark_overhead.exs | 34 +++++++++++++++++++++++++++------- bench/spark_two_node.exs | 35 +++++------------------------------ docs/dgx-spark.md | 23 ++++++++++++++++------- 3 files changed, 48 insertions(+), 44 deletions(-) diff --git a/bench/spark_overhead.exs b/bench/spark_overhead.exs index 79c04b7..b6d322b 100644 --- a/bench/spark_overhead.exs +++ b/bench/spark_overhead.exs @@ -1,6 +1,7 @@ # Binding overhead against upstream's own tools, on one model. # # scripts/spark/remote.sh --env MIX_ENV=bench --env LLAMA_MODEL_PATH= \ +# [--env SPARK_RPC_ENDPOINT=10.100.64.2:50052] \ # --big-cores spark-1 mix run bench/spark_overhead.exs # # Compare with, from the same llama.cpp commit: @@ -66,7 +67,24 @@ defmodule Overhead do end :ok = LlamaCppEx.init() -{:ok, model} = LlamaCppEx.load_model(model_path, n_gpu_layers: -1) + +# SPARK_RPC_ENDPOINT=host:port splits every load 50/50 with that worker, so the +# same table measures two nodes. +placement = + case System.get_env("SPARK_RPC_ENDPOINT") do + nil -> + [] + + endpoint -> + [ + rpc_servers: [endpoint], + devices: ["CUDA0", "RPC0"], + split_mode: :layer, + tensor_split: [0.5, 0.5] + ] + end + +{:ok, model} = LlamaCppEx.load_model(model_path, [n_gpu_layers: -1] ++ placement) IO.puts("model: #{Path.basename(model_path)} n_gen: #{n_gen} samples: #{samples}\n") IO.puts("| path | streams | tokens/stream | per-stream t/s | aggregate t/s |") @@ -85,12 +103,14 @@ IO.puts("| stream | 1 | #{n} | #{Float.round(tps, 2)} | #{Float.round(tps, 2)} | for n_par <- [1 | parallel] do {:ok, server} = LlamaCppEx.Server.start_link( - model_path: model_path, - n_gpu_layers: -1, - n_parallel: n_par, - n_ctx: 4096 * n_par, - temp: 0.0, - cache_prompt: false + [ + model_path: model_path, + n_gpu_layers: -1, + n_parallel: n_par, + n_ctx: 4096 * n_par, + temp: 0.0, + cache_prompt: false + ] ++ placement ) # start_link returns before the load; a generate call queues behind it. diff --git a/bench/spark_two_node.exs b/bench/spark_two_node.exs index 2e06af5..a03df51 100644 --- a/bench/spark_two_node.exs +++ b/bench/spark_two_node.exs @@ -17,8 +17,10 @@ Code.require_file("helpers.exs", __DIR__) # justifies the second Spark, and it is allowed to come out negative. # b3 RDMA versus TCP, in tokens. One run per transport; see the b3 clause # for the worker flags (`--tcp` sets GGML_RPC_NO_RDMA, `--link lan`). -# b4 Batching amortisation. Per-token RTT is fixed per *graph*, not per -# token, so n_parallel should amortise it. Measure, do not assume. +# +# Concurrency across two nodes is bench/spark_overhead.exs with +# SPARK_RPC_ENDPOINT set: it runs N streams at once, which a slot count alone +# does not. # # Every run reports worker RSS before and after: upstream's worker is reported # to grow and never release, and RSS is a column here rather than an afterthought. @@ -367,34 +369,7 @@ case which do TwoNode.table([row]) - "b4" -> - # Per-token RTT is fixed per graph, not per token, so a bigger batch should - # amortise it. - path = models["120b"] - register.() - {local, remote} = device_names.() - - rows = - for n_parallel <- [1, 4, 8] do - TwoNode.measure( - "120b two-node n_parallel=#{n_parallel}", - path, - [ - n_parallel: n_parallel, - n_ctx: n_ctx * n_parallel, - cache_prompt: false, - devices: [local, remote], - split_mode: :layer, - tensor_split: [0.5, 0.5] - ], - prompt_tokens, - worker_node - ) - end - - TwoNode.table(rows) - other -> - IO.puts(:stderr, "unknown bench #{inspect(other)}; expected b1, b2, b3 or b4") + IO.puts(:stderr, "unknown bench #{inspect(other)}; expected b1, b2 or b3") System.halt(2) end diff --git a/docs/dgx-spark.md b/docs/dgx-spark.md index fd59e3c..44ffd1e 100644 --- a/docs/dgx-spark.md +++ b/docs/dgx-spark.md @@ -727,14 +727,23 @@ pairing; load the drafter with the target's `:devices` and ### Concurrency across two nodes -| `n_parallel` | decode t/s per request | -|---|---| -| 1 | 49.48 | -| 4 | 44.71 | -| 8 | 44.25 | +gpt-oss-120b through `bench/spark_overhead.exs` with `SPARK_RPC_ENDPOINT` +set (every load split 50/50 over the fabric), against the same bench on one +node; per-stream decode, then aggregate: -Per-token RTT is fixed per *graph*, not per token, so batching amortises it -well: 8 concurrent requests cost 11% of per-request decode for 8× the aggregate. +| streams | one node | two nodes | +|---|---|---| +| 1 (`stream/3`) | 57.0 | 47.8 | +| 1 (server) | 55.9 | 45.7 | +| 4 | 23.8 / **91** | 18.2 / **70** | +| 8 | 13.5 / **105** | 11.8 / **92** | + +Two nodes keep 77–88% of one node's throughput at every concurrency, so the +per-token round trip does not grow with the batch. (This section used to +quote 49.5 / 44.7 / 44.3 for `n_parallel` 1 / 4 / 8 from `spark_two_node.exs +b4`, which allocates that many slots but sends one request, so it measured +load-to-load variation rather than concurrency.) A MoE does not batch well on +either: each extra stream routes to different experts. ### The decode fast path is holding From e8abbad602a1414f7b86f905fe2ab9db1d661328 Mon Sep 17 00:00:00 2001 From: Niko Maroulis Date: Mon, 2 Nov 2026 10:34:52 -0500 Subject: [PATCH 15/49] docs: upstream fix for DFlash drafter on fewer devices; GRAPH_OPT row --- CHANGELOG.md | 4 +++- docs/dgx-spark.md | 13 ++++++++++--- 2 files changed, 13 insertions(+), 4 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 7c1df1b..01cf008 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -24,7 +24,9 @@ numbers behind the entries below. embeddings and LM head, and a target split onto an RPC worker with the drafter on `CUDA0` alone aborted the VM. Loaded with the target's `:devices`, DFlash runs over a two-node split (Qwen3.8-27B NVFP4: 22.3 - tok/s against 14.0 plain). + tok/s against 14.0 plain). Upstream fix (the draft context gets backends + for the target's devices): `nyo16/llama.cpp` branch + `draft-ctx-other-devices`. ### Fixed diff --git a/docs/dgx-spark.md b/docs/dgx-spark.md index 44ffd1e..4858112 100644 --- a/docs/dgx-spark.md +++ b/docs/dgx-spark.md @@ -299,6 +299,7 @@ And the settings that do **not** matter, each of which looks like it should: | `type_k` / `type_v` | leave f16. Quantizing the KV cache **loses** 2–7% and buys nothing: there is no separate VRAM to free | | `use_mmap`, `use_mlock`, `use_direct_io` | **leave all three unset.** Upstream's `auto` then reads the file instead of mapping it on this iGPU. A forced `use_mmap: true` — the binding's default before this run — left most gpt-oss-120b loads decoding at 48.5 tok/s against 57 with `auto`, `use_mmap: false` or `use_direct_io: true`; about one forced-mmap load in five came out fast, so single-load comparisons from before (this row used to say mlock and dio cost 3–4%) are not reliable | | `n_batch`, `n_ubatch` | no measurable effect; the default is fine | +| `GGML_CUDA_GRAPH_OPT=1` (env) | upstream's experimental concurrent-stream graph optimisation: **+2%** decode on gpt-oss-120b (60.1 against 59.0, three runs each), neutral on Qwen3-8B, Qwen3.6-35B-A3B and Qwen3.8-27B NVFP4 | | cpuidle / `idle=poll` | **no effect**, single-node or two-node. See below | | `taskset -c 5-9,15-19` | hygiene, not speed. But never use `-c 0-9` — those are the little cores | @@ -721,9 +722,15 @@ DFlash still pays 1.6× across two nodes. The drafter must be loaded on every device the target uses, because it computes with the target's embeddings and LM head: with the target on `["CUDA0", "RPC0"]` and the drafter on `CUDA0` alone, upstream aborts the process ("pre-allocated tensor (output.weight) in -a buffer (RPC0) that cannot run the operation"). `MTP.init/2` refuses that -pairing; load the drafter with the target's `:devices` and -`tensor_split: [1.0, 0.0]` to keep its own layers local. +a buffer (RPC0) that cannot run the operation") — `llama-server +--spec-draft-device CUDA0` does it too. `MTP.init/2` refuses that pairing; +load the drafter with the target's `:devices` and `tensor_split: [1.0, 0.0]` +to keep its own layers local. + +The upstream fix is branch `draft-ctx-other-devices` on `nyo16/llama.cpp`: a +context with `ctx_other` gets a backend for each of the other model's devices. +With it, that same `llama-server` command runs, at 26.4 tok/s (566 drafted, +173 accepted) on one 256-token completion. ### Concurrency across two nodes From 7802e84275dff61fbe8239b233435b96041c1b78 Mon Sep 17 00:00:00 2001 From: Niko Maroulis Date: Mon, 2 Nov 2026 10:46:32 -0500 Subject: [PATCH 16/49] docs: MMQ src1 reuse upstream candidate --- docs/dgx-spark.md | 9 +++++++++ 1 file changed, 9 insertions(+) diff --git a/docs/dgx-spark.md b/docs/dgx-spark.md index 4858112..046e341 100644 --- a/docs/dgx-spark.md +++ b/docs/dgx-spark.md @@ -354,6 +354,15 @@ Blackwell FP4 MMA (`mma.sync ... kind::mxf4nvf4`); an `nsys` profile of pp2048 puts 53% of GPU time in that matmul, 9% in activation quantization and ~23% in element-wise ops (SwiGLU, gating muls, adds, the GDN conv-state concat). +Part of that 9% is waste: projections that read the same activations (Q/K/V, +gate/up, the GDN input projections) quantize them once each — 4450 +`quantize_mmq_nvfp4` launches for a 2048-token prefill. Branch +`cuda-mmq-src1-reuse` on `nyo16/llama.cpp` keeps the last quantized MMQ +input and reuses it until something overwrites the source: 2540 launches, +**+2–2.6% prefill** on Qwen3.8-27B NVFP4 (1279 → 1312 tok/s at pp512), +0.5–1% +on the Q4_K models, perplexity bit-identical. It is not in the vendored +llama.cpp; it is a candidate for upstream. + ## Speculative decoding: MTP, DFlash 2, DSpark 256-token greedy chat completions (thinking off), four prompts run twice, From a9f78c15dd63b94d18affd9b558761f77bcf389e Mon Sep 17 00:00:00 2001 From: Niko Maroulis Date: Mon, 2 Nov 2026 11:09:03 -0500 Subject: [PATCH 17/49] docs: NVFP4 MMQ weight-scale fold upstream candidate --- docs/dgx-spark.md | 26 ++++++++++++++++++++++++-- 1 file changed, 24 insertions(+), 2 deletions(-) diff --git a/docs/dgx-spark.md b/docs/dgx-spark.md index 046e341..61bebfd 100644 --- a/docs/dgx-spark.md +++ b/docs/dgx-spark.md @@ -360,8 +360,30 @@ gate/up, the GDN input projections) quantize them once each — 4450 `cuda-mmq-src1-reuse` on `nyo16/llama.cpp` keeps the last quantized MMQ input and reuses it until something overwrites the source: 2540 launches, **+2–2.6% prefill** on Qwen3.8-27B NVFP4 (1279 → 1312 tok/s at pp512), +0.5–1% -on the Q4_K models, perplexity bit-identical. It is not in the vendored -llama.cpp; it is a candidate for upstream. +on the Q4_K models, perplexity bit-identical. + +The per-tensor NVFP4 weight scale is the other cheap win. llama.cpp builds each +NVFP4 projection as `mul(mul_mat(w, x), w_s)` with a scalar `w_s`. Decode +(MMVQ) already fuses that multiply, but batched MMQ runs it as a separate +broadcast kernel over the output: 224 launches and ~14% of pp512 GPU time. The +second commit on the same branch folds `w_s` into the per-token activation +scale that the NVFP4 write-back already applies: + +| `llama-bench -fa 1` | pp512 | pp2048 | pp8192 | tg128 | +|---|---|---|---|---| +| Qwen3.8-27B NVFP4, upstream | 1284 | 1297 | 1250 | 14.35 | +| + src1 reuse + scale fold | **1411** | **1422** | **1373** | 14.31 | +| Qwen3-8B Q4_K_M, upstream | 3577 | 3565 | 3214 | 43.97 | +| + src1 reuse (no NVFP4 to fold) | 3626 | 3611 | 3237 | 44.07 | + +That is +9.8% NVFP4 prefill, with decode unchanged. The fold changes where the +scale is rounded in. Over 8×512 tokens, its KL divergence against the unfused +path is 0.051. Upstream's native FP4 path differs from itself by about the same +amount (0.052) when only `-ub 256` changes, and with Q8 activations +(`GGML_CUDA_MMQ_PREC=q8`) the divergence is 0.0007. A new `test-backend-ops` +case, `MUL_MAT_SCALE`, compares the fused graph against the CPU backend. It +fails when the fold is deliberately off by 2×. Neither patch is in the vendored +llama.cpp; both are upstream candidates. ## Speculative decoding: MTP, DFlash 2, DSpark From 12e6a1721e3874025c8fd9bacb556bb545366f33 Mon Sep 17 00:00:00 2001 From: Niko Maroulis Date: Mon, 2 Nov 2026 11:24:02 -0500 Subject: [PATCH 18/49] docs: NVFP4 SWIGLU-in-MMQ fusion, +19-20% prefill --- docs/dgx-spark.md | 36 +++++++++++++++++++++++------------- 1 file changed, 23 insertions(+), 13 deletions(-) diff --git a/docs/dgx-spark.md b/docs/dgx-spark.md index 61bebfd..eeb90ed 100644 --- a/docs/dgx-spark.md +++ b/docs/dgx-spark.md @@ -362,28 +362,38 @@ input and reuses it until something overwrites the source: 2540 launches, **+2–2.6% prefill** on Qwen3.8-27B NVFP4 (1279 → 1312 tok/s at pp512), +0.5–1% on the Q4_K models, perplexity bit-identical. -The per-tensor NVFP4 weight scale is the other cheap win. llama.cpp builds each +The per-tensor NVFP4 weight scale is the next cheap win. llama.cpp builds each NVFP4 projection as `mul(mul_mat(w, x), w_s)` with a scalar `w_s`. Decode (MMVQ) already fuses that multiply, but batched MMQ runs it as a separate broadcast kernel over the output: 224 launches and ~14% of pp512 GPU time. The second commit on the same branch folds `w_s` into the per-token activation -scale that the NVFP4 write-back already applies: +scale that the NVFP4 write-back already applies. + +The third commit removes the SWIGLU output. An FFN down projection reads +`swiglu(gate, up)`, the widest activation in the model, which the GLU kernel +writes and the quantizer then reads twice. The fused quantizer reads `gate` and +`up` and quantizes `silu(gate) * up` directly. It uses the same expression as +the GLU kernel, so the quantized blocks are bit-identical. It needs 512 threads +per row: at the stock 128 the fused kernel is latency-bound and gains nothing. | `llama-bench -fa 1` | pp512 | pp2048 | pp8192 | tg128 | |---|---|---|---|---| | Qwen3.8-27B NVFP4, upstream | 1284 | 1297 | 1250 | 14.35 | -| + src1 reuse + scale fold | **1411** | **1422** | **1373** | 14.31 | +| + src1 reuse + scale fold | 1411 | 1422 | 1373 | 14.31 | +| + SWIGLU quantized in MMQ | **1541** | **1552** | **1488** | 14.30 | | Qwen3-8B Q4_K_M, upstream | 3577 | 3565 | 3214 | 43.97 | -| + src1 reuse (no NVFP4 to fold) | 3626 | 3611 | 3237 | 44.07 | - -That is +9.8% NVFP4 prefill, with decode unchanged. The fold changes where the -scale is rounded in. Over 8×512 tokens, its KL divergence against the unfused -path is 0.051. Upstream's native FP4 path differs from itself by about the same -amount (0.052) when only `-ub 256` changes, and with Q8 activations -(`GGML_CUDA_MMQ_PREC=q8`) the divergence is 0.0007. A new `test-backend-ops` -case, `MUL_MAT_SCALE`, compares the fused graph against the CPU backend. It -fails when the fold is deliberately off by 2×. Neither patch is in the vendored -llama.cpp; both are upstream candidates. +| + src1 reuse (no NVFP4 fusions apply) | 3626 | 3611 | 3237 | 44.07 | + +Together, the three commits give **+19–20% NVFP4 prefill**, with decode +unchanged. Only the scale fold changes numerics, because it moves where the +scale is rounded in. Over 8×512 tokens, its KL divergence against upstream is +0.051. Upstream's native FP4 path differs from itself by about the same amount +(0.052) when only `-ub 256` changes. With Q8 activations +(`GGML_CUDA_MMQ_PREC=q8`), the divergence is 0.0007. The SWIGLU fusion leaves +it at exactly 0.050913. The new `test-backend-ops` case, `MUL_MAT_SCALE`, +compares the fused graphs against the CPU backend. It fails when the fold is +deliberately off by 2× or the silu is dropped. None of these patches are in +the vendored llama.cpp; all three are upstream candidates. ## Speculative decoding: MTP, DFlash 2, DSpark From fba36f891f429ea492e9ac5db082a05dcbfcb321 Mon Sep 17 00:00:00 2001 From: Niko Maroulis Date: Mon, 2 Nov 2026 11:52:11 -0500 Subject: [PATCH 19/49] docs: gpt-oss expert-bias fusion results --- docs/dgx-spark.md | 18 ++++++++++++++++++ 1 file changed, 18 insertions(+) diff --git a/docs/dgx-spark.md b/docs/dgx-spark.md index eeb90ed..a8a231a 100644 --- a/docs/dgx-spark.md +++ b/docs/dgx-spark.md @@ -395,6 +395,24 @@ compares the fused graphs against the CPU backend. It fails when the fold is deliberately off by 2× or the silu is dropped. None of these patches are in the vendored llama.cpp; all three are upstream candidates. +## gpt-oss-120b prefill: the expert biases + +gpt-oss adds a per-expert bias after every expert projection: an `ADD_ID` after +the up, gate and down `MUL_MAT_ID`s. Decode fuses these into MMVQ, but prefill +made three passes over the `[n_ff, n_expert_used, n_tokens]` projections. That +was 7% of pp2048 GPU time. A fourth commit on the same branch moves the +up and gate biases into the GLU kernel and the down bias into the +weighted expert reduction. It keeps the unfused order of float operations, +so the KL divergence against upstream is 0.000000 with 100% same top token: + +| gpt-oss-120b, `llama-bench -fa 1 -r 5` | pp512 | pp2048 | pp8192 | tg128 | +|---|---|---|---|---| +| upstream | 2037 | 2080 | 1993 | 58.07 | +| branch (src1 reuse + bias fusions) | **2209** | **2244** | **2147** | 58.02 | + +That is +8% prefill with decode unchanged. The full CUDA `test-backend-ops` +suite passes on the branch (19246/19246). + ## Speculative decoding: MTP, DFlash 2, DSpark 256-token greedy chat completions (thinking off), four prompts run twice, From 125ad5d0c79af34585c20212418eccca07abecd0 Mon Sep 17 00:00:00 2001 From: Niko Maroulis Date: Mon, 2 Nov 2026 12:02:08 -0500 Subject: [PATCH 20/49] docs: binding prefill with the spark-all llama.cpp branch --- docs/dgx-spark.md | 19 +++++++++++++++++++ 1 file changed, 19 insertions(+) diff --git a/docs/dgx-spark.md b/docs/dgx-spark.md index a8a231a..3c7058b 100644 --- a/docs/dgx-spark.md +++ b/docs/dgx-spark.md @@ -413,6 +413,25 @@ so the KL divergence against upstream is 0.000000 with 100% same top token: That is +8% prefill with decode unchanged. The full CUDA `test-backend-ops` suite passes on the branch (19246/19246). +### Through the binding + +`nyo16/llama.cpp` branch `spark-all` is `785322d17`, the vendored commit, plus +these four CUDA commits, the `draft-ctx-other-devices` fix and the +`rpc-add-server-no-abort` fix. To test it, copy the checkout on spark-1 and +replace `vendor/llama.cpp` with the branch tree. Then remove the +`_build/*/lib/llama_cpp_ex/obj/llama_build-*` directories and run +`mix compile`. In that build, `Context.decode/2` of a 2048-token prompt +(`n_ubatch: 512`, flash attention, median of 5) gives: + +| | vendored | `spark-all` | +|---|---|---| +| Qwen3.8-27B NVFP4 | 1304 tok/s | **1560 tok/s** (+20%) | +| gpt-oss-120b MXFP4 | 2352 tok/s | **2583 tok/s** (+10%) | + +`scripts/spark/e2e.exs single` passes 12/12 on that build. The binding is +unaffected by the swap, but a release would have to vendor the branch or wait +for upstream. + ## Speculative decoding: MTP, DFlash 2, DSpark 256-token greedy chat completions (thinking off), four prompts run twice, From 9b208df174bce557e54fe4db0b21a6fcd39fe9b7 Mon Sep 17 00:00:00 2001 From: Niko Maroulis Date: Mon, 2 Nov 2026 13:03:05 -0500 Subject: [PATCH 21/49] docs: pin a two-node client to the A725 cores (+25% RPC decode) Two-node decode sits in one of two bands and the client's CPU cluster picks it. gpt-oss-120b over RDMA: llama-bench 44 on the X925 cores or unpinned, 54 on the A725 cores (single-node 59); the binding 37-38 unpinned, 47 pinned, same prefill. Kernel times are identical in both bands on both nodes, so the cost is CPU-side and in the network wait; why the X925 cluster is slower here is open. remote.sh gains --little-cores; the topology notes no longer claim taskset -c 0-9 is all little cores (it is five of each). --- CHANGELOG.md | 6 ++++ README.md | 6 +++- bench/spark_two_node.exs | 6 +++- docs/dgx-spark.md | 68 +++++++++++++++++++++++++++++++--------- scripts/spark/lib.sh | 8 +++-- scripts/spark/remote.sh | 6 ++++ 6 files changed, 81 insertions(+), 19 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 01cf008..22b1995 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -76,6 +76,12 @@ numbers behind the entries below. TCP (`scripts/spark/rpc-worker.sh --tcp` now uses it), and layer split over RPC is pipelined: the RPC backend implements async compute and events (#18626), so llama.cpp enables pipeline parallelism across the nodes. +- Two-node docs: run the client on the GB10's Cortex-A725 cores + (`taskset -c 0-4,10-14`, new `scripts/spark/remote.sh --little-cores`). + Unpinned or on the X925 cores, decode over RPC sits in a band ~25% slower: + gpt-oss-120b layer-split decoded 37–38 tok/s against 47 through the binding, + 44 against 54 through `llama-bench`. The decode spread the docs blamed on the + worker came from the client's placement. ## v0.8.66 diff --git a/README.md b/README.md index 8424447..bf34ab9 100644 --- a/README.md +++ b/README.md @@ -1359,7 +1359,7 @@ NVFP4 (DFlash 2) and 96.7 on Qwen3.6-35B-A3B (MTP, `n_draft: 2`); see [Speculative decoding](#speculative-decoding-mtp-dflash). Concurrency, prefill and two-node numbers are in [docs/dgx-spark.md](docs/dgx-spark.md). -Two notes on method, both learned the hard way: +Three notes, all learned the hard way: - **Each run uses a distinct prompt, or prompt caching off.** Repeating one prompt hits the context reuse path and reports a throughput the engine never @@ -1368,6 +1368,10 @@ Two notes on method, both learned the hard way: slower for its whole lifetime (gpt-oss-120b: 48.5 against 57 tok/s), and a forced `use_mmap: true` made that the common case — leave the load-mode options unset. +- **Over two nodes, pin the client to the Cortex-A725 cores** + (`taskset -c 0-4,10-14`). Unpinned, the BEAM mostly lands on the X925 + cores, and decode over RPC runs ~25% slower: gpt-oss-120b layer-split decoded + 37–38 tok/s unpinned against 47 pinned, with the same prefill. ### Single-sequence generation (Qwen3-4B Q4_K_M) diff --git a/bench/spark_two_node.exs b/bench/spark_two_node.exs index a03df51..5614368 100644 --- a/bench/spark_two_node.exs +++ b/bench/spark_two_node.exs @@ -3,9 +3,13 @@ Code.require_file("helpers.exs", __DIR__) # Two-node measurement suite for a pair of DGX Sparks. # # scripts/spark/rpc-worker.sh start spark-2 -# scripts/spark/remote.sh --env MIX_ENV=bench --env LLAMA_RPC=1 spark-1 \ +# scripts/spark/remote.sh --little-cores --env MIX_ENV=bench --env LLAMA_RPC=1 spark-1 \ # mix run bench/spark_two_node.exs # +# --little-cores runs this client on the Cortex-A725 cores, where two-node decode +# is ~25% faster than on the X925s an unpinned BEAM mostly lands on +# (docs/dgx-spark.md, "Pin the client to the little cores"). +# # Benches, each answering one question: # # b1 RPC overhead, controlled. A model that FITS one node, run single-node diff --git a/docs/dgx-spark.md b/docs/dgx-spark.md index 3c7058b..c30343f 100644 --- a/docs/dgx-spark.md +++ b/docs/dgx-spark.md @@ -25,9 +25,10 @@ Use `free -h`. `LlamaCppEx.devices/0` reports it correctly (130.7 GB total on `:igpu` for the same reason. **The CPU clusters are interleaved.** The performance cores are **5-9, 15-19**; -the efficiency cores are **0-4, 10-14**. `taskset -c 0-9` therefore pins a job -entirely to little cores. Measured on a 1-byte RDMA ping-pong: p50 21.5 µs on -cpu19 versus 29.1 µs on cpu0. +the efficiency cores are **0-4, 10-14**. `taskset -c 0-9` therefore gives a job +five of each, not the X925 cluster. Measured on a 1-byte RDMA ping-pong: p50 +21.5 µs on cpu19 versus 29.1 µs on cpu0. Even so, a two-node *client* decodes +25% faster on the A725 cores (see "Pin the client to the little cores"). **`ping` lies by three orders of magnitude.** ICMP RTT over the 200 Gb/s direct link reads ~1.2 ms. That is cpuidle exit latency (LPI-3 is 433 µs), not the wire @@ -301,7 +302,7 @@ And the settings that do **not** matter, each of which looks like it should: | `n_batch`, `n_ubatch` | no measurable effect; the default is fine | | `GGML_CUDA_GRAPH_OPT=1` (env) | upstream's experimental concurrent-stream graph optimisation: **+2%** decode on gpt-oss-120b (60.1 against 59.0, three runs each), neutral on Qwen3-8B, Qwen3.6-35B-A3B and Qwen3.8-27B NVFP4 | | cpuidle / `idle=poll` | **no effect**, single-node or two-node. See below | -| `taskset -c 5-9,15-19` | hygiene, not speed. But never use `-c 0-9` — those are the little cores | +| `taskset` | single node: hygiene, not speed. Two nodes: run the **client** on the A725 cores, `taskset -c 0-4,10-14`, for **+25% decode** (see "Pin the client to the little cores"). Note `-c 0-9` is half little cores, not the X925s | ### The cpuidle story, and why you can ignore it @@ -513,8 +514,9 @@ than the marketing: sequentially). A prompt's micro-batches now overlap across the two nodes: prefill measured **+18–26%** for gpt-oss-120b and +22% for Qwen3.8-27B NVFP4 against one node. A single decode stream has nothing to overlap and pays a - network round trip per token: 14% slower at best for gpt-oss-120b (see the - control below). + network round trip per token. For gpt-oss-120b that costs 8% through + `llama-bench` and ~15% through the binding with the client on the A725 + cores, and 25–30% left unpinned (see the control below). - **Tensor parallelism ("tp=2"): technically yes, practically no.** It runs and it is correct, and it is 2.7× slower on decode. See the verdict section. @@ -729,23 +731,61 @@ backend async (#18626), llama.cpp pipelines the prompt's micro-batches across the nodes, where it used to run them one node after the other. **Decode is slower** — a single stream has nothing to overlap and pays a network round trip per token on top of the same total compute: 14% at best through -`llama-bench`, ~30% through the binding's server. The spread on the -two-node rows is the worker's: the same worker served three `llama-bench` -clients in a row at 50.4, 41.5 and 50.5 tok/s, so restart it and re-measure -before believing any one two-node decode figure. +`llama-bench`, ~30% through the binding's server, with the client unpinned. +The spread on the two-node rows (one worker served three `llama-bench` clients +in a row at 50.4, 41.5 and 50.5 tok/s) was not the worker's, as this page used +to say. It comes from which cluster the *client* runs on, and pinning it +removes most of the decode cost; see the next section. -The worker binary matters less than that spread. `LlamaCppEx.stream/3` over +The worker binary matters less than that. `LlamaCppEx.stream/3` over two nodes, three fresh contexts per session, worker restarted between sessions: this library's `LlamaCppEx.RPC.Server` decoded at 38–48 tok/s (sessions at ~38 and ~38/47), upstream's `ggml-rpc-server` -(`rpc-worker.sh --upstream`) at 40–51 (~50 and ~40). Both land in one of two -bands per session; upstream's sat in the faster one more often over four -sessions, which is too few to call. +(`rpc-worker.sh --upstream`) at 40–51 (~50 and ~40). Both fall into the same +two bands. Load time is still the cost — 2–3× one node — because ~30 GB of weights cross the network and the client still reads and hashes every tensor to check the worker's cache. +### Pin the client to the little cores + +Two-node decode lands in one of two bands, ~44 or ~53 tok/s through +`llama-bench`, and the client's CPU cluster picks the band. The setup was +gpt-oss-120b over RDMA, upstream's worker restarted before every run, and +`llama-bench -dev CUDA0/RPC0 -n 128 -r 3`. Single-node is 59: + +| worker on | client on | decode t/s | +|---|---|---| +| X925 `5-9,15-19` | X925 `5-9,15-19` | 44.2, 44.5, 44.6, 44.1 | +| X925 | unpinned | 44.3, 53.2 (and ~44 in five more unpinned runs) | +| A725 `0-4,10-14` | unpinned | 44.0, 44.5 | +| X925 | **A725 `0-4,10-14`** | **54.0, 54.0, 53.9** | +| A725 | **A725** | **53.5** | +| A725 | X925 | 53.1 | + +The client's cluster decides the band. With the client on the A725 cores, +every run lands in the fast band. Leave it unpinned and the scheduler mostly +puts it on the X925 cores, which is the slow band. llama-bench's own CPU +threads do not explain it: `--poll 0` and `-t 1` change nothing. Kernel times +are identical in both bands on both nodes (`nsys`: 118 µs per expert matvec, +2.7 ms for the LM head). The extra ~4 ms per token is spent on the CPU and in +the network wait. Why the X925 cluster is slower here is not established. A +1-byte RDMA ping-pong favours the X925 (top of page), so the cause is not raw +link latency. + +The binding follows the same rule. `bench/spark_two_node.exs b1` with the +BEAM under `taskset -c 0-4,10-14` (`scripts/spark/remote.sh --little-cores`), +binding worker on its default cores, two sessions each: + +| client BEAM | single-node decode | two-node prefill | two-node decode | +|---|---|---|---| +| unpinned | 54.1, 55.0 | 2597, 2599 | 37.4, 38.5 | +| **A725 cores** | 55.0, 55.1 | 2587, 2593 | **47.1, 46.6** | + +That is **+25% two-node decode** at no cost to prefill or single-node decode. +**Run the client of a two-node setup on the A725 cores.** + ### RDMA versus TCP, and the 10 GbE LAN `GGML_RPC_NO_RDMA=1` on either peer keeps the connection on TCP diff --git a/scripts/spark/lib.sh b/scripts/spark/lib.sh index 845ec0d..efcf887 100755 --- a/scripts/spark/lib.sh +++ b/scripts/spark/lib.sh @@ -61,9 +61,11 @@ SPARK_TOOLCHAIN_DONOR="${SPARK_TOOLCHAIN_DONOR:-spark-1}" # --- CPU topology ------------------------------------------------------------ # The clusters are INTERLEAVED. X925 (performance) is 5-9,15-19 and A725 -# (efficiency) is 0-4,10-14, so the obvious `taskset -c 0-9` pins a job entirely -# to little cores. Measured: 1-byte RDMA ping-pong p50 21.5 us on cpu19 versus -# 29.1 us on cpu0. +# (efficiency) is 0-4,10-14, so the obvious `taskset -c 0-9` gets five of each. +# Measured: 1-byte RDMA ping-pong p50 21.5 us on cpu19 versus 29.1 us on cpu0 -- +# yet a two-node *client* decodes ~25% faster on the A725 cores (gpt-oss-120b, +# 37-38 -> 47 tok/s through the binding; docs/dgx-spark.md, "Pin the client to +# the little cores"). remote.sh --little-cores does that. SPARK_BIG_CORES="5-9,15-19" SPARK_LITTLE_CORES="0-4,10-14" SPARK_BIG_CORE_COUNT=10 diff --git a/scripts/spark/remote.sh b/scripts/spark/remote.sh index 63807a1..0dcf013 100755 --- a/scripts/spark/remote.sh +++ b/scripts/spark/remote.sh @@ -26,6 +26,8 @@ Options: (default: the synced repo; "-" for $HOME) --env K=V extra environment variable, repeatable --big-cores wrap the command in `taskset -c 5-9,15-19` (Cortex-X925) + --little-cores wrap the command in `taskset -c 0-4,10-14` (Cortex-A725): + where a two-node client decodes ~25% faster --tty allocate a remote tty --print print the remote script instead of running it USAGE @@ -35,6 +37,7 @@ login=0 tty=0 print_only=0 big_cores=0 +little_cores=0 forward_agent=0 dir="$SPARK_REMOTE_DIR" extra_env=() @@ -45,6 +48,7 @@ while [ $# -gt 0 ]; do --tty) tty=1; shift ;; --print) print_only=1; shift ;; --big-cores) big_cores=1; shift ;; + --little-cores) little_cores=1; shift ;; --forward-agent) forward_agent=1; shift ;; --dir) dir="${2:?--dir needs a path}"; shift 2 ;; --env) extra_env+=("${2:?--env needs K=V}"); shift 2 ;; @@ -60,8 +64,10 @@ done node=$1; shift spark_is_node "$node" || spark_die "unknown node '$node' (known: ${SPARK_NODES[*]})" +[ "$big_cores" -eq 1 ] && [ "$little_cores" -eq 1 ] && spark_die "--big-cores and --little-cores are exclusive" prefix=() [ "$big_cores" -eq 1 ] && prefix=(taskset -c "$SPARK_BIG_CORES") +[ "$little_cores" -eq 1 ] && prefix=(taskset -c "$SPARK_LITTLE_CORES") # Assemble the remote script. Every word is quoted here rather than left to # ssh's own re-splitting, which joins its arguments with spaces and would mangle From 760bcef876f8494b6496255a504201cb26d4d1b0 Mon Sep 17 00:00:00 2001 From: Niko Maroulis Date: Mon, 2 Nov 2026 13:22:48 -0500 Subject: [PATCH 22/49] docs: RPC client wake-ups explain the two-node decode bands; fix branch --- CHANGELOG.md | 6 +++++- README.md | 4 +++- docs/dgx-spark.md | 46 +++++++++++++++++++++++++++++++++++++++------- 3 files changed, 47 insertions(+), 9 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 22b1995..f0d1dbf 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -81,7 +81,11 @@ numbers behind the entries below. Unpinned or on the X925 cores, decode over RPC sits in a band ~25% slower: gpt-oss-120b layer-split decoded 37–38 tok/s against 47 through the binding, 44 against 54 through `llama-bench`. The decode spread the docs blamed on the - worker came from the client's placement. + worker came from the client's placement: ggml's RPC client hands every + command between two threads, and those wake-ups are slow on the X925 + cores. Upstream fix on `nyo16/llama.cpp` branch `rpc-client-spin-wait`: + 57.6 tok/s on any cores through `llama-bench` (single node 59), 50.6–50.8 + through the binding unpinned. ## v0.8.66 diff --git a/README.md b/README.md index bf34ab9..e30c71f 100644 --- a/README.md +++ b/README.md @@ -1371,7 +1371,9 @@ Three notes, all learned the hard way: - **Over two nodes, pin the client to the Cortex-A725 cores** (`taskset -c 0-4,10-14`). Unpinned, the BEAM mostly lands on the X925 cores, and decode over RPC runs ~25% slower: gpt-oss-120b layer-split decoded - 37–38 tok/s unpinned against 47 pinned, with the same prefill. + 37–38 tok/s unpinned against 47 pinned, with the same prefill. The cause is + thread wake-ups in ggml's RPC client. A fix on `nyo16/llama.cpp` + (`rpc-client-spin-wait`) gives 50.6–50.8 unpinned, against 55 single-node. ### Single-sequence generation (Qwen3-4B Q4_K_M) diff --git a/docs/dgx-spark.md b/docs/dgx-spark.md index c30343f..2d4e24c 100644 --- a/docs/dgx-spark.md +++ b/docs/dgx-spark.md @@ -417,9 +417,12 @@ suite passes on the branch (19246/19246). ### Through the binding `nyo16/llama.cpp` branch `spark-all` is `785322d17`, the vendored commit, plus -these four CUDA commits, the `draft-ctx-other-devices` fix and the -`rpc-add-server-no-abort` fix. To test it, copy the checkout on spark-1 and -replace `vendor/llama.cpp` with the branch tree. Then remove the +these four CUDA commits, the `draft-ctx-other-devices` and +`rpc-add-server-no-abort` fixes, and the RPC client spin +(`rpc-client-spin-wait`, see the two-node section). The prefill numbers below +predate the RPC commit, which does not touch single-node runs. To test it, +copy the checkout on spark-1 and replace `vendor/llama.cpp` with the branch +tree. Then remove the `_build/*/lib/llama_cpp_ex/obj/llama_build-*` directories and run `mix compile`. In that build, `Context.decode/2` of a 2048-token prompt (`n_ubatch: 512`, flash attention, median of 5) gives: @@ -770,9 +773,7 @@ puts it on the X925 cores, which is the slow band. llama-bench's own CPU threads do not explain it: `--poll 0` and `-t 1` change nothing. Kernel times are identical in both bands on both nodes (`nsys`: 118 µs per expert matvec, 2.7 ms for the LM head). The extra ~4 ms per token is spent on the CPU and in -the network wait. Why the X925 cluster is slower here is not established. A -1-byte RDMA ping-pong favours the X925 (top of page), so the cause is not raw -link latency. +the network wait; the next section has the cause. The binding follows the same rule. `bench/spark_two_node.exs b1` with the BEAM under `taskset -c 0-4,10-14` (`scripts/spark/remote.sh --little-cores`), @@ -784,7 +785,38 @@ binding worker on its default cores, two sessions each: | **A725 cores** | 55.0, 55.1 | 2587, 2593 | **47.1, 46.6** | That is **+25% two-node decode** at no cost to prefill or single-node decode. -**Run the client of a two-node setup on the A725 cores.** +On the vendored llama.cpp, **run the client of a two-node setup on the A725 +cores.** + +### The cause, and a fix that makes pinning unnecessary + +Every RPC command the client sends is two thread handoffs. The calling thread +queues it and blocks on a future. The RPC dispatcher thread wakes from its +queue, does the network round trip, then wakes the caller. The dispatcher +already busy-spins on its queue, but only while a `-sm tensor` communicator +holds it. For a layer split, each handoff is a futex wake of an idle core, +and a token takes several commands. On the X925 cores those wakes add up to +the ~4 ms per token: removing them, below, recovers it. Why the A725 cores +wake faster is not established. + +Branch `rpc-client-spin-wait` on `nyo16/llama.cpp` (also merged into +`spark-all`) spins both sides whenever a command arrived in the last 100 ms: +the dispatcher on its queue, and the caller on its future, up to 100 ms +before blocking. An idle client still sleeps. With that client and the same +unpatched worker: + +| client | `llama-bench` decode, before | after | +|---|---|---| +| X925 cores | 44.2–44.6 | **57.6** | +| unpinned | 44.0–44.5 (one run in seven 53.2) | **57.4, 57.6** | +| A725 cores | 53.5–54.0 | **57.3** | +| single node | 59.0 | — | + +Prefill is unchanged (pp1024 2487–2513). Two-node decode now costs 2–3% against +one node, wherever the client runs. Through the binding (`spark-all` vendored, +BEAM unpinned, `b1`, two sessions), two-node decode is **50.6 and 50.8 tok/s** +against 54.7 and 55.2 single-node, where the vendored build gives 37.4–38.5 +unpinned. Two-node prefill rises to 2731–2750 with the CUDA commits. ### RDMA versus TCP, and the 10 GbE LAN From 6bf8d100fd36725b31a8578f681e1f834ab0a334 Mon Sep 17 00:00:00 2001 From: Niko Maroulis Date: Mon, 2 Nov 2026 13:43:19 -0500 Subject: [PATCH 23/49] docs: worker binary gap once the RPC client is fixed --- docs/dgx-spark.md | 12 ++++++++++++ 1 file changed, 12 insertions(+) diff --git a/docs/dgx-spark.md b/docs/dgx-spark.md index 2d4e24c..93284d0 100644 --- a/docs/dgx-spark.md +++ b/docs/dgx-spark.md @@ -818,6 +818,18 @@ BEAM unpinned, `b1`, two sessions), two-node decode is **50.6 and 50.8 tok/s** against 54.7 and 55.2 single-node, where the vendored build gives 37.4–38.5 unpinned. Two-node prefill rises to 2731–2750 with the CUDA commits. +With the client fixed, the worker binary shows up. Against the same patched +`llama-bench` client, this library's `LlamaCppEx.RPC.Server` decodes at +53.8–54.0 and upstream's `ggml-rpc-server` at 57.6, four restarts each. The +binding client gives the same split: 50.6–50.8 against 53.9. Both workers run +the same server code from the same tree. BEAM scheduler flags (`+sbwt none`, +`+S 1:1`) change nothing, and the GPU clocks the same in both, 2411 MHz. Yet +the worker's memory-bound kernels run ~5% slower inside the BEAM (`nsys`: 123.7 +against 117–118 µs per expert matvec, 2.84 against 2.71–2.76 ms for the LM +head). That points at where the weights land in memory, the same family as +the per-load decode spread on one node, but the cause is not established. For +the last 7% of two-node decode, run `rpc-worker.sh --upstream`. + ### RDMA versus TCP, and the 10 GbE LAN `GGML_RPC_NO_RDMA=1` on either peer keeps the connection on TCP From 925dfa777a94f7b7de5e14fd304e517081635561 Mon Sep 17 00:00:00 2001 From: Niko Maroulis Date: Mon, 2 Nov 2026 13:51:29 -0500 Subject: [PATCH 24/49] docs: spec decoding on the spark-all build --- docs/dgx-spark.md | 8 +++++--- 1 file changed, 5 insertions(+), 3 deletions(-) diff --git a/docs/dgx-spark.md b/docs/dgx-spark.md index 93284d0..7a7c959 100644 --- a/docs/dgx-spark.md +++ b/docs/dgx-spark.md @@ -432,9 +432,11 @@ tree. Then remove the | Qwen3.8-27B NVFP4 | 1304 tok/s | **1560 tok/s** (+20%) | | gpt-oss-120b MXFP4 | 2352 tok/s | **2583 tok/s** (+10%) | -`scripts/spark/e2e.exs single` passes 12/12 on that build. The binding is -unaffected by the swap, but a release would have to vendor the branch or wait -for upstream. +`scripts/spark/e2e.exs single` passes 12/12 on that build. Speculative +decoding on Qwen3.8-27B NVFP4 (`bench/spark_spec.exs`) runs at plain 14.3, MTP +`n_draft: 2` 26.5 and DFlash 2 `n_draft: 7` 45.9 tok/s, against 14.3 / 26.8 / +44.2 vendored. No source change in the binding is needed for the swap, but a +release would have to vendor the branch or wait for upstream. ## Speculative decoding: MTP, DFlash 2, DSpark From 7a70232d525033f8efd4a849bd441464186468a6 Mon Sep 17 00:00:00 2001 From: Niko Maroulis Date: Mon, 2 Nov 2026 13:59:10 -0500 Subject: [PATCH 25/49] solutions: two-node decode bands come from RPC client wake-ups --- ...de-decode-bands-client-wakeups-20261102.md | 54 +++++++++++++++++++ 1 file changed, 54 insertions(+) create mode 100644 .claude/solutions/phoenix-issues/rpc-two-node-decode-bands-client-wakeups-20261102.md diff --git a/.claude/solutions/phoenix-issues/rpc-two-node-decode-bands-client-wakeups-20261102.md b/.claude/solutions/phoenix-issues/rpc-two-node-decode-bands-client-wakeups-20261102.md new file mode 100644 index 0000000..290c129 --- /dev/null +++ b/.claude/solutions/phoenix-issues/rpc-two-node-decode-bands-client-wakeups-20261102.md @@ -0,0 +1,54 @@ +--- +module: "ggml-rpc client (vendor/llama.cpp/ggml/src/ggml-rpc/ggml-rpc.cpp), two-node layer split" +date: "2026-11-02" +problem_type: performance +component: rpc +symptoms: + - "Two-node (RPC layer split) decode sits in one of two bands per client process: gpt-oss-120b ~44 or ~53 tok/s via llama-bench, ~38 or ~47 via the binding" + - "The same worker serves consecutive clients at different speeds; restarting the worker does not settle it" + - "Kernel times (nsys) are identical in both bands on both nodes; the extra ~4 ms per token is CPU-side" +root_cause: "Every RPC command is two thread handoffs: the caller blocks on a std::future while the dispatcher thread, woken from its queue, does the network round trip and wakes the caller. The dispatcher only busy-spins while a -sm tensor communicator holds it (busy_spin_acquire), so for a layer split each handoff is a futex wake of an idle core. On GB10's Cortex-X925 cores those wakes are slow enough to cost ~4 ms per token; on the A725 cores they are not (why is not established)." +severity: medium +tags: [rpc, ggml-rpc, dgx-spark, gb10, two-node, decode, cpu-affinity, latency] +related_solutions: [rpc-add-server-aborts-vm-dispatcher-20261102] +--- + +# Two-node decode bands: RPC client thread wake-ups + +## Symptoms + +`llama-bench --rpc ... -dev CUDA0/RPC0 -n 128` on two DGX Sparks gave 44 or 53 +tok/s for gpt-oss-120b on different runs (single node 59). The docs had +blamed the worker for the spread. + +## Investigation + +- `nsys` on the worker in a fast and a slow session: same kernel times (118 + µs per MXFP4 expert matvec, 2.7 ms LM head), same per-token + `cudaStreamSynchronize` total. Same on the client. So not GPU, not clocks. +- `taskset` matrix (worker cores x client cores, upstream worker restarted + per run): the client on the A725 cores (0-4,10-14) was always fast; on the + X925 cores (5-9,15-19) slow; unpinned mostly slow. `--poll 0`, `-t 1`, + BEAM `+sbwt none` changed nothing. +- An env-gated hack spinning the dispatcher queue and the callers' future + waits gave 57.6 on any cores: the wake-ups were the cost. + +## Fix + +- Upstream patch, `nyo16/llama.cpp` branch `rpc-client-spin-wait` (merged + into `spark-all`): spin the dispatcher whenever a command arrived in the last + `RPC_BUSY_SPIN_IDLE_TIME` (100 ms), and spin callers on their future for up + to that long before blocking; `busy_spin_acquire/release` removed. 57.3-57.6 + tok/s on X925, A725 or unpinned; prefill unchanged. +- Without the patch (vendored llama.cpp): run the client on the A725 cores, + `scripts/spark/remote.sh --little-cores` (+25% two-node decode through the + binding, 37-38 -> 47 tok/s). + +## Lessons + +- A latency microbenchmark (1-byte RDMA ping-pong favours the X925) did not + predict the end-to-end result; measure the decode loop itself. +- A bimodal per-process number with identical kernel times is a CPU-side + handoff, not the GPU. Profile both nodes before blaming either. +- `pkill -f ` over ssh matches the ssh shell's own command line and + kills it (exit 255); use `pkill -x` or a pid. From 59c62208d3d242f738e01268a750a97a8a6e40e5 Mon Sep 17 00:00:00 2001 From: Niko Maroulis Date: Mon, 2 Nov 2026 14:03:38 -0500 Subject: [PATCH 26/49] docs: with the RPC client fixed, dense two-node decode beats one node and RDMA shows --- docs/dgx-spark.md | 33 +++++++++++++++++++++++---------- 1 file changed, 23 insertions(+), 10 deletions(-) diff --git a/docs/dgx-spark.md b/docs/dgx-spark.md index 7a7c959..7bf29a8 100644 --- a/docs/dgx-spark.md +++ b/docs/dgx-spark.md @@ -820,6 +820,19 @@ BEAM unpinned, `b1`, two sessions), two-node decode is **50.6 and 50.8 tok/s** against 54.7 and 55.2 single-node, where the vendored build gives 37.4–38.5 unpinned. Two-node prefill rises to 2731–2750 with the CUDA commits. +On the dense model, a two-node split no longer costs any decode. For +Qwen3.8-27B NVFP4 (`llama-bench -p 512 -n 128`, RDMA, fresh upstream worker), +the unpatched client decodes at 13.86 tok/s over two nodes. `spark-all` +decodes at **14.85**, against 14.35 on one node. pp512 is a single +micro-batch, so it does not pipeline, and it stays below one node: 1370 +against 1539. + +With the wake-ups gone, the transport becomes visible again. With the +`spark-all` client and gpt-oss-120b, decode is **57.6 tok/s over RDMA, 53.0 over +TCP on the same 200 GbE link, and 51.8 over the 10 GbE LAN**. The next +section's "no measurable difference" result was measured under the ~4 ms +wake-up cost, which hid the transport. + With the client fixed, the worker binary shows up. Against the same patched `llama-bench` client, this library's `LlamaCppEx.RPC.Server` decodes at 53.8–54.0 and upstream's `ggml-rpc-server` at 57.6, four restarts each. The @@ -846,16 +859,16 @@ the link, two sessions per transport: | TCP, 200 GbE fabric | 89–91 | 419–422 | 2593–2615 | 36.9–37.6 | | TCP, 10 GbE LAN | 76–77 | 422–429 | 2540–2585 | 38.8–39.1 | -**On this llama.cpp you lose nothing measurable without RDMA**, and nothing -on the 10 GbE LAN either: TTFT, prefill and decode overlap across the three -transports, and load time did not favour RDMA (the LAN was quickest in this -session; RDMA loaded in 54 s in an earlier one), so it is dominated by the -client reading and hashing the file, not by the wire. -Per-token traffic -across a layer split is one activation row, and the async dispatcher hides the -round trip; the −27% prefill / −11% decode TCP penalty measured at b10362 is -gone. RDMA still activates by default on the fabric and costs nothing, so -leave it on — but a TCP fallback, even over the LAN, is not a cliff. +**On the vendored llama.cpp, you lose nothing measurable without RDMA**, and +nothing on the 10 GbE LAN either. TTFT, prefill and decode overlap across the +three transports. Load time did not favour RDMA either: the LAN was quickest in +this session, and RDMA loaded in 54 s in an earlier one. So load time is +dominated by the client reading and hashing the file, not by the wire. +Per-token traffic across a layer split is one activation row. The −27% +prefill / −11% decode TCP penalty measured at b10362 is gone. **That changes +once the RPC client's wake-ups are fixed** (previous section): decode then +reads 57.6 over RDMA, 53.0 over TCP on the fabric and 51.8 on the LAN. Leave +RDMA on. A TCP fallback, even over the LAN, is still not a cliff. To confirm which one you got, look at the worker's log with `GGML_RPC_DEBUG=1`: From 7532fe73b0914242ff5c17ed6b64c8e6b9007bdc Mon Sep 17 00:00:00 2001 From: Niko Maroulis Date: Mon, 2 Nov 2026 14:03:49 -0500 Subject: [PATCH 27/49] docs: two-node speed summary reflects the RPC client fix --- docs/dgx-spark.md | 19 +++++++++++-------- 1 file changed, 11 insertions(+), 8 deletions(-) diff --git a/docs/dgx-spark.md b/docs/dgx-spark.md index 7bf29a8..8890d95 100644 --- a/docs/dgx-spark.md +++ b/docs/dgx-spark.md @@ -513,15 +513,18 @@ than the marketing: - **Capacity: yes.** A model that does not fit in 130 GB runs. Nothing else on this pair will run it at all. -- **Speed: prefill yes, decode no.** Since llama.cpp #18626 the RPC backend - implements async compute and events, so llama.cpp enables **pipeline - parallelism** across an RPC split (it used to refuse, and the nodes ran - sequentially). A prompt's micro-batches now overlap across the two nodes: - prefill measured **+18–26%** for gpt-oss-120b and +22% for Qwen3.8-27B NVFP4 - against one node. A single decode stream has nothing to overlap and pays a - network round trip per token. For gpt-oss-120b that costs 8% through +- **Speed: prefill yes, decode roughly even.** Since llama.cpp #18626, the RPC + backend implements async compute and events, so llama.cpp enables + **pipeline parallelism** across an RPC split. It used to refuse, and the + nodes ran one after the other. A prompt's micro-batches now overlap across + the two nodes: prefill measured **+18–26%** for gpt-oss-120b and +22% for + Qwen3.8-27B NVFP4 against one node. A single decode stream has nothing to + overlap. On the vendored llama.cpp, it pays thread wake-ups in the RPC + client on every command. For gpt-oss-120b, that costs 8% through `llama-bench` and ~15% through the binding with the client on the A725 - cores, and 25–30% left unpinned (see the control below). + cores, and 25–30% left unpinned. With the RPC client fix on `spark-all`, it + costs 2–3%, and the dense NVFP4 model decodes faster on two nodes than on + one (see the control below). - **Tensor parallelism ("tp=2"): technically yes, practically no.** It runs and it is correct, and it is 2.7× slower on decode. See the verdict section. From 9eb0f7c8212c31f39b7b84c656117832b29dfbb2 Mon Sep 17 00:00:00 2001 From: Niko Maroulis Date: Mon, 2 Nov 2026 14:14:09 -0500 Subject: [PATCH 28/49] docs: 235B two-node decode with the RPC client fix --- docs/dgx-spark.md | 7 +++++-- 1 file changed, 5 insertions(+), 2 deletions(-) diff --git a/docs/dgx-spark.md b/docs/dgx-spark.md index 8890d95..4d04f0a 100644 --- a/docs/dgx-spark.md +++ b/docs/dgx-spark.md @@ -710,8 +710,11 @@ There is no percentage to quote here, and that is the point: on one Spark this model does not run slowly, it takes the machine's memory out from under the OOM killer. On two it runs at **12–14 tokens/s**, which is a usable interactive speed for a 235B model, and with pipelining its prefill is 1.8× what it was. (The -decode gap between the two rows is within the load-to-load spread described -under the control below.) +decode gap between the two rows is the client wake-up band described under +the control below.) Through `llama-bench` (`-p 512 -n 64`, upstream worker +restarted per run), the vendored client decodes at 13.35 tok/s and the +`spark-all` client with the RPC fix at **14.27**, with the same pp512 (475, +479). The cold load is nine minutes, because ~71 GB of weights cross the fabric. Budget for it, keep the worker's tensor cache on, and do not restart casually. From a2698718f5d092a93b01ebe70c70bf2a9305780d Mon Sep 17 00:00:00 2001 From: Niko Maroulis Date: Mon, 2 Nov 2026 14:15:22 -0500 Subject: [PATCH 29/49] docs: index of the llama.cpp branches --- docs/dgx-spark.md | 11 +++++++++++ 1 file changed, 11 insertions(+) diff --git a/docs/dgx-spark.md b/docs/dgx-spark.md index 4d04f0a..2743c80 100644 --- a/docs/dgx-spark.md +++ b/docs/dgx-spark.md @@ -5,6 +5,17 @@ across two nodes. Everything here is measured on the hardware rather than inferred from spec sheets; where a number differs from the marketing figure, the measurement wins and the reason is given. +The work behind this page produced four llama.cpp branches on +`nyo16/llama.cpp`, each based on `785322d17`, the vendored commit. None of them +is in the vendored tree. A fifth, `spark-all`, merges all four. + +| branch | effect on GB10 | section | +|---|---|---| +| `cuda-mmq-src1-reuse` | NVFP4 prefill +19–20% (src1 reuse, weight-scale fold, SWIGLU in MMQ); gpt-oss-120b prefill +8% (expert biases) | Qwen3.8-27B NVFP4, gpt-oss-120b prefill | +| `rpc-client-spin-wait` | two-node decode +30% unpinned (gpt-oss-120b 44 → 57.6 tok/s, single node 59) | The cause, and a fix | +| `rpc-add-server-no-abort` | an unreachable worker returns an error instead of aborting | Five things, #1 | +| `draft-ctx-other-devices` | DFlash with the target split over RPC | Speculative decoding across two nodes | + ## The machine | | | From f540d2dba2321cb167a2a9110fa11eaa1dd9fd48 Mon Sep 17 00:00:00 2001 From: Niko Maroulis Date: Mon, 2 Nov 2026 14:22:09 -0500 Subject: [PATCH 30/49] docs: two-node concurrency with the RPC client fix --- docs/dgx-spark.md | 29 ++++++++++++++++------------- 1 file changed, 16 insertions(+), 13 deletions(-) diff --git a/docs/dgx-spark.md b/docs/dgx-spark.md index 2743c80..f6a4795 100644 --- a/docs/dgx-spark.md +++ b/docs/dgx-spark.md @@ -932,19 +932,22 @@ gpt-oss-120b through `bench/spark_overhead.exs` with `SPARK_RPC_ENDPOINT` set (every load split 50/50 over the fabric), against the same bench on one node; per-stream decode, then aggregate: -| streams | one node | two nodes | -|---|---|---| -| 1 (`stream/3`) | 57.0 | 47.8 | -| 1 (server) | 55.9 | 45.7 | -| 4 | 23.8 / **91** | 18.2 / **70** | -| 8 | 13.5 / **105** | 11.8 / **92** | - -Two nodes keep 77–88% of one node's throughput at every concurrency, so the -per-token round trip does not grow with the batch. (This section used to -quote 49.5 / 44.7 / 44.3 for `n_parallel` 1 / 4 / 8 from `spark_two_node.exs -b4`, which allocates that many slots but sends one request, so it measured -load-to-load variation rather than concurrency.) A MoE does not batch well on -either: each extra stream routes to different experts. +| streams | one node | two nodes | two nodes, `spark-all` client | +|---|---|---|---| +| 1 (`stream/3`) | 57.0 | 47.8 | **56.1** | +| 1 (server) | 55.9 | 45.7 | **55.2** | +| 4 | 23.8 / **91** | 18.2 / **70** | 23.9 / **93** | +| 8 | 13.5 / **105** | 11.8 / **92** | 12.8 / **99** | + +On the vendored client, two nodes keep 77–88% of one node's throughput at +every concurrency, so the per-token round trip does not grow with the batch. +The last column is the `spark-all` build, with the RPC client fix, against +upstream's worker, the BEAM on the X925 cores (`--big-cores`). It keeps +95–102%. (This section used to quote 49.5 / 44.7 / 44.3 for `n_parallel` +1 / 4 / 8 from `spark_two_node.exs b4`, which allocates that many slots but +sends one request. So it measured load-to-load variation rather than +concurrency.) A MoE does not batch well on either: each extra stream routes +to different experts. ### The decode fast path is holding From 22c4d446e26f4e3e43179f37d35803ff910dcd56 Mon Sep 17 00:00:00 2001 From: Niko Maroulis Date: Mon, 2 Nov 2026 14:24:47 -0500 Subject: [PATCH 31/49] docs: two-node speculative decoding with the RPC client fix --- docs/dgx-spark.md | 19 ++++++++++--------- 1 file changed, 10 insertions(+), 9 deletions(-) diff --git a/docs/dgx-spark.md b/docs/dgx-spark.md index f6a4795..b014ee1 100644 --- a/docs/dgx-spark.md +++ b/docs/dgx-spark.md @@ -906,15 +906,16 @@ Qwen3.8-27B NVFP4 split 50/50 over the fabric, one 256-token greedy chat completion, three runs each through `LlamaCppEx.MTP` (not the four-prompt harness above, so acceptance is not comparable with the one-node table): -| config | decode t/s | acceptance | -|---|---|---| -| plain | 14.02–14.03 | — | -| MTP `n_draft: 3` | 17.7–19.7 | 50% | -| DFlash 2 `n_draft: 7` | **22.2–22.4** | 27% | - -DFlash still pays 1.6× across two nodes. The drafter must be loaded on every -device the target uses, because it computes with the target's embeddings and -LM head: with the target on `["CUDA0", "RPC0"]` and the drafter on `CUDA0` +| config | decode t/s | acceptance | `spark-all` client, upstream worker | +|---|---|---|---| +| plain | 14.02–14.03 | — | **14.79–14.81** | +| MTP `n_draft: 3` | 17.7–19.7 | 50% | not run | +| DFlash 2 `n_draft: 7` | **22.2–22.4** | 27% | **27.8–27.9** (29%) | + +DFlash still pays 1.6× across two nodes, and 1.9× with the RPC client fix. With +the fix, plain decode over two nodes beats one node's 14.3. The drafter must be +loaded on every device the target uses, because it computes with the target's +embeddings and LM head: with the target on `["CUDA0", "RPC0"]` and the drafter on `CUDA0` alone, upstream aborts the process ("pre-allocated tensor (output.weight) in a buffer (RPC0) that cannot run the operation") — `llama-server --spec-draft-device CUDA0` does it too. `MTP.init/2` refuses that pairing; From ffcecb1ebbdf07628850c4f052010c3d36a86995 Mon Sep 17 00:00:00 2001 From: Niko Maroulis Date: Mon, 2 Nov 2026 14:33:57 -0500 Subject: [PATCH 32/49] docs: -sm tensor across two nodes with the RPC client fix --- docs/dgx-spark.md | 9 +++++++++ 1 file changed, 9 insertions(+) diff --git a/docs/dgx-spark.md b/docs/dgx-spark.md index b014ee1..97df547 100644 --- a/docs/dgx-spark.md +++ b/docs/dgx-spark.md @@ -1004,6 +1004,15 @@ Essentially free. So the Meta device is not the problem. Now two nodes: It runs, and the output is byte-identical to the layer-split reference. It is **2.7× slower on decode and 23× slower on prefill**. +At `785322d17` the RPC backend has its own pairwise communicator for this +(#26610, `ggml_backend_rpc_comm_init`), so the next section describes the older +commit. Re-measured on gpt-oss-120b (`llama-bench -sm tensor -p 512 -n 64`, +fresh upstream worker), the vendored client decodes at 8.9 tok/s with pp512 +1135. The `spark-all` client, whose RPC fix also spins the callers that the +communicator's own spin left blocking, decodes at **24.1** with pp512 1553. +That is 2.7× better, and still less than half of a layer split's 57.6. The +verdict below stands. + ## Why, and why the comm-mode knob cannot help `ggml_backend_cuda_comm_init` returns `nullptr` the moment **any** member backend From 60627e4ae40b9f4b78d3e0c310bdd27d4652ed7e Mon Sep 17 00:00:00 2001 From: Niko Maroulis Date: Mon, 2 Nov 2026 14:36:49 -0500 Subject: [PATCH 33/49] docs: test coverage of the spark-all build --- docs/dgx-spark.md | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/docs/dgx-spark.md b/docs/dgx-spark.md index 97df547..a8fa6b8 100644 --- a/docs/dgx-spark.md +++ b/docs/dgx-spark.md @@ -443,7 +443,10 @@ tree. Then remove the | Qwen3.8-27B NVFP4 | 1304 tok/s | **1560 tok/s** (+20%) | | gpt-oss-120b MXFP4 | 2352 tok/s | **2583 tok/s** (+10%) | -`scripts/spark/e2e.exs single` passes 12/12 on that build. Speculative +`scripts/spark/e2e.exs single` passes 12/12 on that build. So do the test +suite's `smoke`, `embeddings`, `tools` and `decision` tags (602 tests), `mtp` and +`dflash` (458), `rpc_live` against a worker, `vm_exit_test.exs`, and +`rpc_check.exs` over the fabric (VM exit 0). Speculative decoding on Qwen3.8-27B NVFP4 (`bench/spark_spec.exs`) runs at plain 14.3, MTP `n_draft: 2` 26.5 and DFlash 2 `n_draft: 7` 45.9 tok/s, against 14.3 / 26.8 / 44.2 vendored. No source change in the binding is needed for the swap, but a From f88bb23bcf8e40c394d0bb545051783f74ead2cd Mon Sep 17 00:00:00 2001 From: Niko Maroulis Date: Mon, 2 Nov 2026 14:36:56 -0500 Subject: [PATCH 34/49] docs: note the bge-small embed_batch tolerance miss on CUDA --- docs/dgx-spark.md | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/docs/dgx-spark.md b/docs/dgx-spark.md index a8fa6b8..b21e8ec 100644 --- a/docs/dgx-spark.md +++ b/docs/dgx-spark.md @@ -446,7 +446,10 @@ tree. Then remove the `scripts/spark/e2e.exs single` passes 12/12 on that build. So do the test suite's `smoke`, `embeddings`, `tools` and `decision` tags (602 tests), `mtp` and `dflash` (458), `rpc_live` against a worker, `vm_exit_test.exs`, and -`rpc_check.exs` over the fabric (VM exit 0). Speculative +`rpc_check.exs` over the fabric (VM exit 0). The embeddings run used +Qwen3-Embedding-0.6B. With bge-small-en-v1.5 Q8_0, `embed_batch matches +per-text embed` fails on CUDA by 0.0027 against its 0.001 bound, on the +vendored tree as well, and passes on the CPU backend. Speculative decoding on Qwen3.8-27B NVFP4 (`bench/spark_spec.exs`) runs at plain 14.3, MTP `n_draft: 2` 26.5 and DFlash 2 `n_draft: 7` 45.9 tok/s, against 14.3 / 26.8 / 44.2 vendored. No source change in the binding is needed for the swap, but a From 8fccfb5c7b532733041eca44224018a64770e61b Mon Sep 17 00:00:00 2001 From: Niko Maroulis Date: Mon, 2 Nov 2026 14:37:24 -0500 Subject: [PATCH 35/49] docs: bge-small CUDA gap is backend numerics, not batching --- docs/dgx-spark.md | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/docs/dgx-spark.md b/docs/dgx-spark.md index b21e8ec..8739de3 100644 --- a/docs/dgx-spark.md +++ b/docs/dgx-spark.md @@ -449,7 +449,10 @@ suite's `smoke`, `embeddings`, `tools` and `decision` tags (602 tests), `mtp` an `rpc_check.exs` over the fabric (VM exit 0). The embeddings run used Qwen3-Embedding-0.6B. With bge-small-en-v1.5 Q8_0, `embed_batch matches per-text embed` fails on CUDA by 0.0027 against its 0.001 bound, on the -vendored tree as well, and passes on the CPU backend. Speculative +vendored tree as well, and passes on the CPU backend. Batching is not the +cause. Per-text embeddings on CUDA already differ from CPU by 0.0026, with +elements up to 0.42. The CUDA backend's numerics on this BERT simply exceed a +bound calibrated on CPU. Speculative decoding on Qwen3.8-27B NVFP4 (`bench/spark_spec.exs`) runs at plain 14.3, MTP `n_draft: 2` 26.5 and DFlash 2 `n_draft: 7` 45.9 tok/s, against 14.3 / 26.8 / 44.2 vendored. No source change in the binding is needed for the swap, but a From d1164d5ebbcfbc08ec0f42c1244bcd134f63dbbb Mon Sep 17 00:00:00 2001 From: Niko Maroulis Date: Mon, 2 Nov 2026 14:40:31 -0500 Subject: [PATCH 36/49] docs: MoE expert matvec runs ~4% slower inside the BEAM --- docs/dgx-spark.md | 10 ++++++++++ 1 file changed, 10 insertions(+) diff --git a/docs/dgx-spark.md b/docs/dgx-spark.md index 8739de3..a7beea5 100644 --- a/docs/dgx-spark.md +++ b/docs/dgx-spark.md @@ -348,6 +348,16 @@ step, and that serial dependency is the 8%. Upstream's `--backend-sampling` exposed. Tuning on this machine is therefore model and drafter choice, not the binding. +The one gap that remains is on MoE decode, and it is inside the GPU kernels. +gpt-oss-120b, 256 greedy tokens: `LlamaCppEx.stream/3` gives 55.5–55.9 tok/s +and `llama-bench` tg256 gives 57.8. Under `nsys`, the expert matvec (MXFP4 +`mul_mat_vec_q`, 55k calls) averages **123.0 µs in the BEAM against 118.1 µs** +in `llama-bench`, while the dense LM head is equal (2.75 against 2.74 ms). The +RPC worker shows the same split, 123.7 against 117–118 µs (two-node section). +Same kernels, same clocks, and only the scattered expert reads slow down. That +points at how the weight memory is mapped inside a BEAM process; the cause is +not established. + ## Qwen3.8-27B NVFP4 `esatapedico/Qwen3.8-27B-NVFP4-MTP-GGUF`, `MID-HIGH` tier: every attention and From 81554a34cca018feb84513893e4c9e12c75c3f66 Mon Sep 17 00:00:00 2001 From: Niko Maroulis Date: Mon, 2 Nov 2026 14:48:37 -0500 Subject: [PATCH 37/49] docs: correct the MoE kernel-gap claims (nsys artifact); binding single-node MoE decode within 1% --- docs/dgx-spark.md | 30 ++++++++++++++---------------- 1 file changed, 14 insertions(+), 16 deletions(-) diff --git a/docs/dgx-spark.md b/docs/dgx-spark.md index a7beea5..905f799 100644 --- a/docs/dgx-spark.md +++ b/docs/dgx-spark.md @@ -348,15 +348,13 @@ step, and that serial dependency is the 8%. Upstream's `--backend-sampling` exposed. Tuning on this machine is therefore model and drafter choice, not the binding. -The one gap that remains is on MoE decode, and it is inside the GPU kernels. -gpt-oss-120b, 256 greedy tokens: `LlamaCppEx.stream/3` gives 55.5–55.9 tok/s -and `llama-bench` tg256 gives 57.8. Under `nsys`, the expert matvec (MXFP4 -`mul_mat_vec_q`, 55k calls) averages **123.0 µs in the BEAM against 118.1 µs** -in `llama-bench`, while the dense LM head is equal (2.75 against 2.74 ms). The -RPC worker shows the same split, 123.7 against 117–118 µs (two-node section). -Same kernels, same clocks, and only the scattered expert reads slow down. That -points at how the weight memory is mapped inside a BEAM process; the cause is -not established. +The same holds for MoE decode. gpt-oss-120b, 256 greedy tokens, five fresh +processes: `LlamaCppEx.stream/3` gives 57.0–57.3 tok/s with the default load +mode, `use_mmap: false` or `use_direct_io: true` alike, against 57.8 for +`llama-bench` tg256. (Under `nsys --cuda-graph-trace=node` the binding drops +to 55.5–55.9 and its expert matvecs read 123 µs against `llama-bench`'s 118 µs. +That gap is the profiler's, so do not compare kernel times across processes +profiled this way.) ## Qwen3.8-27B NVFP4 @@ -873,13 +871,13 @@ With the client fixed, the worker binary shows up. Against the same patched `llama-bench` client, this library's `LlamaCppEx.RPC.Server` decodes at 53.8–54.0 and upstream's `ggml-rpc-server` at 57.6, four restarts each. The binding client gives the same split: 50.6–50.8 against 53.9. Both workers run -the same server code from the same tree. BEAM scheduler flags (`+sbwt none`, -`+S 1:1`) change nothing, and the GPU clocks the same in both, 2411 MHz. Yet -the worker's memory-bound kernels run ~5% slower inside the BEAM (`nsys`: 123.7 -against 117–118 µs per expert matvec, 2.84 against 2.71–2.76 ms for the LM -head). That points at where the weights land in memory, the same family as -the per-load decode spread on one node, but the cause is not established. For -the last 7% of two-node decode, run `rpc-worker.sh --upstream`. +the same server code from the same tree and build flags. Several things change +nothing: BEAM scheduler flags (`+sbwt none`, `+S 1:1`), no super carriers +(`+MMscs 0 +MMmcs 0`), and running the worker on the A725 cores instead of the +X925s. GPU clocks are the same in both, 2411 MHz. Kernel times under `nsys` do +not settle it, because profiling slows the BEAM process more than a bare +binary (one-node section). The cause is not established. For the last 7% of +two-node decode, run `rpc-worker.sh --upstream`. ### RDMA versus TCP, and the 10 GbE LAN From 3d84f144274fa11b88506fe1b1688424addca58a Mon Sep 17 00:00:00 2001 From: Niko Maroulis Date: Mon, 2 Nov 2026 14:56:30 -0500 Subject: [PATCH 38/49] docs: the CUDA branch is neutral on Q4_K MoE models --- docs/dgx-spark.md | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/docs/dgx-spark.md b/docs/dgx-spark.md index 905f799..c2c4f3e 100644 --- a/docs/dgx-spark.md +++ b/docs/dgx-spark.md @@ -431,7 +431,10 @@ so the KL divergence against upstream is 0.000000 with 100% same top token: | branch (src1 reuse + bias fusions) | **2209** | **2244** | **2147** | 58.02 | That is +8% prefill with decode unchanged. The full CUDA `test-backend-ops` -suite passes on the branch (19246/19246). +suite passes on the branch (19246/19246). Models with nothing to fuse stay +level. On Qwen3.6-35B-A3B and Qwen3-30B-A3B (Q4_K_M), pp512 / pp2048 / tg128 +read 2956 / 2896 / 69.9 → 2940 / 2918 / 69.8 and 3288 / 3309 / 92.6 → 3302 / +3353 / 92.6. ### Through the binding From 8c6ca4bc6764ff04b23a95e140c240d4fe9bc59b Mon Sep 17 00:00:00 2001 From: Niko Maroulis Date: Mon, 2 Nov 2026 14:59:04 -0500 Subject: [PATCH 39/49] docs: two-node e2e on the spark-all build --- docs/dgx-spark.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/dgx-spark.md b/docs/dgx-spark.md index c2c4f3e..0c6eea2 100644 --- a/docs/dgx-spark.md +++ b/docs/dgx-spark.md @@ -454,7 +454,7 @@ tree. Then remove the | Qwen3.8-27B NVFP4 | 1304 tok/s | **1560 tok/s** (+20%) | | gpt-oss-120b MXFP4 | 2352 tok/s | **2583 tok/s** (+10%) | -`scripts/spark/e2e.exs single` passes 12/12 on that build. So do the test +`scripts/spark/e2e.exs` passes 12/12 on that build, both `single` and `two-node`. So do the test suite's `smoke`, `embeddings`, `tools` and `decision` tags (602 tests), `mtp` and `dflash` (458), `rpc_live` against a worker, `vm_exit_test.exs`, and `rpc_check.exs` over the fabric (VM exit 0). The embeddings run used From a4f064b726d79805543bc40f70dce03725c4226c Mon Sep 17 00:00:00 2001 From: Niko Maroulis Date: Mon, 2 Nov 2026 15:07:52 -0500 Subject: [PATCH 40/49] docs: the RPC spin leaves an idle client idle --- docs/dgx-spark.md | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/docs/dgx-spark.md b/docs/dgx-spark.md index 0c6eea2..2d77478 100644 --- a/docs/dgx-spark.md +++ b/docs/dgx-spark.md @@ -841,8 +841,9 @@ wake faster is not established. Branch `rpc-client-spin-wait` on `nyo16/llama.cpp` (also merged into `spark-all`) spins both sides whenever a command arrived in the last 100 ms: the dispatcher on its queue, and the caller on its future, up to 100 ms -before blocking. An idle client still sleeps. With that client and the same -unpatched worker: +before blocking. An idle client still sleeps. A `llama-server` holding an +RPC-split model used 0 CPU ticks in the 10 s after a request, against 2 +unpatched. With that client and the same unpatched worker: | client | `llama-bench` decode, before | after | |---|---|---| From 8deb8fbe8d88330fe79f999f6a2f4976e1fd49d7 Mon Sep 17 00:00:00 2001 From: Niko Maroulis Date: Mon, 2 Nov 2026 15:10:00 -0500 Subject: [PATCH 41/49] docs: CPU cost of the RPC client spin while generating --- docs/dgx-spark.md | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/docs/dgx-spark.md b/docs/dgx-spark.md index 2d77478..846ebdb 100644 --- a/docs/dgx-spark.md +++ b/docs/dgx-spark.md @@ -843,7 +843,10 @@ Branch `rpc-client-spin-wait` on `nyo16/llama.cpp` (also merged into the dispatcher on its queue, and the caller on its future, up to 100 ms before blocking. An idle client still sleeps. A `llama-server` holding an RPC-split model used 0 CPU ticks in the 10 s after a request, against 2 -unpatched. With that client and the same unpatched worker: +unpatched. The cost is paid while generating. On a 512-token gpt-oss-120b +completion over two nodes, `llama-server` used 1.99 cores on average against +0.89 unpatched, and decoded at 55.7 tok/s against 48.4. That is one extra core +for +15%. With that client and the same unpatched worker: | client | `llama-bench` decode, before | after | |---|---|---| From 5d91acb85bf040bc6340f3063dc65235541593dd Mon Sep 17 00:00:00 2001 From: Niko Maroulis Date: Mon, 2 Nov 2026 15:14:25 -0500 Subject: [PATCH 42/49] docs: both RPC spins are needed --- docs/dgx-spark.md | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/docs/dgx-spark.md b/docs/dgx-spark.md index 846ebdb..a2b171e 100644 --- a/docs/dgx-spark.md +++ b/docs/dgx-spark.md @@ -846,7 +846,9 @@ RPC-split model used 0 CPU ticks in the 10 s after a request, against 2 unpatched. The cost is paid while generating. On a 512-token gpt-oss-120b completion over two nodes, `llama-server` used 1.99 cores on average against 0.89 unpatched, and decoded at 55.7 tok/s against 48.4. That is one extra core -for +15%. With that client and the same unpatched worker: +for +15%. Both spins are needed. With an X925 client, `llama-bench` decodes at +44.2 with neither, 52.4 with the dispatcher spin only, 54.1 with the caller +spin only and 57.5 with both. With that client and the same unpatched worker: | client | `llama-bench` decode, before | after | |---|---|---| From 19755d2e630efb95732187bfd57e4f89f5dcb1d9 Mon Sep 17 00:00:00 2001 From: Niko Maroulis Date: Mon, 2 Nov 2026 15:14:42 -0500 Subject: [PATCH 43/49] docs: state exactly which nsys comparisons were made --- docs/dgx-spark.md | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/docs/dgx-spark.md b/docs/dgx-spark.md index a2b171e..8c88dd4 100644 --- a/docs/dgx-spark.md +++ b/docs/dgx-spark.md @@ -809,10 +809,11 @@ gpt-oss-120b over RDMA, upstream's worker restarted before every run, and The client's cluster decides the band. With the client on the A725 cores, every run lands in the fast band. Leave it unpinned and the scheduler mostly puts it on the X925 cores, which is the slow band. llama-bench's own CPU -threads do not explain it: `--poll 0` and `-t 1` change nothing. Kernel times -are identical in both bands on both nodes (`nsys`: 118 µs per expert matvec, -2.7 ms for the LM head). The extra ~4 ms per token is spent on the CPU and in -the network wait; the next section has the cause. +threads do not explain it: `--poll 0` and `-t 1` change nothing. On the +worker, kernel times are identical in fast and slow sessions (`nsys`: 118 µs +per expert matvec, 2.7 ms for the LM head), and the client's slow-band expert +matvecs run at the same 118 µs. The extra ~4 ms per token is spent on the CPU +and in the network wait; the next section has the cause. The binding follows the same rule. `bench/spark_two_node.exs b1` with the BEAM under `taskset -c 0-4,10-14` (`scripts/spark/remote.sh --little-cores`), From ec790132c66f8bb698b82d6fe7cb7c505fd7252d Mon Sep 17 00:00:00 2001 From: Niko Maroulis Date: Mon, 2 Nov 2026 15:15:01 -0500 Subject: [PATCH 44/49] docs: count unpinned runs instead of guessing the scheduler --- README.md | 4 ++-- bench/spark_two_node.exs | 2 +- docs/dgx-spark.md | 4 ++-- 3 files changed, 5 insertions(+), 5 deletions(-) diff --git a/README.md b/README.md index e30c71f..1af48db 100644 --- a/README.md +++ b/README.md @@ -1369,8 +1369,8 @@ Three notes, all learned the hard way: forced `use_mmap: true` made that the common case — leave the load-mode options unset. - **Over two nodes, pin the client to the Cortex-A725 cores** - (`taskset -c 0-4,10-14`). Unpinned, the BEAM mostly lands on the X925 - cores, and decode over RPC runs ~25% slower: gpt-oss-120b layer-split decoded + (`taskset -c 0-4,10-14`). Unpinned or on the X925 cores, decode over RPC + usually lands in a band ~25% slower: gpt-oss-120b layer-split decoded 37–38 tok/s unpinned against 47 pinned, with the same prefill. The cause is thread wake-ups in ggml's RPC client. A fix on `nyo16/llama.cpp` (`rpc-client-spin-wait`) gives 50.6–50.8 unpinned, against 55 single-node. diff --git a/bench/spark_two_node.exs b/bench/spark_two_node.exs index 5614368..ac77f5f 100644 --- a/bench/spark_two_node.exs +++ b/bench/spark_two_node.exs @@ -7,7 +7,7 @@ Code.require_file("helpers.exs", __DIR__) # mix run bench/spark_two_node.exs # # --little-cores runs this client on the Cortex-A725 cores, where two-node decode -# is ~25% faster than on the X925s an unpinned BEAM mostly lands on +# is ~25% faster than in the band an unpinned BEAM usually lands in # (docs/dgx-spark.md, "Pin the client to the little cores"). # # Benches, each answering one question: diff --git a/docs/dgx-spark.md b/docs/dgx-spark.md index 8c88dd4..9149985 100644 --- a/docs/dgx-spark.md +++ b/docs/dgx-spark.md @@ -807,8 +807,8 @@ gpt-oss-120b over RDMA, upstream's worker restarted before every run, and | A725 | X925 | 53.1 | The client's cluster decides the band. With the client on the A725 cores, -every run lands in the fast band. Leave it unpinned and the scheduler mostly -puts it on the X925 cores, which is the slow band. llama-bench's own CPU +every run lands in the fast band. Unpinned, 14 of 18 `llama-bench` runs landed +in the slow band, the same band as X925 pinning. llama-bench's own CPU threads do not explain it: `--poll 0` and `-t 1` change nothing. On the worker, kernel times are identical in fast and slow sessions (`nsys`: 118 µs per expert matvec, 2.7 ms for the LM head), and the client's slow-band expert From 1cc5158bee6486c2e939b0372351c76752ab84e4 Mon Sep 17 00:00:00 2001 From: Niko Maroulis Date: Mon, 2 Nov 2026 15:46:33 -0500 Subject: [PATCH 45/49] docs: soak result, unpinned run count, two-node verdict with the fix --- docs/dgx-spark.md | 15 +++++++++++---- 1 file changed, 11 insertions(+), 4 deletions(-) diff --git a/docs/dgx-spark.md b/docs/dgx-spark.md index 9149985..7d8838d 100644 --- a/docs/dgx-spark.md +++ b/docs/dgx-spark.md @@ -849,12 +849,16 @@ completion over two nodes, `llama-server` used 1.99 cores on average against 0.89 unpatched, and decoded at 55.7 tok/s against 48.4. That is one extra core for +15%. Both spins are needed. With an X925 client, `llama-bench` decodes at 44.2 with neither, 52.4 with the dispatcher spin only, 54.1 with the caller -spin only and 57.5 with both. With that client and the same unpatched worker: +spin only and 57.5 with both. A 30-minute soak of `llama-server` on that +client (`-np 4`, six concurrent clients, random 16/64/256-token completions, +gpt-oss-120b over RDMA) served 1419 completions and 146k tokens with no +errors, and exited 0. Upstream's worker grew from 332 to 1565 MiB RSS over it. +With that client and the same unpatched worker: | client | `llama-bench` decode, before | after | |---|---|---| | X925 cores | 44.2–44.6 | **57.6** | -| unpinned | 44.0–44.5 (one run in seven 53.2) | **57.4, 57.6** | +| unpinned | 42.3–44.5 (4 of 18 runs at 52–53) | **57.4, 57.6** | | A725 cores | 53.5–54.0 | **57.3** | | single node | 59.0 | — | @@ -1068,8 +1072,11 @@ only cross-host mode that is both correct and fast, and it buys capacity. cannot span hosts as designed. Across hosts it silently falls back to a generic path that is 2.7× slower. It is the right tool for several GPUs in **one** box, which a Spark does not have. -- Layer split over RPC buys **capacity, not speed**. If your model fits in - 130 GB, one Spark is the answer. +- Layer split over RPC buys **capacity** first. On the vendored llama.cpp it + also buys +18–26% prefill and costs 9–30% decode, depending on where the + client runs. With the `rpc-client-spin-wait` fix, decode costs 2–3% on + gpt-oss-120b and nothing on the dense NVFP4 model. For a model that fits in + 130 GB, a second Spark is a prefill and throughput option, not a requirement. Re-check these claims against a future llama.cpp bump using upstream commits `d6f303004` (`-sm tensor`), `adb541a6a` and `91fef9536`. From 4ba426583302d0e1b477bf366a98607ae205ba6f Mon Sep 17 00:00:00 2001 From: Niko Maroulis Date: Mon, 2 Nov 2026 16:07:13 -0500 Subject: [PATCH 46/49] docs: binding two-node soak with the RPC client fix --- docs/dgx-spark.md | 3 +++ 1 file changed, 3 insertions(+) diff --git a/docs/dgx-spark.md b/docs/dgx-spark.md index 7d8838d..cefe7e4 100644 --- a/docs/dgx-spark.md +++ b/docs/dgx-spark.md @@ -853,6 +853,9 @@ spin only and 57.5 with both. A 30-minute soak of `llama-server` on that client (`-np 4`, six concurrent clients, random 16/64/256-token completions, gpt-oss-120b over RDMA) served 1419 completions and 146k tokens with no errors, and exited 0. Upstream's worker grew from 332 to 1565 MiB RSS over it. +The same through the binding (`spark-all` vendored, `LlamaCppEx.Server` with +`n_parallel: 4`, six concurrent callers, 20 minutes) served 892 completions +with no errors, and the VM exited 0. With that client and the same unpatched worker: | client | `llama-bench` decode, before | after | From 51c640c4af73f49b1bbb96260cfb4196e0c312e4 Mon Sep 17 00:00:00 2001 From: Niko Maroulis Date: Mon, 2 Nov 2026 16:08:34 -0500 Subject: [PATCH 47/49] docs: two-node MTP with the RPC client fix --- docs/dgx-spark.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/dgx-spark.md b/docs/dgx-spark.md index cefe7e4..6c64c89 100644 --- a/docs/dgx-spark.md +++ b/docs/dgx-spark.md @@ -943,7 +943,7 @@ harness above, so acceptance is not comparable with the one-node table): | config | decode t/s | acceptance | `spark-all` client, upstream worker | |---|---|---|---| | plain | 14.02–14.03 | — | **14.79–14.81** | -| MTP `n_draft: 3` | 17.7–19.7 | 50% | not run | +| MTP `n_draft: 3` | 17.7–19.7 | 50% | **24.8** (53%) | | DFlash 2 `n_draft: 7` | **22.2–22.4** | 27% | **27.8–27.9** (29%) | DFlash still pays 1.6× across two nodes, and 1.9× with the RPC client fix. With From 3877c569e08a4702a6318109bafac4d190cd6882 Mon Sep 17 00:00:00 2001 From: Niko Maroulis Date: Mon, 2 Nov 2026 16:10:42 -0500 Subject: [PATCH 48/49] docs: more ruled-out causes for the binding worker gap --- docs/dgx-spark.md | 8 ++++++-- 1 file changed, 6 insertions(+), 2 deletions(-) diff --git a/docs/dgx-spark.md b/docs/dgx-spark.md index 6c64c89..b093cb9 100644 --- a/docs/dgx-spark.md +++ b/docs/dgx-spark.md @@ -890,8 +890,12 @@ With the client fixed, the worker binary shows up. Against the same patched binding client gives the same split: 50.6–50.8 against 53.9. Both workers run the same server code from the same tree and build flags. Several things change nothing: BEAM scheduler flags (`+sbwt none`, `+S 1:1`), no super carriers -(`+MMscs 0 +MMmcs 0`), and running the worker on the A725 cores instead of the -X925s. GPU clocks are the same in both, 2411 MHz. Kernel times under `nsys` do +(`+MMscs 0 +MMmcs 0`), running the worker on the A725 cores instead of the +X925s, and an explicit `-ts 1/1` split (53.7 against 57.4), which rules out the +layers moving with a different free-memory report. The server thread's context +switches and CPU time match the upstream worker's (1032 / 199 / 25.9 s against +1036 / 190 / 25.2 s over a 256-token run). GPU clocks are the same in both, +2411 MHz. Kernel times under `nsys` do not settle it, because profiling slows the BEAM process more than a bare binary (one-node section). The cause is not established. For the last 7% of two-node decode, run `rpc-worker.sh --upstream`. From 0eec112324c8a32c6c248cbc114f4aa70902dc47 Mon Sep 17 00:00:00 2001 From: Niko Maroulis Date: Mon, 2 Nov 2026 16:32:55 -0500 Subject: [PATCH 49/49] test: compare embed_batch with per-text embed by cosine similarity The 0.001 elementwise bound was tuned on CPU. On CUDA a batch runs different kernels than a single text, and bge-small differs by up to 0.0027 per element (cos 0.99988), so the test failed on every CUDA run with the CI model. Cosine > 0.999 passes on CUDA with bge-small, embeddinggemma and Qwen3-Embedding and on CPU, and still fails on the bugs it guards: rows swapped between sequences (cos 0.41-0.70) and the wrong pooling (<= 0.93). --- CHANGELOG.md | 4 ++++ docs/dgx-spark.md | 14 +++++++------- test/embeddings_test.exs | 24 ++++++++++++++++++------ 3 files changed, 29 insertions(+), 13 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index f0d1dbf..1018623 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -86,6 +86,10 @@ numbers behind the entries below. cores. Upstream fix on `nyo16/llama.cpp` branch `rpc-client-spin-wait`: 57.6 tok/s on any cores through `llama-bench` (single node 59), 50.6–50.8 through the binding unpinned. +- `test/embeddings_test.exs`: `embed_batch` is compared with per-text `embed` + by cosine similarity (> 0.999) instead of a 0.001 elementwise bound, which + CUDA missed (0.0027 on bge-small) because a batch runs different kernels. + Swapped rows still fail it (cos 0.41). ## v0.8.66 diff --git a/docs/dgx-spark.md b/docs/dgx-spark.md index b093cb9..c986e77 100644 --- a/docs/dgx-spark.md +++ b/docs/dgx-spark.md @@ -457,13 +457,13 @@ tree. Then remove the `scripts/spark/e2e.exs` passes 12/12 on that build, both `single` and `two-node`. So do the test suite's `smoke`, `embeddings`, `tools` and `decision` tags (602 tests), `mtp` and `dflash` (458), `rpc_live` against a worker, `vm_exit_test.exs`, and -`rpc_check.exs` over the fabric (VM exit 0). The embeddings run used -Qwen3-Embedding-0.6B. With bge-small-en-v1.5 Q8_0, `embed_batch matches -per-text embed` fails on CUDA by 0.0027 against its 0.001 bound, on the -vendored tree as well, and passes on the CPU backend. Batching is not the -cause. Per-text embeddings on CUDA already differ from CPU by 0.0026, with -elements up to 0.42. The CUDA backend's numerics on this BERT simply exceed a -bound calibrated on CPU. Speculative +`rpc_check.exs` over the fabric (VM exit 0). `embed_batch matches per-text +embed` used to fail on CUDA with bge-small-en-v1.5 Q8_0, on the vendored tree +as well: batched and per-text embeddings differed by up to 0.0027 per element +against a 0.001 bound tuned on CPU, because a batch runs different kernels. +The test now compares cosine similarity (> 0.999; CUDA gives 0.99988, swapped +rows 0.41–0.70, the wrong pooling ≤ 0.93) and passes on CUDA with bge-small, +embeddinggemma and Qwen3-Embedding, and on CPU. Speculative decoding on Qwen3.8-27B NVFP4 (`bench/spark_spec.exs`) runs at plain 14.3, MTP `n_draft: 2` 26.5 and DFlash 2 `n_draft: 7` 45.9 tok/s, against 14.3 / 26.8 / 44.2 vendored. No source change in the binding is needed for the swap, but a diff --git a/test/embeddings_test.exs b/test/embeddings_test.exs index 20ecaa1..13915ce 100644 --- a/test/embeddings_test.exs +++ b/test/embeddings_test.exs @@ -41,6 +41,13 @@ defmodule LlamaCppEx.EmbeddingsTest do # Guards the multi-sequence batch refactor: batched embeddings (single # context, many sequences) must match one-context-per-text, including when # grouping splits the batch (max_batch_sequences forces multiple groups). + # + # Compared by cosine similarity, not elementwise. A batch runs different + # kernels than a single text on GPU backends (CUDA: up to 0.0027 per element + # with bge-small, cos 0.99988), so an absolute bound tuned on CPU fails there. + # The bugs this guards against are far away: rows swapped between sequences + # give the cosine of two different texts (at most 0.70 on bge-small, + # embeddinggemma and Qwen3-Embedding), and the wrong pooling at most 0.93. test "embed_batch matches per-text embed (incl. multi-group)", %{emb_model: em} do texts = [ "Elixir is a functional programming language.", @@ -60,8 +67,8 @@ defmodule LlamaCppEx.EmbeddingsTest do assert {:ok, grouped} = LlamaCppEx.embed_batch(em, texts, max_batch_sequences: 2) assert length(batched) == length(texts) - assert max_elementwise_diff(batched, reference) < 1.0e-3 - assert max_elementwise_diff(grouped, reference) < 1.0e-3 + assert min_pairwise_cosine(batched, reference) > 0.999 + assert min_pairwise_cosine(grouped, reference) > 0.999 end # Regression: llama_context reserves its prompt graph for n_ubatch rounded up @@ -78,11 +85,16 @@ defmodule LlamaCppEx.EmbeddingsTest do assert Enum.all?(vectors, &(length(&1) == LlamaCppEx.Model.n_embd_out(em))) end - defp max_elementwise_diff(a, b) do - Enum.zip(a, b) + # Lowest cosine similarity between the i-th vectors of two equally long lists. + defp min_pairwise_cosine(a, b) do + a + |> Enum.zip(b) |> Enum.map(fn {va, vb} -> - Enum.zip(va, vb) |> Enum.map(fn {x, y} -> abs(x - y) end) |> Enum.max() + dot = va |> Enum.zip(vb) |> Enum.reduce(0.0, fn {x, y}, acc -> acc + x * y end) + dot / (norm(va) * norm(vb)) end) - |> Enum.max() + |> Enum.min() end + + defp norm(v), do: :math.sqrt(Enum.reduce(v, 0.0, &(&1 * &1 + &2))) end