Paper · 2023-06-24 · cs.LG, cs.AR, cs.DC
A Survey on Graph Neural Network Acceleration: Algorithms, Systems, and Customized Hardware
Survey taxonomy of GNN acceleration: training (graph modification, node, layer and subgraph sampling), inference (pruning, quantization, distillation), and systems and hardware (GPU kernels, scalable training, FPGA and ASIC accelerators). It proposes no method and runs no experiments; its tables collect author-reported speedups.
Graph neural networkNetwork pruningKnowledge distillationWeight quantizationgraph-neural-networksaccelerationsurveyhardwaresampling
AI-compiled by claude-haiku-5-5 on 2026-11-13, not yet reviewed by a human. Every claim cites its source; check it when a detail matters.
In plain words
Graph neural networks learn from connected data, such as molecules or social networks. To learn about a node, they look at its neighbours, then at the neighbours of those neighbours, and so on. On large graphs this grows very quickly, so training and running these models becomes slow and memory-hungry.
This survey does not invent a new speed-up. It sorts the many existing ways to make these models faster into one map with three parts. The first part changes the training data or the training process, for example by shrinking the graph or by looking at only part of it at each step. The second part makes the trained model smaller or simpler, for example by dropping weights, using less precise numbers, or training a small student model to copy a large one. The third part is about the machines that run the model: ordinary GPUs and CPUs with better software, and custom chips such as FPGAs and ASICs.
The authors also discuss how to pick among these options. The right choice depends on the size of the graph, how much memory the machine has, and whether the model is trained once or many times. Their recommendations are set out in the last technical part of the survey and should be read as guidance, not as measured results.
TL;DR
A survey, not a method: it classifies GNN acceleration into training algorithms, inference algorithms, COTS systems and customized hardware, with a section on heterogeneous and dynamic graphs §1. It runs no experiments of its own, so its numbers are author-reported by the cited works §5.2 tab. 1. Read it to choose a family of techniques, then go to the original paper for the details.
Problem
GNN training and single-node inference both need the neighbourhood of each node, and the neighbourhood grows exponentially with the number of layers, so computation graphs become huge on large graphs §1. Training cannot use random mini-batches of nodes as image or text training does, because nodes depend on each other §1. The resulting graph must be stored in sparse format, and sparse computation maps poorly onto GPUs §1. The survey excludes collections of many small graphs such as molecule datasets, where this problem is much smaller §1.
Method
This is a survey. It has no training objective or algorithm of its own. The map is given in the taxonomy figure fig. 1 and the sections below follow it. Where the survey gives a formula, the formula is reproduced and cited. Where it describes a method in words, the card says so.
1. Taxonomy
The survey splits GNN acceleration into three areas: algorithms, COTS systems and customized hardware §1 fig. 1. The algorithm area covers training (graph modification and sampling) and inference (pruning, quantization and distillation). The system area covers GPU kernels, tuning of user-written graph operations, and training systems that scale out. The hardware area covers accelerators for general and for special workloads §1 fig. 1. Heterogeneous and dynamic graphs get separate treatment §6.
2. Training algorithms §2
Both families reduce the computation graph used during training §2. Graph modification builds a smaller graph G' in a separate step and then trains on it. Sampling picks a subset of nodes or edges in every iteration and never creates an intermediate graph §2.
Graph modification has three types §2.1 fig. 2:
- Coarsening clusters nodes into K clusters, merges each cluster into a super-node, and adds a super-edge where clusters are connected §2.1.1. The clustering step is the core, and the survey lists spectral properties as the criteria the coarsening tries to preserve §2.1.1.
- Sparsification removes less important edges and keeps all nodes. It can run once before training, and the full-batch cost of an L-layer GNN falls from O(L|E|) to O(L|E'|) §2.1.2.
- Condensation generates a new small graph whose training dynamics match those of the original graph. GCond matches gradients between two GNNs and learns the condensed node features directly §2.1.3.
Sampling has three types §2.2 fig. 3:
- Node-wise sampling samples neighbours separately for each node and each layer. GraphSAGE samples a fixed number of neighbours uniformly, so each neighbour has probability 1/d(v) §2.2.1.
- Layer-wise sampling samples one set of nodes per layer, shared by all target nodes. FastGCN samples with a degree-based probability, the same for every layer §2.2.2. AS-GCN and LADIES are covered in app. B.
- Subgraph-wise sampling samples an induced subgraph and runs full-batch message passing inside it. ClusterGCN partitions the graph with METIS and trains on clusters chosen at random per mini-batch; GraphSAINT samples nodes first; Shadow-GNN samples per target node with random walks or personalized PageRank §2.2.3.
The sampled message passing in the matrix form is eq. 1 eq. 2 eq. 3:
\mathbf{h}_{v}^{(l)} \approx \mathrm{UPDATE} \big(\mathbf{h}_{v}^{(l-1)}, \mathrm{AGGR} \big(\{ \phi(\mathbf{h}_v^{(l-1)}, \mathbf{h}_u^{(l-1)}) \mid u \in \overline{\mathcal{N}}(v)^{(l)} \} \big)\big) eq. 1
\mathbf{H}^{(l)} \approx \sigma \big( \overline{\mathbf{P}}^{(l)} \, \mathbf{H}^{(l-1)} \, \mathbf{W}^{(l)} \big) eq. 2
\mathcal{M}_{u,v} = \begin{cases} |\mathcal{N}(v)| / s_{node}^{(l)} & u \in \overline{\mathcal{N}}(v)^{(l)} \\ 0 & \text{otherwise} \end{cases} eq. 3
Here \overline{\mathbf{P}}^{(l)} = \mathcal{M} \circ \mathbf{P}^{(l)}, and \overline{\mathcal{N}}(v)^{(l)} is the sampled neighbourhood §2.2.1. The survey states that the sampled aggregation is an unbiased estimate of the full aggregation, in expectation §2.2.1. For layer-wise methods the mask is eq. 4 §2.2.2:
\overline{\mathbf{P}}^{(l)}_{v,u} = \begin{cases} \mathbf{P}^{(l)}_{v,u} \big/ \big(s_{layer}^{(l)} \, p_{\mathcal{V}}(u)\big) & v \text{ sampled in layer } l \text{ and } u \in \mathcal{N}(v) \\ 0 & \text{otherwise} \end{cases} eq. 4
Pseudocode for the node-wise case, in the survey's notation:
# One layer of node-wise sampled aggregation [§2.2.1] [eq. 2] [eq. 3]
# Input: P (N, N) full filter; M (N, N) sampling mask; H_prev (N, d)
# Output: H_next (N, d')
def sampled_layer(P, M, H_prev, W):
# Element-wise mask keeps sampled neighbours and rescales them [eq. 3]
P_bar = M * P
# Sampled aggregation, transform, nonlinearity [eq. 2]
H_next = sigma(P_bar @ H_prev @ W)
return H_next# Build the node-wise mask for one layer [§2.2.1] [eq. 3]
# Input: neighbours[v] for each node v; s_node (number of samples)
# Output: mask (N, N)
def node_wise_mask(neighbours, s_node, num_nodes):
mask = zeros(num_nodes, num_nodes)
for each target node v:
# Uniform sample of s_node neighbours (GraphSAGE) [§2.2.1]
kept = uniform_sample(neighbours[v], s_node)
# Rescale by the full neighbour count over the sample count [eq. 3]
for each u in kept:
mask[u, v] = len(neighbours[v]) / s_node
return maskGraph modification in its two steps §2.1:
# Training with graph modification [§2.1]
# Input: graph G = (V, E), features X, labels Y
# Output: trained GNN parameters theta
def train_with_graph_modification(G, X, Y):
# Step 1: build a smaller graph G' with features X' and labels Y' [§2.1]
G_small, X_small, Y_small = modify(G, X, Y)
# Step 2: ordinary training on G' [§2.1]
theta = train_gnn(G_small, X_small, Y_small)
return theta3. Inference algorithms §3
The survey treats inference acceleration as a change to the model only; the test graph is assumed unseen and left alone §3. Coarsening and condensation are said not to fit inference, and sampling is rarely used there, because one forward pass is usually run and sampling then cannot guarantee accuracy or consistency §3.
- Pruning removes unimportant weights, most often by weight magnitude §3.1. For GNNs, the survey describes a channel-pruning method (Zhou et al.) that solves a LASSO problem per layer with a learnable mask over channels §3.1 eq. 5:
\argmin_{\hat{\bm{\beta}}, \hat{\mathbf{W}}} \big\lVert \mathbf{H}^{(l)} - \mathbf{P} \mathbf{H}^{(l-1)} \big( \hat{\bm{\beta}} \odot \hat{\mathbf{W}}^{(l)} \big) \big\rVert_{2} + \lambda \lVert \hat{\bm{\beta}} \rVert_{1} eq. 5
The mask is optimized first with SGD, then the weights in closed form. The survey also mentions the lottery-ticket hypothesis, that a pruned network can be retrained to similar accuracy §3.1.
- Quantization maps tensors to a q-bit representation with a scale s and a zero-point z, x_q = floor(x/s + z) and x̂ = (x_q − z)s §3.2. Post-training quantization needs no training pipeline but can lose accuracy at low bit widths; quantization-aware training models the error during training at a higher cost §3.2. The survey says most quantization methods target CNNs, and cites SGQuant and Degree-Quant for GNNs §3.2 app. C.
- Distillation trains a small student to match a large teacher's soft labels §3.3. The survey writes the standard KD term as the KL divergence from teacher to student, summed over classes §3.3. LSP uses a student-first divergence over local neighbour-similarity distributions eq. 6:
\mathcal{L}_{i}^{LSP} = D_{KL}\big(\mathbf{s}^{(i),s} \,\|\, \mathbf{s}^{(i),t}\big) = \sum_{j \in \mathcal{N}(i)} \mathbf{s}^{(i),s}_{j} \log \frac{\mathbf{s}^{(i),s}_{j}}{\mathbf{s}^{(i),t}_{j}} eq. 6
with the local structure of node i given by normalized exponentials of the squared distances between its representation and each neighbour's §3.3. GLNN uses an MLP student with no graph at inference time, so inference is free of neighbour fetches §3.3. The survey reports that GLNN fails when labels depend mainly on structure and not on features §3.3.
- Combination: a cascaded scheme quantizes and distils the GNN step by step to a binary model that reaches a 2× speed-up on a Raspberry Pi 4B with moderate accuracy loss §3.4.
4. COTS systems §4
- GPU kernel acceleration §4.1 tab. 2: workload reordering, kernel fusion, dual-mode computation, dynamic workload assignment and custom sparse formats reduce memory traffic and improve data locality. Methods listed include PCGCN, fuseGNN, TLPGNN, FusedMM and MaxK-GNN tab. 2.
- User-defined function optimization §4.2 app. D: the survey covers Graphiler, which automatically reorders redundant scatter/gather operations and fuses them app. D.
- Scalable training systems §4.3 tab. 3 tab. 4: three types are distinguished by the challenge they address: on-device systems (communication and memory patterns), swap-based systems (workload scheduler), and sampling-based systems (data movement and caching). Each type is then tabulated with the hardware, aggregation type, whether the algorithm is changed, and whether the code is open source tab. 4.
- Design guidelines §4.4 tab. 5: the survey recommends profiling the workload first, choosing the algorithm family to match memory limits, then adding system optimizations such as fusion, caching, partitioning and pipelining. Memory thresholds in the guidance are 40 GB or less (sampling or cluster methods) and 80 GB or more (full-graph methods) §4.4. The table maps four regimes (single consumer GPU, single high-end GPU, 4–16 GPUs, CPU+GPU or cluster) to a preferred algorithm and system technique tab. 5.
5. Customized hardware §5
The survey first lists the design challenges §5.1. It then summarizes 14 accelerators by graph size, target GNN, layer customization, sparsity support and parallelization tab. 6 §5.2. The reported speed-ups are in tab. 7 and are not directly comparable, because baselines differ across rows.
- Accelerators for general workloads §5.3: an all-stage unified architecture handles every computation stage §5.3.1, or dedicated modules handle the main stages separately, because their communication patterns differ §5.3.2.
- Accelerators for special workloads §5.4 are built for GCN-like models: a layer-customizable deep pipeline §5.4.1 or an all-layer unified architecture §5.4.2.
- Design §5.5 covers how the accelerator is designed around the input graph and model hyperparameters §5.5.
The survey notes that accelerators mostly target inference, and that customized accelerators for training are rare §5.2.
6. Special graphs and special GNNs §6
- Heterogeneous graphs §6.1: ignoring node and edge types degrades performance. A sampler that treats all types the same can miss rare types entirely, and pruning can remove all weights for one edge type. The survey points to weighted sampling as the better option §6.1.
- Dynamic graphs §6.2 eq. 7: spatio-temporal GNNs update each node from its spatial neighbours and its history over the last few timestamps eq. 7. Training must run in time order, and sampling per timestamp ignores temporal neighbours §6.2.
\mathbf{h}_{v}^{t} = \mathrm{UPDATE} \big(\mathbf{h}_{v}^{t-k:t-1}, \mathrm{AGGR} \big(\{\phi(\mathbf{h}_v^{t-1}, \mathbf{h}_u^{t-1}) \mid (u^{t-1}, v^{t-1}) \in \mathcal{E}^{t-1} \} \big)\big) eq. 7
7. Cross-cutting selection guidance §7
- Training: graph modification pays off when the same graph trains many models, because its preprocessing is amortized. Sampling is preferred for a single run when memory is the limit §7.1.
- Inference: pruning and quantization fit strict latency; distillation into a graph-less model fits high-throughput batch jobs §7.2.
- Platform: COTS GPUs and CPUs suit changing workloads; FPGA or ASIC suits a stable workload that needs very low latency, at the cost of flexibility §7.3.
8. Future directions §8
The survey lists open problems in COTS-system and customized-hardware acceleration and in acceleration for heterogeneous and dynamic graphs §8.
Hyperparameters
The survey runs no experiments, so it sets no training or model hyperparameters. The settings below are the ones it reports for the cited benchmark, or are marked not stated.
| Name | Value | Where | Notes |
|---|---|---|---|
| sampling benchmark backbone | 2-layer GCN | tab. 1 | all sampling rows use this model |
| sampling size and optimizer | as in each original paper | tab. 1 | the survey does not restate the values |
| sampling accuracy source | absolute values from another paper | tab. 1 | attributed to [liu2021sampling]; relative columns computed by the survey with GraphSAGE as 1× |
| node-wise sample size s_node | not stated | §2.2.1 | per-layer values are in the original papers |
| layer-wise sample size s_layer | not stated | §2.2.2 | |
| LASSO weight λ (channel pruning) | not stated | eq. 5 | |
| KD temperature and loss weighting | not stated | §3.3 | |
| GCond condensation ratio | under 1% (reported by GCond) | §2.1.3 | author-reported on several benchmarks |
| memory thresholds for guidance | 40 GB or less; 80 GB or more | §4.4 | a recommendation, not a measurement |
| hardware clocks in tab. 7 | per row (100 to 330 MHz for FPGAs, 1 GHz and 500 MHz for ASICs) | tab. 7 | from each accelerator's own paper |
Results
Author-reported, taken from the cited papers. The survey runs no experiments.
Sampling benchmark, from [liu2021sampling] as reproduced in the survey. Setup: 2-layer backbone GCN, datasets Pubmed, PPI and Reddit; relative values in parentheses use GraphSAGE as the 1× baseline, computed by the survey tab. 1:
| Family | Method | Pubmed acc. (%) | Pubmed time (s) | PPI acc. (%) | PPI time (s) | Reddit acc. (%) | Reddit time (s) |
|---|---|---|---|---|---|---|---|
| no sampling | GCN | 78.6 (0.97×) | 24.8 (0.65×) | N/A | N/A | N/A | N/A |
| node-wise | GraphSAGE | 81.4 (1×) | 37.9 (1×) | 61.6 (1×) | 47.5 (1×) | 95.0 (1×) | 326.7 (1×) |
| node-wise | VR-GCN | 81.4 (1×) | 5.9 (0.16×) | 97.5 (1.58×) | 83.5 (1.76×) | 96.3 (1.01×) | 390.6 (1.20×) |
| layer-wise | FastGCN | 86.3 (1.06×) | 13.7 (0.36×) | N/A | N/A | 92.8 (0.98×) | 294.5 (0.90×) |
| layer-wise | AS-GCN | 89.5 (1.10×) | 39.1 (1.03×) | N/A | N/A | 96.5 (1.02×) | 1633.7 (5.00×) |
| layer-wise | LADIES | 75.7 (0.93×) | 6.4 (0.17×) | N/A | N/A | N/A | N/A |
| subgraph-wise | Cluster-GCN | N/A | N/A | 95.8 (1.56×) | 202.3 (4.26×) | 95.8 (1.01×) | 981.8 (3.00×) |
| subgraph-wise | GraphSAINT | N/A | N/A | 98.7 (1.60×) | 550.1 (11.58×) | 96.7 (1.02×) | 124.0 (0.38×) |
The survey's own reading of this table: layer-wise methods do better on Reddit and subgraph-wise methods do better on PPI §2.2.
Customized accelerators, as reported by each paper and listed by the survey tab. 7. "E2E" marks whether the accelerator was measured end to end:
| Work | Platform | E2E | Reported speed-up (as listed) |
|---|---|---|---|
| EnGN | ASIC, TSMC 14 nm, HBM 2.0 at 1 GHz; cycle-accurate simulator | no | 1802.9×, 19.75×, 2.97× over CPU (PyG & DGL), GPU (PyG & DGL), HyGCN |
| Rubik | ASIC, 45 nm at 500 MHz; cycle-accurate simulator | no | 3.42–46.7× and 1.3–14.16× over PyG-GPU and an Eyeriss-like accelerator |
| HyGCN | ASIC, TSMC 12 nm with HBM at 1 GHz; cycle-accurate simulator | no | 1509×, 6.5× over PyG-CPU, PyG-GPU |
| FlowGNN | FPGA, Xilinx Alveo U50 at 300 MHz; on-board | yes | 24–254×, 1.3–477×, 1.26× over PyG-CPU, PyG-GPU, I-GCN |
| BlockGNN | FPGA, Xilinx ZC706 at 100 MHz; on-board and analytical | no | 2.3×; 4.2–8.3× over CPU (TensorFlow), HyGCN |
| DeepBurning-GL | FPGA, ZC706, KCU1500, Alveo U50; on-board at 100–200 MHz | no | 7.43–346.98×, 3.7–16.5×, 6.28× over DGL-CPU, DGL-GPU, HyGCN on FPGA |
| AWB-GCN | FPGA, Intel Stratix 10 SX; on-board | no | 3255×, 80.3×, 5.1× over PyG-CPU, PyG-GPU, HyGCN |
| StreamGCN | FPGA, KU15P, Alveo U50 and U280; on-board at 201–290 MHz | yes | 8.2–18.2× and 12.1–26.9× over PyG-CPU, PyG-GPU |
| GraphACT | FPGA, Alveo U200 at 200 MHz; training speed measured | yes (training) | 12–15× and 1.1–1.5× over CPU and GPU |
| Zhang et al. | FPGA, Alveo U200 at 250 MHz; on-board | no | 30× and 2× over CPU and GPU (TensorFlow and CUDA C++) |
| BoostGCN | FPGA, Intel Stratix 10 GX 10M at 250 MHz; on-board | no | 100×, 30×, 3–45× over CPU and GPU (PyG & DGL); over FPGA designs of Zhang et al. and HyGCN |
| G-CoS | VCU128 board, FPGA clocked at 330 MHz; tested on the board | no | 5.52× and 1.92× against HyGCN and AWB-GCN |
| GCoD | VCU128 board, FPGA clocked at 330 MHz; tested on the board | no | 7.8× and 2.5× against HyGCN and AWB-GCN |
| I-GCN | Stratix 10 SX FPGA, clock 330 MHz; tested on the board | no | 368×, 453×, 16× and 5.7×, against the four baselines in the order PyG-GPU, DGL-GPU, SIGMA, AWB-GCN |
GCond, as reported by its authors, reaches under 1% condensation ratio with over 95% of the original GNN's accuracy on several benchmarks §2.1.3.
Baselines and hardware differ across the rows, so the speed-ups cannot be ranked against each other tab. 7.
Paper vs code
No official code. The survey has no code of its own, and the source links no repository. Searched: the abstract and the body text (the only URL is the ACM classification link), the arXiv metadata (no comments or links), and a GitHub repository search for "GNN acceleration". That search returned paper lists and unrelated repositories, none owned by an author: for example BUAA-CI-LAB/Literatures-on-GNN-Acceleration and other third-party lists. Per the wiki policy for surveys, those lists are not treated as code.
With no code, there is nothing to compare the text against.
Pitfalls
- No experiments. The numbers are author-reported by the cited papers, on different hardware, datasets and baselines. The speed-ups in tab. 7 are not comparable across rows, and the sampling table combines absolute values from [liu2021sampling] with relative values the survey computed tab. 1.
- Uncited figures. Section 4.4 gives figures without a source: fusion reduces global memory traffic by 2–5×, caching raises the effective batch size by 4–8×, and starting with PyG or DGL plus fused kernels gives 3–8× §4.4. Section 7 says one approach yields speed-ups "an order of magnitude" above software optimization §7.2. The survey attaches no source to these figures, so do not rely on them without checking the original papers.
- Pruning is not sparsification. Pruning changes the model, sparsification changes the graph §2.1.2. Pruning of a model at inference is a different step from removing edges before training.
- Subgraph samplers can be preprocessing. Subgraph-wise samplers may run once before training starts, which makes them look like graph modification; the survey separates them by the smaller, local subgraphs they produce §2.2.3.
- Layer-wise connectivity. Nodes sampled in consecutive layers may not be connected, which makes the filter matrix sparse and the approximation noisy §2.2.2.
- Unbiasedness is in expectation. The sampled aggregation estimates the full one only in expectation §2.2.1. A single run has variance, and the survey does not say how many neighbours are needed for a given error bound.
- Behaviour when a node has fewer neighbours than the sample size is not stated. The mask in eq. 3 assumes the sample exists §2.2.1.
- GCond needs a full-graph GNN. Gradient matching trains a GNN on the original graph, so GCond only saves time from the second model on the same graph §2.1.3. The survey notes this and suggests combining it with other methods for a single run §2.1.3.
- Sparsification may not speed up a single run. The sparsification methods that use the GNN itself can slow a single training run, because solving the extra optimization takes time §2.1.2.
- KL direction. The survey writes the standard KD term as teacher-to-student and the LSP loss as student-to-teacher §3.3 eq. 6. Check the original paper before implementing either.
- GLNN limits. Distilling into an MLP fails when the labels depend mainly on the graph and not on node features §3.3.
- Inference-time sampling. Sampling at inference is rarely used, and the survey says it cannot guarantee accuracy or consistency §3.
- Heterogeneous graphs. Treating typed graphs as homogeneous degrades performance, and a pruning step can delete every weight of one edge type §6.1.
- Dynamic graphs. Training must follow time order, and per-timestamp sampling ignores temporal neighbours §6.2.
- Hardware breadth. Customized accelerators mostly target inference, and training accelerators are rare §5.2. Each accelerator trades flexibility for speed §5.2.
- Appendices. Appendix details (training datasets and algorithm variants app. B, inference variants app. C, systems app. D, hardware app. E, special graphs app. F) are cited here by location but not condensed.
Lineage
- Builds on: the surveyed methods above, with the key sources the survey cites for the sampling benchmark [liu2021sampling] and for GCond §2.1.3.
- Compared against: the survey compares families of methods within itself, not against other surveys.
- Superseded by: not stated.
Source and license
Adapted from “A Survey on Graph Neural Network Acceleration: Algorithms, Systems, and Customized Hardware” by Shichang Zhang, Atefeh Sohrabizadeh, Cheng Wan, Zijie Huang, Ziniu Hu, Yewen Wang, Yingyan (Celine) Lin, Jason Cong, Yizhou Sun (arXiv:2306.14052), used under CC BY 4.0. Changes: condensed and restructured for implementation, with tables, equations and algorithms taken from the paper and its code, each cited to its source. Not affiliated with or endorsed by the authors.