GPUs have a hierarchical memory system: global memory (DRAM) provides large capacity but high latency, while L1/L2 caches and shared memory offer low latency with limited capacity. GPUs execute instructions in groups of 32 threads called warps. When threads in a warp access consecutive global-memory addresses, the hardware combines them into fewer transactions, a pattern known as coalesced access. Because graph traversal involves irregular access patterns, coalescing efficiency and cache utilization in global memory can dominate overall search throughput.

Figure 2: GPU Memory Hierarchy. Global memory provides high capacity but low bandwidth. L1 cache and shared memory offer high bandwidth with limited capacity.

Figure 3: Coalesced Memory Access. (a) The ideal pattern, where threads access consecutive memory addresses. (b) The anti pattern, with scattered memory requests.

Plasma has three components. The graph adapter takes an index in any format (Faiss, DiskANN) and converts its topology into a common GPU format, so even a CPU-oriented index runs on GPU. The reordering module applies a permutation $\pi$ to vertex IDs. The unified traversal engine runs one beam-search kernel for every condition, so a performance difference reflects topology or layout, never the search implementation.

Vertex IDs index the underlying arrays directly, so reordering is what physically moves data: the dataset region stores $N$ vectors of $d + p$ elements each, the graph region $N$ neighbor lists of up to $K$ IDs. Giving co-accessed vertices consecutive IDs promotes coalesced access and cuts DRAM traffic. Plasma supports GOrder, RCM, Degree Sort, and Hub Sort as $\pi$.

Figure 4 (a): The dataset memory region consists of vectors, each containing d data elements plus padding p to satisfy 16-byte alignment.

Figure 4 (b): The graph memory region consists of nodes, where each node stores the IDs of up to K neighbor nodes without padding.

Comparison with existing ANNS benchmarks

Other ANNS benchmarks compare libraries end to end, so a win can come from the graph, the search algorithm, or the implementation, and none of them can say which. Plasma fixes the kernel and varies only topology and layout, reads GPU hardware counters alongside Recall and QPS, and pins the whole CUDA stack in a pixi lockfile, so pixi install reproduces the environment exactly.

• NVIDIA A100 80GB
• NVIDIA RTX 6000 Ada 48GB

Topology matters less than expected

Benchmarking CAGRA, NSG, Vamana, and NN-Descent across 12 datasets on a single NVIDIA A100, all under the same kernel and their original vertex ordering, shows that topology differences are often minor. To the best of our knowledge, this is the first work to run CPU-oriented indices such as NSG, Vamana, and NN-Descent on a GPU, and NSG outperforms the GPU-optimized CAGRA by up to 1.2× on C4 5M. Differences are small on classical datasets such as SIFT and Deep, and more pronounced on modern high-dimensional ones such as Wikipedia 10M and BioASQ 10M.

Reordering alone buys up to 80% QPS

Applying reordering to the same four indices yields up to 80% QPS improvement while preserving search accuracy, with typical gains of 10–30%. C4 5M improves by 60–80% for every index; BioASQ gains less than 10% except for NN-Descent. GOrder is consistently unstable, dropping sharply in the high-recall region, and no single reordering algorithm wins across the board, so the right choice depends on the workload.

The speedup comes from DRAM bandwidth, not caches

Profiling with Nsight Compute at $L = 120$ attributes the gain to bandwidth rather than caching. L1 hit rates sit near zero (0.007% to 0.025%) regardless of reordering, and L2 hit rates stay between 8% and 28% and move by less than one percentage point. DRAM bandwidth utilization, in contrast, changes substantially: for NSG on SIFT 1M it rises from 39.4% to 44.2% under Hub Sort, a 4.8 point gain that corresponds to roughly 15% more QPS. The correlation between bandwidth-utilization change and execution-time change is $-0.669$ overall and $-0.965$ for the search kernel alone.

The effect is architecture-dependent. On the A100 (HBM2e, 2,039 GB/s) improvements reach 80%, whereas on an RTX 6000 Ada (GDDR6, 960 GB/s) they stay below 15%, so reordering pays off most on high-bandwidth-memory GPUs.