Skip to content

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

C++

peer experts: peer access is used only if a test copy each way arrives exact (#2666)

Niko1221331507246722
diff --git a/src/core/peer_experts.cpp b/src/core/peer_experts.cpp
index 6c8f567e6..9ca2ee994 100644
--- a/src/core/peer_experts.cpp
+++ b/src/core/peer_experts.cpp
@@ -13,6 +13,7 @@
#include <cstring>
#include <cstdlib>
#include <stdexcept>
+#include <vector>
namespace strata::core {
@@ -41,6 +42,45 @@ struct On {
~On() { int cur = 0; cudaGetDevice(&cur); if (cur != prev) cudaSetDevice(prev); }
};
+/// #2666: `cudaDeviceCanAccessPeer` said yes and `cudaDeviceEnablePeerAccess` succeeded, and on a pair of GPUs behind a host bridge
+/// (2x RTX A4000, "PHB" in nvidia-smi topo) `cudaMemcpyPeerAsync` then returned success having moved nothing: the peer's input rows
+/// were zeros and the rows it sent back never arrived, so the first prompt's MoE output was garbage and the logits NaN. Without
+/// peer access enabled the same copies are right (the driver stages them). So the pair is asked once, with a small copy each way,
+/// whether the direct path really carries data. true = both ways exact (or nothing could be tested: the old trust is kept).
+bool p2p_copies_data(int device) {
+ constexpr size_t kN = 1 << 14; // floats
+ std::vector<float> h(kN), back(kN);
+ for (size_t i = 0; i < kN; ++i) h[i] = 1.0f + (float) ((i * 2654435761u) % 4093u);
+ float* d[2] = {nullptr, nullptr};
+ const int dev[2] = {0, device};
+ bool ok = true, tested = true;
+ for (int k = 0; k < 2 && tested; ++k) {
+ On on(dev[k]);
+ if (cudaMalloc((void**) &d[k], kN * 4) != cudaSuccess) { cudaGetLastError(); tested = false; }
+ }
+ for (int dir = 0; dir < 2 && tested && ok; ++dir) { // 0: device 0 -> peer, 1: peer -> device 0
+ const int from = dir == 0 ? 0 : 1, to = 1 - from;
+ {
+ On on(dev[from]);
+ if (cudaMemcpy(d[from], h.data(), kN * 4, cudaMemcpyHostToDevice) != cudaSuccess) { tested = false; break; }
+ }
+ {
+ On on(dev[to]);
+ if (cudaMemset(d[to], 0, kN * 4) != cudaSuccess) { tested = false; break; }
+ }
+ if (cudaMemcpyPeer(d[to], dev[to], d[from], dev[from], kN * 4) != cudaSuccess) { tested = false; break; }
+ {
+ On on(dev[to]);
+ if (cudaMemcpy(back.data(), d[to], kN * 4, cudaMemcpyDeviceToHost) != cudaSuccess) { tested = false; break; }
+ }
+ ok = std::memcmp(back.data(), h.data(), kN * 4) == 0;
+ }
+ for (int k = 0; k < 2; ++k)
+ if (d[k] != nullptr) { On on(dev[k]); cudaFree(d[k]); }
+ if (!tested) { cudaGetLastError(); return true; }
+ return ok;
+}
+
bool ck(cudaError_t e, const char* what, std::string& err) {
if (e == cudaSuccess) return true;
err = std::string("peer experts: ") + what + ": " + cudaGetErrorString(e);
@@ -108,6 +148,15 @@ bool PeerExperts::open(int device, const std::vector<std::pair<int32_t, int32_t>
cudaError_t e1 = cudaDeviceEnablePeerAccess(0, 0);
if (e1 == cudaErrorPeerAccessAlreadyEnabled) { cudaGetLastError(); e1 = cudaSuccess; }
p2p_ = e0 == cudaSuccess && e1 == cudaSuccess;
+ // recommend, never force: the direct path is used only if a test copy each way arrives exact (#2666)
+ if (p2p_ && !p2p_copies_data(device)) {
+ std::fprintf(stderr, "strata: peer GPU %d: peer access is enabled but a test copy between the two GPUs arrived wrong "
+ "(a host bridge between them, no real P2P): the prompt path takes the host route instead "
+ "(STRATA_PEER_NO_P2P=1 does that by hand)\n", device);
+ { On q0(0); cudaDeviceDisablePeerAccess(device); cudaGetLastError(); }
+ { On q1(device); cudaDeviceDisablePeerAccess(0); cudaGetLastError(); }
+ p2p_ = false;
+ }
}
}
On on(device);