SNI-GNN: SmartNIC-Assisted Full-Graph GNN Training with In-Network Embedding Prediction

SNI-GNN: SmartNIC-Assisted Full-Graph GNN Training with In-Network Embedding Prediction Guofan Yu∗ , Sitian Chen∗ , Zhenheng Tang† , Xiaowen Chu‡ , Amelie Chi Zhou∗ ∗ Hong Kong Baptist University † Hong Kong University of Science and Technology

arXiv:2608.06441v1 [cs.LG] 6 Aug 2026

‡ Hong Kong University of Science and Technology (Guangzhou)

Abstract—Full-graph GNN training delivers high accuracy but scales poorly on multi-server clusters due to heavy, irregular internode embedding exchanges. We present SNI-GNN, a SmartNICassisted full-graph training system that reduces communication while preserving accuracy by predicting remote embeddings innetwork. SNI-GNN deploys a lightweight linear-trend predictor on SmartNICs to refine cached historical embeddings, coupled with an importance-based boundary-node sampling policy and an asynchronous DPU–GPU data pipeline with intermediateresult reuse. We provide error and convergence bounds showing that predictor bias remains controlled under bounded secondorder dynamics and yields standard non-convex convergence with inexact gradients. Implemented on NVIDIA BlueField-3, SNI-GNN integrates with state-of-the-art full-graph systems, cuts communication by 21–45%, achieves 1.3–3.6× end-to-end speedups over BNS-GCN and up to 1.29× over baseline SANCUS, with accuracy loss ≤ 0.01, and scales efficiently to 16 GPUs on graphs with up to tens of millions of edges. These results indicate SmartNIC-based in-network prediction is a practical complement to partitioning and compression techniques for communicationefficient full-graph GNN training at scale. Index Terms—distributed systems, graph neural networks, Fullgraph training, SmartNIC, embedding prediction

I. I NTRODUCTION Graph Neural Networks (GNNs) are a class of deep learning models specifically designed for graph-structured data. They have achieved remarkable success across a wide range of applications, including node classification [1], [2], link prediction [3], [4], and graph classification [5], [6]. Owing to their strong performance in capturing topological patterns and relational structures, GNNs have become a cornerstone technique in numerous domains such as social networks [7], [8], recommendation systems [9], fraud detection [10], [11] and molecular biology [12]. A prominent training paradigm in GNNs is full-graph training, which processes the entire graph in each training iteration. Compared to sampling-based approaches, fullgraph training enables precise aggregation of neighborhood information without introducing sampling noise [13], [14]. This results in faster convergence and superior accuracy, particularly in applications that require high structural fidelity, such as knowledge graph reasoning [15] and molecular property prediction [16]. However, full-graph training also poses significant scalability challenges, particularly in distributed settings. Since full-graph training requires access to the entire graph in each iteration, it

often exceeds the memory capacity of a single GPU or even a single machine, especially for large-scale real-world graphs containing millions or billions of nodes and edges [17]–[19]. As a result, the graph and its associated features must be partitioned and distributed across multiple computing nodes. This distributed setup introduces substantial communication overhead. During training, each node must frequently exchange feature and embedding information with other nodes to obtain the latest states of neighboring vertices. The inherent sparsity and irregularity of graph data further exacerbate the challenge, as they lead to unpredictable and imbalanced communication patterns in terms of volume, frequency, and destinations. Consequently, communication often becomes the dominant bottleneck, significantly limiting training throughput and hindering system scalability. To mitigate communication overhead, recent studies have explored a range of techniques such as overlapping communication and computation [20]–[22], using stale embeddings [23], [24], and compressing data via quantization [25]. Despite these efforts, most existing works focus on single-machine multi-GPU setups, largely constrained by the scale of publicly available datasets. In contrast, industrial-scale graphs demand multi-server training architectures. Yet, most full-graph training systems supporting multi-server configurations are simple extensions of single-node designs [23], [24], [26], failing to exploit opportunities for communication optimization in multi-node environments. In comparison, mini-batch GNN training systems have begun to incorporate inter/intra-node communicationaware strategies, such as adaptive sampling [27]. In modern data centers, SmartNICs are increasingly adopted to address communication challenges in large-scale distributed systems. Unlike traditional NICs, SmartNICs offer programmable computing capabilities, enabling them to offload certain network and system-level tasks from CPUs. This architectural shift enhances overall system efficiency and reduces network congestion [28], [29]. We identify a new opportunity from the vantage point of SmartNICs. Positioned in the inter-node data path and equipped with programmable compute and memory, SmartNICs can cache and process embeddings in transit without consuming host CPU/GPU cycles. Empirically, we observe that node embeddings evolve smoothly over time during training, making them amenable to lightweight temporal forecasting. This motivates in-network prediction: refine stale embeddings directly

on the SmartNIC, reduce cross-node exchange frequency, and control staleness without introducing new synchronization. We present SNI-GNN, a SmartNIC-assisted and communication-efficient full-graph GNN training system for multi-server clusters. In contrast to software-only optimizations that contend for host-side resources, SNI-GNN leverages the DPU to perform active staleness mitigation directly on the data path. By offloading a lightweight linear-trend predictor to the SmartNIC, our system decouples embedding extrapolation from the bottlenecked host CPU and eliminates the redundant PCIe traffic associated with host-based prediction. This design ensures strict hardware isolation between the prediction logic and the main training process. To manage the DPU’s specialized resource constraints, SNI-GNN employs boundary-node importance sampling to prioritize the most influential neighbors. It further utilizes an asynchronous DPU–GPU pipeline with intermediate-result reuse to overlap in-network prediction, data transfer, and GPU computation. Based on the assumption of bounded second-order dynamics where embeddings evolve smoothly with bounded curvature, we provide a rigorous theoretical foundation. This analysis proves that the predictor’s bias remains controlled and establishes standard non-convex convergence despite the use of inexact gradients. We prototype SNI-GNN on NVIDIA BlueField-3 DPUs and integrate it with state-of-the-art full-graph systems, including SANCUS and NeutronTP. Across datasets with up to tens of millions of nodes and scaling up to 16 GPUs, SNI-GNN reduces inter-node communication volume by 21–45%, delivering 1.3–3.6× end-to-end speedups over the sampling-based BNSGCN [30]. Notably, it achieves up to a 1.29× marginal speedup over an optimized SANCUS [24] baseline by eliminating PCIe bottlenecks and host-resource contention through innetwork prediction. Our evaluation across diverse architectures, including GraphSAGE and GAT, confirms the framework’s generalizability, while experiments with 4-layer and 6-layer GNNs demonstrate its robustness against staleness amplification in deeper networks. Throughout these stress tests, SNI-GNN consistently maintains model accuracy within 1% of the ideal synchronous training. SNI-GNN makes the following contributions:

intermediate-result reuse. This design enables the complete overlapping of prediction, RDMA transmission, and GPU computation, effectively hiding communication latency without introducing new synchronization barriers. • Theoretical Rigor and System Validation: We provide error and convergence guarantees under bounded secondorder dynamics. Our BlueField-3 prototype demonstrates that SNI-GNN is not a standalone extension but a generalizable enhancement that integrates with existing full-graph systems, yielding up to 1.29× marginal speedups over alreadyoptimized baselines. II. BACKGROUND AND M OTIVATION A. Graph Neural Networks Graph Neural Networks (GNNs) are deep learning architectures designed to process graph-structured data, where nodes represent entities (e.g., users, molecules) and edges encode relationships. Unlike traditional neural networks for grid-like data, GNNs leverage message-passing mechanisms [31] to iteratively refine node representations by propagating and aggregating features across the graph’s topology. A GNN model comprises L layers, where each layer transforms node embeddings to capture increasingly complex (l) structural patterns. Let hv denote the feature vector of node v at l-th layer, which is updated through two key steps: • Aggregation: Node v gathers feature vectors from its neighbors N (v), applying a permutation-invariant aggregation function (e.g., sum, mean) to handle variable-sized inputs:   (l) a(l) {h(l−1) | u ∈ N (v)} (1) v = AGGREGATE u •

(l)

Update: The aggregated features av are combined with v’s (l−1) previous state hv via a function fθ (e.g., MLP), where θ are learnable parameters:   (l) h(l) h(l−1) , a(l) (2) v = fθ v v

Through successive layers, nodes integrate information from their L-hop neighborhoods, enabling hierarchical feature learning across graph topology. Despite their expressive power, training GNNs on large-scale graphs presents significant • Active Mitigation Architecture: We propose a SmartNIC- challenges. The message-passing paradigm requires frequent assisted training stack that moves beyond passive staleness access to neighbor embeddings, creating memory bottlenecks tolerance to active in-network mitigation. Unlike prior host- when storing intermediate states for billions of nodes. Moreover, centric systems, SNI-GNN targets inter-node bottlenecks neighborhood aggregation triggers irregular data access patterns by isolating prediction logic on the DPU, eliminating host- that strain computational resources [32], [33]. resource contention and PCIe-induced synchronization stalls. B. Distributed Full-Graph GNN Training • Hardware-Aware Predictor: A lightweight linear-trend predictor specifically optimized for SmartNIC constraints. By combining ring-buffer histories with boundary-node importance sampling, we enable high-fidelity embedding estimation for billion-scale graphs within the limited memory and compute budget of the DPU’s ARM cores. • Conflict-Free Asynchronous Pipeline: A specialized DPU–GPU and inter-node execution pipeline featuring

Large-scale graph datasets necessitate distributed training frameworks to overcome memory and computational constraints. Two primary paradigms exist, including mini-batch training and full-graph training. Mini-batch training partitions a graph into small batches for sequential processing [17], [34], [35]. Although this approach introduces lower memory footprint due to neighbor sampling, it can also lead to decreased accuracy

GPU

HOST

Full Graph Remote Embedding

3 Aggregate

& Update

2 Message Passing PCIe or NVLINK

Partitioning

GPU

M e s s a g e P a s s in g

2 0 %

Local Embedding 1 Graph

A g g re g a te & U p d a te 1 0 0 %

Local Embedding

0 %

8 N _ 1 G

4 N _ 2 G

2 N _ 4 G

R e d d it

8 N _ 1 G

4 N _ 2 G

2 N _ 4 G

o g b n -p ro d u c ts

Fig. 2: Full-Graph GNN training time breakdown (l−1,t)

embedding hu for a remote neighbor u, a worker uses a (l−1,t) (l−1,t−1) Remote cached version h̃ = hu . u 3 Aggregate Embedding & Update While this approach reduces network pressure, it introduces Full Graph embedding staleness due to the discrepancy between the Fig. 1: General flow of distributed full-graph GNN training cached historical value and the current, updated embedding. due to incomplete neighborhood aggregation. Full-graph train- As training progresses, stale embeddings can distort the ing, on the contrary, processes the entire graph simultaneously aggregation step, potentially degrading model convergence across distributed workers [23], [24], [30], [36]. This approach and final accuracy [42]. This is especially true for deep GNN preserves full-neighbor aggregation semantics and enables full- architectures or graphs with dynamic topological dependencies. batch gradient descent, yielding higher accuracy and faster According to Equation 1 and 2, using historical embeddings convergence. Our paper focuses on full-graph training for its during training leads to an approximation of message aggregaaccuracy benefits, and strive to address its unique scalability tion, as formulated below: challenges. Full-graph training performance is severely constrained by    (l−1,t−1) (l−1,t) communication bottlenecks arising from graph partitioning h(l,t) ≈ f h , AGGREGATE { h̃ | u ∈ N (v)} θ v v u and cross-worker dependencies. As shown in Figure 1, the (3) (l−1,t−1) full-graph GNN training can be decomposed into three stages: where the historical embedding h̃(l−1,t) = hu . More u (l−1,t) (l−1,t−i) • Partitioning: The graph is split across workers using various generally, we could use h̃u = hu , i ≤ t − 1, graph partitioning strategies (such as METIS [37], LDG [38] meaning that we could use older historical embeddings to or KaHIP [39]). Vertex embeddings of the entire graph are approximate the embedding in the current iteration and i is a copied onto each worker (hence full-graph training). This parameter that trades-off communication and accuracy. stage is performed only once during the entire training. To quantify the staleness introduced by historical embed• Message Passing: For each training iteration, workers ex- dings, we conducted a comparative experiment on four nodes change vertex embeddings to resolve cross-partition depen- using Reddit and ogbn-products datasets. We vary the synchrodencies. For example, if node v on Worker A has a neighbors nization interval from 1 to 3, meaning the fresh embeddings will (l−1) u on Worker B, Worker A must fetch hu from B to update be communicated every 2-4 iterations. When there’s no fresh (l) embedding, the training will use the most up-to-date historical hv . • Aggregate and Update: Each worker aggregates the re- embedding. To ensure convergence, the stale synchronization ceived/local neighbor embeddings using Equation 1 and starts at 30-th epoch. The staleness is measured using the L2 updates vertex features using Equation 2. Parameters of the norm of the difference between historical embeddings and (l−1,t) (l−1,t) − h̃u ||. The results in aggregate and update functions are updated through forward fresh embeddings, namely ||hu Figure 3 quantitatively validate the staleness problem inherent and backward propagation. We conducted experiments on an eight-GPU V100 cluster in historical embeddings. Across datasets, we observe a clear with varying node configurations: 2 nodes with 4 GPUs each positive correlation between communication synchronization (2N_4G), 4 nodes with 2 GPUs each (4N_2G), and 8 nodes interval and embedding staleness and the staleness persists with 1 GPU each (8N_1G). All nodes are interconnected via a throughout the training process. Larger staleness usually means 10 Gbps Ethernet. We evaluated full-graph GNN training across poorer accuracy. Therefore, if we aim to reduce communication two dataset scales: ogbn-products [40] and Reddit [41]. Detailed frequency to mitigate performance bottleneck while preserving configurations can be found in Section V. Figure 2 presents accuracy, we need to bridge the staleness gap through the time breakdown on computation (aggregation and update) intelligent local computation that brings historical embeddings and communication (message passing). As clearly evidenced closer to their current values. Full Graph Embedding

in the figure, the communication consistently dominates the training overhead across all configurations and datasets. C. Historical Embeddings and Staleness in GNN training To mitigate the large communication costs, a common technique is to reuse historical embeddings from previous iterations [24], [34], [42], [43]. Instead of fetching the latest

D. The Opportunity of SmartNICs Smart Network Interface Cards (SmartNICs) are programmable hardware components integrated into the network data path. Unlike traditional NICs, they possess onboard multicore processors, memory, and accelerators, allowing them to offload and execute operations directly on data in transit [44].

2 2

C o m m .-S y n c . In te rv a l = 3 C o m m .-S y n c . In te rv a l = 2 C o m m .-S y n c . In te rv a l = 1

1 8

S T A L E N E S S

S T A L E N E S S

2 0 1 6 1 4 1 2 1 0 8 6 4 2 0 0

5 0

1 0 0 1 5 0 2 0 0 2 5 0 3 0 0 E p o c h

5 .0 4 .5 4 .0 3 .5 3 .0 2 .5 2 .0 1 .5 1 .0 0 .5 0 .0

o g b n -p ro d u c ts

1 5 0 2 0 0 E p o c h

2 5 0

3 0 0

Cache PCIE

GPU

DPU

ARM DMA Engine

Memory

NIC

NETWORK

Fig. 4: System architecture with BlueField-3 SmartNIC. In distributed machine learning, SmartNICs have been explored to accelerate collective communication operations (e.g., broadcast, all-reduce) [45], [46], compress gradient data [47], [48], and offload optimizer states [49]. Their strategic position is key: sitting between the host and the network, they can intercept, process, and cache data without consuming GPU or CPU resources. This makes them ideal for implementing in-network caching and computation to improve scalability and resource utilization in large-scale ML clusters. However, the application of SmartNICs to GNN training remains largely unexplored. The unique challenges of GNNs, including irregular communication, high-dimensional embeddings, and the staleness problem, align perfectly with the capabilities of SmartNICs. This work takes the first step toward filling this gap by designing a SmartNICassisted full-graph GNN training framework. III. D ESIGN R ATIONALE As shown in Figure 2, communication is the main performance bottleneck in full-graph GNN training. A straightforward and well-studied approach to reduce communication overhead is to utilize historical embeddings stored locally. While historical embeddings effectively decrease communication volume, their accumulating drift inevitably degrades model accuracy. This necessitates a compensation mechanism that can proactively refresh stale embeddings. However, implementing such mechanism naively on already-bottlenecked GPUs would simply replace communication overhead with computational overhead. While host CPUs might appear to have idle cycles, they are heavily taxed in high-performance GNN training with graph partitioning, data loading, and orchestrating GPU kernels. Offloading the compensation mechanism to the CPU would necessitate bidirectional PCIe traffic—fetching cached embeddings from the NIC, processing them in the CPU, and

25

25

10

15

15

10

10

5

5

20

0

0

0

1 0 0

30

30

15

0

5 0

Node3 35

35

20

Fig. 3: Comparison of embedding staleness with different communication synchronization intervals. Host

40

5

0

Node2

Node1 25

C o m m .-S y n c . In te rv a l = 3 C o m m .-S y n c . In te rv a l = 2 C o m m .-S y n c . In te rv a l = 1

Feature

R e d d it 2 4

50 100 150 200 250 300

Epoch

0

50 100 150 200 250 300

Epoch

0

50 100 150 200 250 300

Epoch

Fig. 5: Predictable embedding evolution across training epochs. Individual dimension trajectories for three randomly sampled nodes (Reddit dataset) exhibit smooth, gradual changes, validating that lightweight temporal prediction can effectively compensate for embedding staleness. pushing predictions back to the GPU, thereby congesting the already busy PCIe channels used for CPU-GPU data exchange. SmartNICs, on the other hand, offer a strategic solution to this impasse. Positioned directly within the communication path and equipped with dedicated compute and memory resources, they can perform lightweight embedding computations without contending for GPU cycles. This architectural advantage enables SNI-GNN to address the staleness problem at its source (i.e., in the network) while keeping the training process undisturbed. However, effectively leveraging SmartNICs for this purpose requires addressing a key design question: How to create a staleness compensation mechanism that is accurate enough to mitigate staleness while lightweight enough to fit in SmartNICs’ limited computation power? To answer this question, we studied the temporal evolution of embeddings during GNN training. Figure 5 shows the trajectory of individual embedding dimensions across three representative nodes, revealing a crucial pattern: hidden features evolve smoothly and gradually over time rather than exhibiting erratic, unpredictable changes. This observed smoothness provides the theoretical foundation for our predictor-based approach: if embedding dimensions follow consistent, lowvariance trajectories, then their near-future values can be reliably estimated from recent history. Consequently, we can design a temporal predictor that extrapolates from cached embeddings to generate accurate, stale-free approximations, achieving effective staleness compensation without exceeding SmartNIC computational constraints. For a prediction model, it is necessary to update the model parameters with the latest embeddings each time. This allows the model to continuously adapt to the changing direction of embeddings as training progresses. As shown in Figure 5, different dimensions exhibit distinct curve patterns, implying that an ideal predictor would require separate, complex models per dimension. This would create a significant computational burden, making our mechanism impractical for resource-constrained SmartNICs. To resolve this tension, our design employs two key strategies: 1) a single, highly lightweight linear-trend predictor shared across all dimensions to minimize computational overhead, and 2) an importance-based sampling policy that selectively updates only the most critical nodes and dimensions, ensuring the predictor’s

workload remains feasible without sacrificing accuracy. IV. D ESIGN D ETAILS OF SNI-GNN A. System Overview

Algorithm 1 In-Network Embedding Prediction Algorithm procedure P REDICT(Hv , t) τlatest ← max(τk ∈ Hv ) ∆t ← t − τlatest h̄v ← 0.3 · Hv [τlatest ] + 0.7 · mean(Hv ) Φv ← 0; W ← 0 for k = 2 to K do δτ ← τk − τk−1 ϕ(k) ← (Hv [k] − Hv [k − 1])/δτ wk ← exp(−|τlatest − τk |/5.0) Φv ← Φv + wk · ϕ(k) W ← W + wk end for Φv ← Φv /W return h̄v + ∆t · Φv · exp(−0.2∆t) end procedure

The core idea of SNI-GNN is to mitigate embedding staleness by predicting the current values of remote embeddings directly within the network, thus reducing the need for frequent synchronization. Our design is guided by two key observations from empirical studies of GNN training dynamics. First, as shown in Figure 5, embedding vectors evolve smoothly over time, making them amenable to temporal forecasting. Second, different embedding dimensions exhibit distinct evolution patterns, suggesting that per-dimension modeling would be ideal but computationally prohibitive for resource-constrained SmartNICs. This tension motivates our design of a single lightweight predictor that operates across all dimensions, complemented by strategic sampling to maintain feasibility. In the following, we first introduce the design details of our lightweight predictor model (Section IV-B), followed by SmartNICs-specific system optimizations to reduce prediction latency (Section IV-C). Training Workflow. Figure 6 illustrates the overall architecture of SNI-GNN in a multi-node distributed training setup. As initialization, SNI-GNN performs a one-time graph partitioning and each node holds a subgraph. Each node consists of a GPU for model computation and a SmartNIC (DPU) for in-network processing. During training, the DPU maintains historical embedding caches and performs lightweight prediction, while the GPU handles the main GNN computation. The architecture supports two operational modes: Sync Epochs, where fresh embeddings are exchanged between nodes and DPU caches are updated, and Stale Epochs, where DPUs supply predicted embeddings to local GPUs. This design effectively positions the SmartNIC as an intelligent communication filter between the GPU and network, enabling embedding prediction directly in the data path.

4) e−λ∆t (we use λ = 0.2) exponentially decays the trend contribution with time. The detailed prediction method is shown in Algorithm 1. To justify our choice, we compare the linear-trend predictor against ARIMA [50], HOLT [51], and an LSTM [52] baseline. As shown in Figure 7 and Table I, while ARIMA achieves slightly higher peak accuracy, its computational cost is nearly an order of magnitude higher than our approach, making it unsuitable for real-time in-network processing. The comparison between HOLT and Linear-Trend is particularly critical. Although both are lightweight and exhibit similar computation times per epoch, our Linear-Trend predictor achieves ≈0.7% higher peak accuracy (92.06% vs. 91.36% on Reddit) and demonstrates more stable convergence with significantly fewer gradient oscillations. From an architectural perspective, HOLT requires maintaining multiple state variables (level, trend, and seasonal components) per embedding dimension, which rapidly exhausts the DPU’s limited on-board memory. Our LinearTrend model minimizes this state storage, enabling the system to support larger graph partitions and a higher sampling ratio within the DPU’s resource budget.

B. Lightweight Linear-Trend Predictor

C. SmartNIC Implementation and Optimizations

The predictor runs on the SmartNIC and maintains a historBased on the design rationale, we implement a lightweight ical embedding table for sampled remote nodes. Training uses linear-trend predictor that aims to reduce the staleness gap (t) (t) (t) a fixed synchronization interval s. At each sync epoch every ∆v = ∥hv − h̃v ∥ without increasing inter-node communiworker broadcasts its latest embeddings; the SmartNIC updates cation. its history from received embeddings and forwards the fresh The predictor estimates the embedding at the current time embeddings to the local GPU. During stale epochs (between step by extrapolating the recent trend relative to the latest syncs) the SmartNIC predicts the next embedding using the stored embedding. The prediction target is given in Equation 4. linear-trend model, and supplies the predicted embeddings to ĥ(t) h̄v + ∆t · Φv · e−λ∆t (4) the GPU for aggregation. v = |{z} | {z } Each SmartNIC maintains a fixed-size circular buffer for baseline trend each tracked remote node: where: n oK k) 1) ∆t = t − τlatest is the number of steps since the most Hv = τk , h(τ ∈ RK×D , τk ∈ Z+ (5) v k=1 recent stored embedding. (τ ) k) 2) h̄v = αhv latest + (1 − α)Hv is an exponential-moving- where τk denotes the global step when embedding h(τ was v average (EMA) baseline (we set α = 0.3 in our imple- received, and K is the buffer capacity . mentation). However, due to the constraints on computing power and 3) Φv is a weighted trend vector estimated from recent slope memory of the DPU on the SmartNIC, a significant overhead estimates in the history. would be introduced if we re-construct the entire time series

Full Cache

CPU 1 Partition 5

2

6 8

6 7 8 Remote Embedding

3 7

Update Local

5

1

Training Process

Cache

Local Embedding 1 2 3 4

Stale epoch L L L

P L

L L

P

R

Sync epoch L R

R L

L

Local Emb

R

GPU

From remote

P From prediction L From local cache

Update prediction

Cache Controller L

Remote Emb

R P

4

History Manager

History Table 6 2 Sampling

7

6 6 6 6 7 7 7 7 t-3

~~

Update

t

t+1 t-2 ~~ t 6 6 6 6 7 7 7 7 Update from prediction or remote

Predictor Update Trend Params

History Cache

Prediction Update Prediction

Prediction Controller P L R

DPU

NIC

Bluefield3

Fig. 6: System architecture for SmartNIC-assisted full-graph GNN training. Each node has a GPU and a SmartNIC. SmartNICs handle embedding caching, asynchronous data transfer, and in-network prediction to enable efficient decentralized full-graph training.

Accuracy

0.9 0.8

Linear-Trend HOLT ARIMA LSTM

0.7 0.6

0

50

100

150 Epoch

200

250

TABLE I: Computation time and peak accuracy of different predictors Method Time (s) Acc. (%)

300

Ours

Fig. 7: Comparison of prediction HOLT accuracy curves across different ARIMA LSTM forecasting methods Computation

Predictor

Intermediate Result Reuse

Memory

History Table

Cache Manager

Prediction controler

Communication Backend

DOCA

Pytorch

48.2 46.83 425.2 57.37

Sampling Based on Node Importance

Data pipeline

OpenMP

92.88 92.14 93.18 92.39

Fig. 9: Node sampling methods (taking the full-graph training of a three-node graph as an example). We set the sampling_ratio to 1/3, and after sorting the adjacency relationships of nodes for worker 2 and worker 3, node 4 and node 7 are selected to use predicted values for training, while other remote nodes only use historical embeddings.

node sampling strategy for the embedding predictor. In fullgraph training, each worker requires access to remote node Fig. 8: Predictor design overview. The blue modules represent embeddings, which can strain the DPU’s limited resources. Our the functional modules of the predictor, while the green modules approach prioritizes prediction for the most influential remote represent the optimization schemes we adopted and their nodes while using standard historical embeddings for the rest. corresponding optimization levels. We define a node’s importance by the number of edges it has for all nodes and perform trend calculation every time we connecting to the local worker’s subgraph, a technique known update the historical records during synchronization rounds, as boundary node sampling. Nodes with more connections as specified in Algorithm 1. Therefore, to further improve the are considered more critical to the local subgraph’s updates efficiency of the predictor and keep the SmartNIC overhead and are selected for prediction. The sampling_ratio parameter low, we have implemented several optimizations. controls the fraction of high-importance nodes that will receive Figure 8 shows the predictor architecture. The predictor predicted embeddings, allowing a trade-off between prediction contains four logical modules: the historical-embedding table, accuracy and computational load. a cache manager, the predictor core, and a prediction controller. As illustrated in Figure 9, the full graph is partitioned across Together these modules manage memory, computation, and three workers. When updating Subgraph 1 (nodes 1, 2, 3), SmartNIC–GPU communication. We apply three optimizations: we calculate the importance of its remote neighbors. Node 4 importance-based sampling, an asynchronous data pipeline, and has the most connections to Subgraph 1, followed by node intermediate-result reuse to keep SmartNIC overhead low. 7. With a sampling_ratio of 1/3, only the top-ranked nodes 1) Node sampling: To reduce the memory and computational (i.e., 4 and 7) are updated using the SmartNIC’s predictor. The overhead on the SmartNIC, we implement an importance-based remaining remote nodes are updated using their last known

��_� Time

GPU

�1_1

��_�

�1_2

DPU �1_2 �2_2 �1_2 �2_2 PCIE

Prediction for Layer n from src i Broadcast data from src i in Layer n

�2_1

(a) Stale Epoch

�2_2

��_� Time

��_�

GPU �1_1 �1_1

DPU PCIE

Compution for Layer n trunk from src i Data transfer for Layer n from src i

Algorithm 2 Self-Feeding Trend Update

�1_2 �1_2 �2_1 �2_1 �2_2 �2_2 �1_2

�1_2

�2_2

(b) Sync Epoch

�2_2

Fig. 10: The asynchronous communication pipeline in SNIGNN (illustrated with a 2-worker, 2-layer GNN configuration).

Inputs: Batch nodes I; optional observations X obs ∈ R|I|×d ; mask M obs ∈ {0, 1}|I| ; time t. State: Ring buffers H ∈ RN ×W ×d , T ∈ ZN ×W , write index pos ∈ {0, . . . , W − 1}N ; Last values xlast ∈ RN ×d , tlast ∈ ZN ; Trend accumulators N ∈ RN ×d , D ∈ RN . Params: Window W ; decay rates λ > 0, β > 0; numerical ε > 0. Procedure: 1) For each i ∈ I: a) ∆ ← t − tlast [i]; b) Trend: v ← N [i]/ max(D[i], ε). −β∆ c) Predict: xpred ← xlast . ( [i] + v · ∆ · e obs obs X [i], if M [i] =1 d) Self-feed: xnew ← xpred , otherwise e) Write ring buffer: p ← pos[i]; H[i, p, :] ← xnew ; T [i, p] ← t; pos[i] ← (p + 1) mod W . f) Decay accumulators: γ ← e−λ∆ ; N [i] ← γN [i]; D[i] ← γD[i]. g) New slope: snew ← (xnew − xlast [i])/ max(∆, ε). h) Update accumulators: N [i] ← N [i] + snew ; D[i] ← D[i] + 1. i) Update last: xlast [i] ← xnew ; tlast [i] ← t. j) Output xpred for node i.

historical embeddings. This selective prediction reduces the DPU’s workload while focusing its computational power on the nodes most likely to affect model convergence. 2) Communication Pipeline: As shown in Figure 10, we have designed specialized data slicing and asynchronous pipelines to mitigate the inherent overhead of transferring data through DPU RAM and the additional latency required for DPU-to-GPU transmission. We categorize training epochs into two distinct execution modes: Stale Epochs and Sync Epochs. In a Stale Epoch (Figure 10a), physical network communication for boundary nodes is skipped to reduce traffic volume. Instead of waiting for a broadcast, the GPU asynchronously obtains extrapolated values (Pn,i ) from the DPU and merges them with the local cache. By offloading the prediction logic manner. During each update, only the impact of the oldest entirely to the SmartNIC, we ensure that the GPU’s GNN historical record needs to be removed, and then the trend is training process (Cn,i ) remains undisturbed, with the prediction updated using the latest embedding record. ii) Self-feeding: latency hidden by the concurrent forward and backward passes. Since the time steps of the warm-up phase and the actual In a Sync Epoch (Figure 10b), the GPU performs global training phase are different, if we want to use intermediate embedding synchronization (Bn,i ) and concurrently sends the cached results to reduce the computational load of the predictor, fresh embeddings of remote workers to the DPU. This allows historical records need to be filled. Therefore, directly using the DPU to update the linear-trend model and generate the predicted values as historical records to fill the historical record predicted values for the subsequent epoch. Because the DPU table can reduce interpolation overhead. is positioned directly on the data path, it can provide these predictions to the GPU immediately after the broadcast is com- D. Theoretical Analysis pleted without introducing additional synchronization barriers. We analyze the convergence of SNI-GNN by bounding By carefully scheduling the computational workload and data the prediction error and its impact on gradients. We assume transmission (Tn,i ) between the DPU and GPU, our pipeline standard bounds: N nodes, dimension d, weight matrices minimizes the architectural overhead introduced by utilizing bounded by C, and adjacency blocks bounded by B. The the DPU as an intermediate transmission layer, ensuring that loss L and activations are ρ-smooth/Lipschitz. the benefits of active staleness mitigation outweigh the costs Theorem IV.1 (Prediction Error). If the second-order difference of hardware offloading. (t) (t−1) +H (t−2) ∥∞ ≤ ϵ, 3) Predictive intermediate Result Reuse: Since the pre- of embeddings is bounded by ∥H −2H diction process requires shifting the time window each time the linear-trend predictor error satisfies: synchronization occurs, it necessitates repeatedly recalculating ∥Ĥ (t) − H (t) ∥∞ ≤ 12 (∆t)2 ϵ =: ϵH , trends. Additionally, as the synchronization interval increases, where ∆t ≤ s is the staleness. intermediate historical data may be missing. If interpolation methods are used to replace the intermediate historical data, Proof Sketch. Approximating H (t) via a second-order Taylor it would incur significant computational overhead. Therefore, expansion around τlatest , the linear predictor captures the firstwe employ prediction records to substitute for the intermediate order trend (h̄ ≈ H (τ ) , Φ ≈ H ′(τ ) ). The error is thus dominated historical data. Moreover, each time the time window slides, by the second-order term 12 (∆t)2 H ′′(τ ) , bounded by ϵ. some previously computed results, as well as intermediate predictions and the latest synchronization results, are overwritNext, we bound how this error propagates to gradients. Let ten. To address this algorithmic characteristic, we designed a p be the maximum communicating workers. prediction algorithm that reuses intermediate results, as shown Lemma IV.2 (Gradient Error Bound). The gradient estimation in Algorithm 2. error is bounded by: The most critical steps in the algorithm are as follows: i) ∥∇L̂ − ∇L∥∞ ≤ K := ρC 2 B 2 (p + CB)ϵH . Trend accumulators: Trends are stored in a prefix sum-like

TABLE II: Graph Datasets Name

Nodes

Edges

Features

Classes

Reddit IGB-small ogbn-products IGB-medium

232,965 1,000,000 2,449,029 10,000,000

11,606,919 12,070,502 61,859,140 120,077, 694

602 128 100 128

41 19 47 19

Proof Sketch. Using the triangle inequality andP submultiplicativity on the GNN aggregation T (l) = AH, the feature error bounds are ∥T̂ − T ∥∞ ≤ pCBϵH and ∥Ẑ − Z∥∞ ≤ C 2 B 2 ϵH . Since backpropagation distributes these errors linearly through ρ-Lipschitz components, the gradient difference is bounded by K. Theorem IV.3 (Convergence). With learning rate η = min{ ρ1 , √1N }, non-convex SGD with SNI-GNN satisfies: min E[∥∇L(Wt )∥2F ] ≤ t

√ 2(L0 − L∗ ) + ρK √ = O(1/ N ). N

Proof Sketch. This follows from standard SGD analysis with inexact gradients [24]. The gradient bias K is constant; setting sync interval s = O(N −1/4 )√ensures the error term ϵH ∝ s2 does not dominate the O(1/ N ) convergence rate. V. E VALUATION This section describes our experimental setup and evaluates the system’s efficiency and accuracy. We also include ablation studies to quantify the contribution of each component. A. Experiment Setup Testbed. Experiments were performed on a cluster of eight GPU nodes. Each node is equipped with two Intel Gold CPUs (v5 series, 16 cores, 2.3GHz), 192 GB of DRAM, one NVIDIA V100 GPU, and one NVIDIA BlueField-3 DPU (SmartNIC) running CentOS 7. The network provides 10 Gbps bandwidth. We use CUDA 12.2, DOCA 3.0, OpenMPI 4.0.5, PyTorch v2.5.1, and cuDNN 9.1.0 in our software stack. Datasets. Table II lists the datasets used in our experiment, including Reddit [41], IGB-small [53], ogbn-products [40] and IGB-medium [53]. These are widely adopted datasets in GNN training research and are presented in ascending order of scale. We evaluate SNI-GNN across several GNN architectures with varying depths and computational complexities: 1) We use 3-layer GCN [54] as our primary benchmarks for standard fullgraph training comparison. To assess the system’s robustness against staleness accumulation in deeper networks, we extend our evaluation to include 4-layer and 6-layer GCNs. 2) We implement a light variant of the Graph Attention Network (GAT) [55] and GraphSAGE [41]. Unlike the static weighting in GCN, GAT involves dynamic, learnable attention coefficients, which test the linear-trend predictor’s ability to handle more complex embedding evolution patterns. For all models, we set the hidden dimension size to 16 and use the Adam optimizer. We follow the standard training-validation-test split provided by the respective dataset creators. Comparisons. To demonstrate the generality and effectiveness of SNI-GNN, we integrate our in-network prediction mechanism into two state-of-the-art full-graph GNN training

systems with distinct communication-reduction strategies: SANCUS [24] and NeutronTP [36]. SANCUS leverages historical embeddings to reduce communication frequency but lacks explicit staleness compensation, making it susceptible to accuracy degradation from embedding drift. NeutronTP employs tensor parallelism and computation/communication overlap for performance scaling but maintains synchronous execution without stale embeddings. These complementary baselines allow us to evaluate SNI-GNN’s prediction benefits across different architectural paradigms. Additionally, we compare against BNS-GCN [30], a sampling-based approach that reduces communication through random boundary node sampling, providing perspective against non-full-graph methods. Configurations. Our evaluation employs a structured experimental design to comprehensively assess SNI-GNN across multiple dimensions. First, we conduct an overall performance comparison using three datasets (Reddit, IGB-small, and ogbn-products) that are directly compatible with all baseline methods. The IGB-medium dataset required graph coarsening for SANCUS to avoid Out-of-Memory errors, and due to framework incompatibilities with BNS-GCN’s sampling-based approach, we excluded it from this specific multi-system comparison to ensure a fair, non-coarsened evaluation (Section V-B). For scalability analysis, we focus exclusively on full-graph systems (SANCUS and NeutronTP) across all four datasets. We scale the system from 4 to 16 GPUs to observe how the SNI-GNN pipeline maintains throughput as inter-node communication pressure increases (Section V-C). For sensitivity and robustness studies, we perform detailed parameter studies to isolate the impact of synchronization intervals and sampling rates on both model accuracy and system efficiency. To demonstrate architectural generalizability, we extend our evaluation beyond GCN to include GraphSAGE and GAT variants, including deeper architectures (4–6 layers) to test robustness against staleness accumulation (Section V-E). All experiments are evaluated across four key metrics: total training time, communication reduction effectiveness, prediction accuracy, and training convergence behavior, providing a comprehensive assessment of SNI-GNN’s performance characteristics. In Section V-D, we explicitly study the accuracy impact of staleness techniques. B. Overall Comparison Results In the overall comparison, all methods were trained for 300 epochs using a 3-layer GCN [54] with a 20-epoch warmup period, consistent with established practices for stalenesstolerant training. Figure 11 presents results where SNI-GNN maintains accuracy loss within 0.01 across all datasets, using sampling rates of 0.3, 0.1, and 0.05 for Reddit, IGB-small, and ogbn-products, respectively. At these conservative sampling rates, the DPU-based predictor operates transparently alongside GPU training without introducing observable overhead. Our analysis reveals that SANCUS experiences significant accuracy degradation when communication intervals exceed three epochs, whereas SNI-GNN enables safe extension to five

S y n c h r o n iz a tio n

4 0 2 0

T im e ( s )

T im e ( s )

T im e ( s )

C o m m u n ic a tio n 2 4 0

8 0

6 0

0

C o m p u ta tio n

1 0 0

8 0

6 0 4 0

1 8 0 1 2 0 6 0

2 0 B N S -G C N

S C S

S C S -S N I

N T P

0

N T P -S N I

B N S -G C N

S C S

IG B - s m a ll

S C S -S N I

N T P

0

N T P -S N I

B N S -G C N

S C S

R e d d it

S C S -S N I

N T P

N T P -S N I

o g b n -p ro d u c ts

Fig. 11: Runtime breakdown (synchronization, computation, communication) using 8 nodes for 3-layer GCN (hidden=16) on Reddit/IGB-small/ogbn-products datasets. Methods: BNS-GCN, SCS (SANCUS), SCS-SNI (SANCUS+SNI), NTP (NeutronTP), NTP-SNI (NeutronTP+SNI). S C S -E 3

S C S -S N I-E 5

IG B - s m a ll

0 .8

0 .4

0 .4 0

5

1 0

1 5

2 0

2 5

T im e ( s )

o g b n -p ro d u c ts

0 .6

0 .6

0 .2

B N S -G C N 0 .8

A C C

A C C

A C C

N T P -S N I-E 1

0 .8

0 .6

0 .2

N T P

R e d d it

1 .0

0

1 0

2 0

T im e ( s )

3 0

4 0

0 .4 0 .2 0

2 0

4 0

6 0

T im e ( s )

Fig. 12: The accuracy results using 8 nodes for 3-layer GCN (hidden=16) on Reddit/ogbn-products/IGB-small datasets. The prediction sampling rates for the three datasets are 0.3, 0.1 and 0.05. E1/3/5 represents performing synchronous communication once every 1/3/5 iterations during training. intervals while preserving model quality. This translates to communication reductions of 28.97%, 31.86%, and 23.2% across the three datasets, respectively. SNI-GNN also substantially benefits NeutronTP, achieving communication reductions of 37.45%, 25.42%, and 44.3% despite its architectural constraints on stale execution. The end-to-end performance gains are equally compelling: SNI-enhanced SANCUS achieves speedups of 2.34×, 1.56×, and 1.73× over BNS-GCN, while SNI-enhanced NeutronTP delivers even greater improvements of 2.51×, 3.55×, and 1.60× over the sampling-based baseline. These results demonstrate SNI-GNN’s ability to enhance diverse training frameworks while maintaining strict accuracy guarantees. Figure 12 demonstrates SNI-GNN’s impact on training convergence and final accuracy across all experimental configurations. While the initial warm-up period produces overlapping accuracy curves across methods, SNI-GNN’s advantages become pronounced in the critical later training stages. SANCUS with SNI prediction exhibits significantly improved stability and accelerated convergence, maintaining smoother optimization trajectories compared to its baseline counterpart. NeutronTP similarly benefits from SNI integration, achieving faster convergence with only minimal accuracy reduction (≤ 0.01) on the Reddit dataset. Importantly, SNI-enhanced training consistently reaches target accuracy levels more rapidly than standard approaches, demonstrating that the prediction mechanism effectively preserves model quality while accelerating the training process through reduced synchronization overhead. C. Scalability Study We evaluate SNI-GNN’s scaling behavior by training a 3layer GCN across cluster sizes from 4 to 16 GPUs, with detailed time breakdowns shown in Figure 13. We decompose the time

into three parts, including communication, computation and synchronization. Our analysis reveals three critical patterns that emerge as system scale increases. (1) Communication Dominance at Scale: Across all datasets, communication becomes the primary bottleneck at 16 GPUs, consuming 81% of total time for IGB-medium and 65% for ogbn-products. This escalating overhead underscores the fundamental importance of communication optimization in distributed GNN training. (2) Consistent Communication Reduction: SNI-GNN delivers substantial communication savings across all scales and datasets. On Reddit, SCS-SNI reduces communication time by 24% at 16 GPUs, yielding a 1.21× end-to-end speedup. The benefits are even more pronounced on ogbn-products, where NTP-SNI halves communication costs (107.9s → 58.9s) and achieves a 1.29× overall speedup. Notably, even on IGB-small where absolute gains appear modest, SCS-SNI maintains 24% communication reduction, showing consistent effectiveness. (3) Architectural Generality: SNI-GNN complements both major parallelization paradigms. NTP-SNI achieves maximum gains on ogbn-products (tensor-parallel optimized), while SCSSNI excels on IGB-medium (partition-parallel optimized), proving the framework’s adaptability to diverse system architectures. The boundary-importance sampling remains effective regardless of graph scale, with larger datasets benefiting more significantly due to their inherently higher communication overhead. We further evaluate SNI-GNN under deeper GNN backbones (4-layer and 6-layer) to test robustness against stronger staleness amplification in multi-hop message passing. As shown in Figure 14, while SANCUS exhibits significant accuracy fluctuations and a noticeable decline in convergence stability as depth increases to 6 layers, SNI-GNN maintains a much smoother and higher optimization trajectory. This robustness is achieved because our in-network predictor actively compensates for the staleness of boundary embeddings on the DPU before they are utilized in the GPU’s aggregation kernels. By providing a fresher approximation of remote embeddings at each step, SNI-GNN effectively truncates the error propagation chain. The scalability results demonstrate that SNI-GNN’s prediction mechanism effectively addresses the fundamental scaling challenge in distributed GNN training: communication costs grow disproportionately with system size, and our in-network approach provides a scalable solution that maintains efficiency across diverse configurations. D. Accuracy and Convergence Analysis Since the staleness of embeddings can greatly affect the convergence of model training and the final accuracy, we conducted a detailed study on the model accuracy, sampling rate, and communication interval. Since we used the simplest GCN model architecture and did not add randomness such as dropout, our model training accuracy did not fluctuate. Therefore, we can confirm that the improvement in accuracy comes from improved prediction. 1) Impact of Prediction Sampling Rate: We evaluate the sensitivity of our system to the Sampling Rate (SR) using

R e d d it

IG B - s m a ll

1 4 0

o g b n -p ro d u c ts

IG B - m e d iu m

1 4 0

1 2 0

1 2 0

1 0 0

1 0 0

8 0

8 0

2 0 0 1 6 0 1 6 0

6 0

T im e ( s )

6 0

T im e ( s )

T im e ( s )

T im e ( s )

1 2 0 1 2 0

8 0

8 0 4 0

4 0 4 0

2 0

2 0

0

0 S C S

S C S N T P S C S N T P S C S N T P N T P S C S N T P S C S N T P -S N I -S N I -S N I -S N I -S N I -S N I

4 G P U

8 G P U

4 0

0 S C S

1 6 G P U

S C S N T P S C S N T P S C S N T P N T P S C S N T P S C S N T P -S N I -S N I -S N I -S N I -S N I -S N I

4 G P U

8 G P U

0 S C S N T P S C S N T P S C S N T P N T P S C S N T P S C S N T P -S N I -S N I -S N I -S N I -S N I -S N I

S C S

1 6 G P U

S y n c h r o n iz a tio n

4 G P U

8 G P U

C o m p u ta tio n

S C S

1 6 G P U

S C S N T P S C S N T P S C S N T P N T P S C S N T P S C S N T P -S N I -S N I -S N I -S N I -S N I -S N I

4 G P U

8 G P U

1 6 G P U

C o m m u n ic a tio n

Fig. 13: Breakdown of time overhead (synchronization, computation, communication) for SCS, SCS-SNI, NTP, and NTP-SNI Under 4/8/16 GPUs across four datasets (Reddit, IGB-small, ogbn-products, IGB-medium). S C S - E 3 - la y e r 4

S N I- E 3 - la y e r 4

R e d d it

S N I- E 3 - la y e r 6

S C S - E 3 - la y e r 6

S C S -E 5 S C S -S N I--E 5 -0 .1

o g b n -p ro d u c ts

0 .7 0

R e d d it 4

0 .8 0 .6 5 0 .6 0

0 .2

0 .5 5

0 .0

0 .5 0

0

5 0

1 0 0

1 5 0 2 0 0 E p o c h

2 5 0

3 0 0

IG B - s m a ll 3 2

L o s s

0 .4

S C S -S N I--E 5 -0 .0 5

3 L o s s

A C C

A C C

0 .6

S C S -S N I-E 5 -0 .0 1 S C S -S N I--E 5 -0 .3

2 1

1 0

0

5 0

1 0 0

1 5 0 2 0 0 E p o c h

2 5 0

0

3 0 0

1 0 0

1 5 0 E p o c h

2 0 0

2 5 0

3 0 0

3

Reddit

IGB-small

ogbn-products

IGB-medium

0 0.01 0.05 0.1 0.3

91.19% 91.35% (+0.16) 91.77% (+0.58) 91.88% (+0.69) 92.06% (+0.87)

69.84% 69.88% (+0.04) 69.94% (+0.10) 70.12% (+0.28) 70.36% (+0.52)

69.54% 69.91% (+0.37) 70.19% (+0.65) 70.23% (+0.69) 70.54% (+1.00)

60.81% 60.76% (-0.05) 61.45% (+0.64) 61.65% (+0.84) 62.21% (+1.40)

SANCUS with a communication interval of 5 as a baseline. We vary the SR from 0.01, 0.05, 0.1 to 0.3 to study its impact on SNI-GNN. As shown in Table III, peak accuracy is positively correlated with the sampling rate across all datasets. For example, on ogbn-products, increasing the SR from 0 to 0.3 yields a 1.00% accuracy gain. While higher sampling rates improve accuracy by providing more comprehensive neighborhood updates, they also increase the DPU’s memory footprint for historical records and computational load. In practice, the optimal SR is determined by the system’s "idle window". That is, the sampling rate should be maximized as long as the DPU’s prediction latency remains hidden behind the GPU’s computation, as illustrated in our pipeline design (Figure 10). 2) Convergence Stability: Beyond peak accuracy, we examine training convergence via the loss curves in Figure 15. First, all variants with the sampling predictor, namely SCS-E5-0.01, SCS-E5-0.05, SCS-E5-0.1, and SCS-E5-0.3, exhibit loss curves that either match or outperform the baseline SCS-E5 in terms of convergence speed and stability. For instance, on the IGB-small dataset, the variants achieve a stable low loss earlier than the baseline. On ogbn-products, they show a smoother and more consistent decline in loss. Even on the Reddit and IGB-medium datasets, where the baseline already has a decent convergence trend, the variants maintain comparable performance while

5 0

1 0 0

1 5 0 E p o c h

2 0 0

2 5 0

3 0 0

2 5 0

3 0 0

IG B - m e d iu m 3 .5

2 L o s s

L o s s

3 .0 1

2 .5 2 .0 1 .5

0

SR

0

o g b n -p ro d u c ts

Fig. 14: Deeper-model study (4/6 layers): convergence under multi-node training. TABLE III: Accuracy results across datasets and Sampling Rates (SR).

5 0

0

5 0

1 0 0

1 5 0 E p o c h

2 0 0

2 5 0

3 0 0 0

5 0

1 0 0

1 5 0

2 0 0

E p o c h

Fig. 15: Training loss curves of SANCUS with SNI prediction and its variants with different sampling rates across datasets. offering more flexibility in parameter adjustment. 3) Communication Interval Study: To verify the communication-avoiding capability of SNI-GNN, we compare it against various synchronization intervals (E ∈ {1, 3, 5}). We analyzed two key metrics, including total training time and final accuracy. The results are shown in Table IV. Note that for each dataset, we configured SNI-GNN with the maximum SR that fits within the system’s idle window (0.3 for Reddit, 0.1 for IGB-Small, and 0.05 for ogbn-products), ensuring that the in-network prediction does not introduce additional latency to the critical path. Across all datasets, increasing the interval from 1 to 5 reduces training time by approximately 43–51% due to lower synchronization frequency. When operating at E = 5, SNIGNN provides a superior Pareto frontier: it retains the 40%+ time savings of a large interval while recovering significant accuracy loss. On Reddit, SNI-GNN recovers nearly 0.9% accuracy compared to the stale baseline, keeping the final accuracy loss within 1 percentage point of the ideal synchronous training (E = 1). 4) Robustness under Non-smooth Dynamics: Our predictor’s theoretical effectiveness rests on the assumption of bounded second-order embedding dynamics. To evaluate the system’s resilience when this assumption is challenged, we conducted a stress test by intentionally introducing non-smooth embedding evolution through two scenarios: (i) early-epoch regimes prior to the completion of the 20-epoch warm-up, and (ii) unstable

TABLE IV: Impact of Communication Interval on Training Time and Accuracy. SR denotes the prediction Sampling Rate. 2

1 0

53.81 57.23

44.31 46.59

71.13 71.21

80.87 81.64

91.19 92.06

70.33 70.47

58.02 60.41

69.84 70.12

69.65 70.08

117.89 123.64

69.47 70.19

R e d d it le a r n in g r a te s tu d y

1 .0 0 .8

A C C

A C C

0 .6 0 .8

S N I- E 3 - lr 0 .1 S N I- E 3 - lr 0 .0 1 S C S - E 3 - lr 0 .1 S C S - E 3 - lr 0 .0 1

0 .2 0 .0

0 .6 1 0 0

1 5 0 E p o c h

1 5 0 E p o c h

2 0 0

2 5 0

2 0 0

2 5 0

3 0 0

3 0 0

0

5 0

1 0 0

1 5 0 E p o c h

2 0 0

2 5 0

3 0 0

0

5 0

G ra p h S A G E

2

1 0 0

1 5 0 E p o c h

o g b n -p ro d u c ts 3

S C S -S N I-E 6 S C S -E 4 S C S -E 6

2 0 0

2 5 0

3 0 0

G ra p h S A G E S C S -S N I-E 4 S C S -E 2 S C S -E 4

2

1 1 0 5 0

1 0 0

1 5 0 E p o c h

2 0 0

2 5 0

3 0 0 0

5 0

1 0 0

1 5 0 E p o c h

2 0 0

2 5 0

3 0 0

Fig. 17: Training loss curves of SANCUS with SNI prediction on GAT/GraphSAGE models under 8 GPUs. E1/2/3/4/6 denotes the communication intervals of 1/2/3/4/6. TABLE V: Cumulative impact of our three primary optimizations on end-to-end time (s). Method

0 .4 S N I-E 3 -w a m u p 1 0 S N I-E 3 -w a rm u p 3 0 S C S -E 3 -w a m u p 1 0 S C S -E 3 -w a rm u p 3 0

5 0

R e d d it

0

149.75 154.31

0 .9

0

1 0 0

0

R e d d it w a r m u p s tu d y

0 .7

5 0

3

ogbn-products (SR=0.05) SANCUS 231.39 71.03 SNI-GNN 234.58 70.88 1 .0

92.28 92.74

L o s s

IGB-Small (SR=0.1) SANCUS 119.12 SNI-GNN 123.59

93.01 93.36

2

1

Time (s) Acc (%) Time (s) Acc (%) Time (s) Acc (%) Reddit (SR=0.3) SANCUS 77.61 SNI-GNN 79.36

G A T S C S -S N I-E 3 S C S -E 3 S C S -E 1

L o s s

Interval=5

o g b n -p ro d u c ts 3

L o s s

Method

Interval=3

G A T S C S -S N I-E 3 S C S -E 3 S C S -E 1

L o s s

Interval=1

R e d d it 3

+ sampling + self-feeding + async pipeline

IGB-small

Reddit

ogbn-prod.

IGB-med.

117.58 86.43 58.02

106.52 83.17 44.31

275.20 210.30 117.89

180.21 161.12 107.72

Fig. 16: Robustness under non-smooth dynamics.

on three core components: (i) importance-based boundaryoptimization settings using significantly larger learning rates. node sampling, (ii) the self-feeding mechanism (intermediateAs shown in Figure 16, although these volatile conditions result reuse), and (iii) the asynchronous DPU-GPU pipeline. naturally lead to higher initial prediction errors compared to As summarized in Table V, our results demonstrate how these our default settings, SNI-GNN maintains convergence without optimizations cumulatively overcome DPU resource constraints catastrophic accuracy loss. The combination of active DPU to improve end-to-end training efficiency. 1) Impact of Importance Sampling: Importance sampling prediction with periodic global synchronization acts as a serves as the fundamental enabler for DPU-offloading. Without fail-safe that prevents unbounded error growth even during sampling, the DPU must predict embeddings for the entire temporary violations of embedding smoothness. These results boundary set, which is computationally prohibitive for the confirm that SNI-GNN is robust enough to handle the nonSmartNIC’s onboard ARM cores. On datasets like ogbnlinear dynamics common in the early stages of GNN training. products, full-graph prediction results in execution times 2–10× longer than the sampled baseline. Consequently, we fix the E. Sensitivity and Robustness Study sampling rate for each dataset (marked in Table V) and evaluate For SNI prediction, any message-passing-based model can the remaining optimizations relative to this feasible baseline. theoretically be used. As long as we can identify fixed message 2) Self-Feeding and Asynchronous Pipeline: The selfcommunications, we can replace the communication content feeding mechanism (intermediate-result reuse) provides a with a historical cache and use a predictor to make short-term consistent performance boost of 10–20% across all datasets. By predictions on the cache, thereby reducing the communication leveraging previously computed trends, it minimizes redundant frequency during model training. To verify the generalizability arithmetic operations on the DPU. The most significant of our method, we also conducted a simple test on the GAT [55], speedup, however, is realized by the asynchronous pipeline. and GraphSAGE [41] models, as shown in Figure 17. By overlapping the DPU’s prediction and PCIe transfer tasks The figure shows that SNI-GNN performs robustly across (P n,i and Tn,i in Figure 10) with the GPU’s computation both architectures. For the GAT model, which introduces (C ), we successfully hide the prediction latency. For instance, n,i dynamic, learnable attention coefficients, our predictor achieves on the Reddit dataset, the asynchronous pipeline reduces the nearly identical convergence speed and final loss at a com- epoch time from 83.17s to 44.31s, nearly doubling the training munication interval of 3 (E = 3) compared to the ideal throughput. This empirical evidence validates that the synergy synchronous baseline (E = 1). Similarly, for GraphSAGE, between algorithm simplification and pipeline overlapping is the SNI-enabled training closely tracks the training dynamics essential for effective SmartNIC-assisted GNN training. of the non-stale baseline even as effective communication G. Microbenchmark: CPU vs. DPU Offloading intervals are increased. F. Ablation Study To quantify the isolated impact of each optimization within SNI-GNN, we conduct an incremental ablation study focusing

To justify the architectural complexity of SmartNIC offloading, we compare predictor execution on the host CPU and the DPU from both topology and latency perspectives. Although the CPU provides stronger raw compute capability

0 .0 E + 0 -2 .0 E -6

V a lu e

A C C

E r r o r A c u m u la tio n

Im p a c t o n A c c u ra c y

1 .0 0 .8 0 .6 0 .4 0 .2 0 .0 0

P r e d ic tio n w ith o u t s e lf- fe e d in g 5 0

1 0 0

E p o c h

1 5 0

-4 .0 E -6

P r e d ic tio n R e a l V a lu e

-6 .0 E -6

2 0 0 0

5 0

1 0 0

1 5 0

2 0 0

E p o c h

Fig. 18: Prediction error over epochs with/without self-feeding on Reddit Dataset. TABLE VI: PCIe bandwidth contention: CPU vs. DPU communication patterns (theoretical, Dell XE9680 PCIe Gen5 with 2:1 switch-uplink oversubscription).

TABLE VII: Offloading overhead breakdown across datasets (per-offload latency, µs). CPU/DPU-Sync denotes predictor-side computation during synchronization (communication) rounds; CPU/DPU-Stale denotes predictor-side computation during stale (prediction) rounds. Dataset

CPU-Sync DPU-Sync CPU-Stale DPU-Stale

Reddit IGB-small ogbn-products

13,692.9 19,940.5 24,760.1

15,961.9 23,126.7 28,568.0

1,113.1 2,365.6 2,813.2

680.6 1281.3 1683.4

adaptive quantization (SYLVIE [26], AdaQP [25]). Other approaches reduce overhead by sampling boundary neighbors (BNS-GCN [30]) or lowering frequency by caching historical CPU → GPU (1:1) 4 63.0 DPU → GPU (1:1) 4 63.0 embeddings and skipping broadcasts (SANCUS [24]). CPU → GPU (1:2) 8 32.0 Historical Embeddings and Staleness. Leveraging historDPU → GPU (1:1) 8 63.0 ical embeddings is a prevalent strategy to alleviate commuand more flexible programmability, CPU-based offloading nication bottlenecks (PipeGCN [23], GNNAutoScale [34]). is more vulnerable to host-side PCIe contention in modern To balance staleness and accuracy, recent works use feature multi-GPU servers. In contrast, DPU offloading places the momentum (GraphFM [42]), selective caching via gradipredictor directly on the communication path and avoids routing ent/staleness criteria (FreshGNN [43]), or temporal dynamic intermediate embeddings through the host, making it a more modeling (SAT [56]). Unlike these software-only approaches that utilize host resources, SNI-GNN introduces active innatural fit for distributed full-graph GNN training. network mitigation to resolve staleness without host contention. We first analyze the communication topology using a Dell SmartNIC/DPU Offloading. DPUs provide programmable PowerEdge XE9680-style PCIe Gen5 hierarchy with 2:1 switchin-network compute to relieve host contention on critical uplink oversubscription, where each switch serves two GPUs data paths. In ML, DPUs have been used for control-plane and two BlueField-3 DPUs through a shared ×16 uplink scheduling (Conspirator [57]), offloading optimizer states (Opto the CPU root complex. Under this topology, CPU-based timusNIC [58]), and accelerating object storage (OS2G [29]). offloading forces GPU-bound traffic to compete on shared host Jain et al. [59] explored DPU-based DNN acceleration through uplinks, whereas DPU-based offloading keeps communication data augmentation and model validation offloading. However, largely pair-local between each GPU and its attached SmartNIC. utilizing SmartNICs for active staleness compensation in GNN As summarized in Table VI, when 8 GPUs communicate training remains largely unexplored. concurrently, the effective per-GPU bandwidth of the CPU path drops to 32.0 GB/s, while the DPU path remains near VII. C ONCLUSION line rate at 63.0 GB/s. This gap suggests CPU offloading’s We introduce SNI-GNN, a SmartNIC-assisted full-graph growing disadvantage with communication concurrency. GNN training system designed to tackle the dominant interWe further dissect the performance of offloading the predic- node communication bottleneck by moving lightweight emtion algorithm to the CPU versus the DPU. Table VII breaks bedding refinement into the data path. The core design places down the processing time into four components: calculation a linear-trend predictor on SmartNICs to extrapolate cached during communication rounds and calculation during stale historical embeddings, applies boundary-node importance (prediction) rounds, for both CPU and DPU targets. sampling to focus limited in-network compute on the most The breakdown includes: (1) CPU-Sync: Computation time influential neighbors, and builds an asynchronous DPU–GPU during communication rounds when offloaded to CPU; (2) pipeline and intermediate-result reuse to avoid new synchronizaCPU-Stale: Computation time during stale rounds on CPU; (3) tion barriers. This mechanism complements existing full-graph DPU-Sync: Computation time during communication rounds training paradigms where redundant exchanges and irregular on DPU; (4) DPU-Stale: Computation time during stale rounds dependencies make communication the principal scalability on DPU. While the CPU offers stronger raw computing power, constraint, and integrates cleanly with partition- and tensorDPU offloading eliminates significant data movement overhead parallel frameworks for multi-GPU training. The feasibility of and host interference, providing a more predictable and scalable SmartNIC-side acceleration for GNN workloads motivates our execution environment for distributed training. in-network approach and its predictor design. Pattern

#GPU BW/GPU (GB/s)

VI. R ELATED W ORK

ACKNOWLEDGEMENTS

Full Graph Training. Full-graph training avoids sampling bias but suffers from massive cross-partition communication. Existing countermeasures include overlapping computation and communication (e.g., FlexGraph [20]), minimizing volume via tensor parallelism (NeutronTP [36]), and adopting

This work is supported by Guangdong and Hong Kong Universities "1+1+1" Joint Research Collaboration Scheme (No. 2025A0505000012). Amelie Chi Zhou is the corresponding author.

AI-G ENERATED C ONTENT ACKNOWLEDGEMENT We employed GPT-5 to refine the language of the entire manuscript. All generative outputs were manually reviewed and edited for technical accuracy. R EFERENCES [1] H. Li and L. Chen, “Early: Efficient and reliable graph neural network for dynamic graphs,” Proceedings of the ACM on Management of Data, vol. 1, no. 2, pp. 1–28, 2023. [2] M. Liu, H. Gao, and S. Ji, “Towards deeper graph neural networks,” in Proceedings of the 26th ACM SIGKDD international conference on knowledge discovery & data mining, pp. 338–348, 2020. [3] M. Zhang and Y. Chen, “Link prediction based on graph neural networks,” Advances in neural information processing systems, vol. 31, 2018. [4] L. Cai and S. Ji, “A multi-scale approach for graph link prediction,” in Proceedings of the AAAI conference on artificial intelligence, vol. 34, pp. 3308–3315, 2020. [5] K. Xu, W. Hu, J. Leskovec, and S. Jegelka, “How powerful are graph neural networks?,” arXiv preprint arXiv:1810.00826, 2018. [6] H. Gao, Y. Liu, and S. Ji, “Topology-aware graph pooling networks,” IEEE Transactions on Pattern Analysis and Machine Intelligence, vol. 43, no. 12, pp. 4512–4518, 2021. [7] Y. Liu, K. Zeng, H. Wang, X. Song, and B. Zhou, “Content matters: A gnn-based model combined with text semantics for social network cascade prediction,” in Pacific-Asia Conference on Knowledge Discovery and Data Mining, pp. 728–740, Springer, 2021. [8] J. Qiu, J. Tang, H. Ma, Y. Dong, K. Wang, and J. Tang, “Deepinf: Social influence prediction with deep learning,” in Proceedings of the 24th ACM SIGKDD international conference on knowledge discovery & data mining, pp. 2110–2119, 2018. [9] X. Li, L. Sun, M. Ling, and Y. Peng, “A survey of graph neural network based recommendation in social networks,” Neurocomputing, vol. 549, p. 126441, 2023. [10] X. Wang, X. He, M. Wang, F. Feng, and T.-S. Chua, “Neural graph collaborative filtering,” in Proceedings of the 42nd international ACM SIGIR conference on Research and development in Information Retrieval, pp. 165–174, 2019. [11] Y. Dou, Z. Liu, L. Sun, Y. Deng, H. Peng, and P. S. Yu, “Enhancing graph neural network-based fraud detectors against camouflaged fraudsters,” in Proceedings of the 29th ACM international conference on information & knowledge management, pp. 315–324, 2020. [12] H. Cai, H. Zhang, D. Zhao, J. Wu, and L. Wang, “Fp-gnn: a versatile deep learning architecture for enhanced molecular property prediction,” Briefings in bioinformatics, vol. 23, no. 6, p. bbac408, 2022. [13] H. Lin, M. Yan, X. Ye, D. Fan, S. Pan, W. Chen, and Y. Xie, “A comprehensive survey on distributed training of graph neural networks,” Proceedings of the IEEE, vol. 111, no. 12, pp. 1572–1606, 2023. [14] S. Bajaj, H. Guan, and M. Serafini, “Graph neural network training systems: A performance comparison of full-graph and mini-batch,” arXiv preprint arXiv:2406.00552, 2024. [15] Z. Du, C. Zhou, J. Yao, T. Tu, L. Cheng, H. Yang, J. Zhou, and J. Tang, “Cogkr: Cognitive graph for multi-hop knowledge reasoning,” IEEE Transactions on Knowledge and Data Engineering, vol. 35, no. 2, pp. 1283–1295, 2021. [16] G. Panapitiya, P. Gao, C. M. Maupin, and E. G. Saldanha, “Fragnet: A graph neural network for molecular property prediction with four layers of interpretability,” arXiv preprint arXiv:2410.12156, 2024. [17] D. Zheng, C. Ma, M. Wang, J. Zhou, Q. Su, X. Song, Q. Gan, Z. Zhang, and G. Karypis, “Distdgl: Distributed graph neural network training for billion-scale graphs,” in 2020 IEEE/ACM 10th Workshop on Irregular Applications: Architectures and Algorithms (IA3), pp. 36–44, IEEE, 2020. [18] Y. Park, S. Min, and J. W. Lee, “Ginex: Ssd-enabled billion-scale graph neural network training on a single machine via provably optimal inmemory caching,” Proceedings of the VLDB Endowment, vol. 15, no. 11, pp. 2626–2639, 2022. [19] H. Mostafa, “Sequential aggregation and rematerialization: Distributed full-batch training of graph neural networks on large graphs,” Proceedings of Machine Learning and Systems, vol. 4, pp. 265–275, 2022. [20] L. Wang, Q. Yin, C. Tian, J. Yang, R. Chen, W. Yu, Z. Yao, and J. Zhou, “Flexgraph: a flexible and efficient distributed framework for gnn training,” in Proceedings of the Sixteenth European Conference on Computer Systems, pp. 67–82, 2021.

[21] X. Wan, K. Xu, X. Liao, Y. Jin, K. Chen, and X. Jin, “Scalable and efficient full-graph gnn training for large graphs,” Proceedings of the ACM on Management of Data, vol. 1, no. 2, pp. 1–23, 2023. [22] D. Zheng, X. Song, C. Yang, D. LaSalle, and G. Karypis, “Distributed hybrid cpu and gpu training for graph neural networks on billionscale heterogeneous graphs,” in Proceedings of the 28th ACM SIGKDD Conference on Knowledge Discovery and Data Mining, pp. 4582–4591, 2022. [23] C. Wan, Y. Li, C. R. Wolfe, A. Kyrillidis, N. S. Kim, and Y. Lin, “Pipegcn: Efficient full-graph training of graph convolutional networks with pipelined feature communication,” arXiv preprint arXiv:2203.10428, 2022. [24] J. Peng, Z. Chen, Y. Shao, Y. Shen, L. Chen, and J. Cao, “Sancus: staleness-aware communication-avoiding full-graph decentralized training in large-scale graph neural networks,” Proceedings of the VLDB Endowment, vol. 15, no. 9, pp. 1937–1950, 2022. [25] B. Wan, J. Zhao, and C. Wu, “Adaptive message quantization and parallelization for distributed full-graph gnn training,” Proceedings of Machine Learning and Systems, vol. 5, 2023. [26] M. Zhang, Q. Hu, C. Wan, H. Wang, P. Sun, Y. Wen, and T. Zhang, “Sylvie: 3d-adaptive and universal system for large-scale graph neural network training,” in 2024 IEEE 40th International Conference on Data Engineering (ICDE), pp. 3823–3836, IEEE, 2024. [27] J. Song, H. Jang, H. Lim, J. Jung, Y. Kim, and J. Lee, “Granndis: Fast distributed graph neural network training framework for multi-server clusters,” in Proceedings of the 2024 International Conference on Parallel Architectures and Compilation Techniques, pp. 91–107, 2024. [28] A. Guo, Software and hardware codesign of SmartNIC-based heterogeneous HPC clusters with machine learning case studies. PhD thesis, Boston University, 2024. [29] Z. Jin, Y. Chen, M. Liang, Y. Wang, G. Fang, A. Zhou, K. Zhang, J. Xu, W. Lin, Y. Lin, et al., “Os2g: A high-performance dpu offloading architecture for gpu-based deep learning with object storage,” in Proceedings of the 30th ACM International Conference on Architectural Support for Programming Languages and Operating Systems, Volume 2, pp. 750–765, 2025. [30] C. Wan, Y. Li, A. Li, N. Kim, and Y. Lin, “Bns-gcn: Efficient full-graph training of graph convolutional networks with partition-parallelism and random boundary node sampling,” ArXiv, vol. abs/2203.10983, 2022. [31] J. Gilmer, S. S. Schoenholz, P. F. Riley, O. Vinyals, and G. E. Dahl, “Neural message passing for quantum chemistry,” in International conference on machine learning, pp. 1263–1272, PMLR, 2017. [32] Z. Cai, X. Yan, Y. Wu, K. Ma, J. Cheng, and F. Yu, “Dgcl: An efficient communication library for distributed gnn training,” in Proceedings of the Sixteenth European Conference on Computer Systems, pp. 130–144, 2021. [33] S. Gandhi and A. P. Iyer, “P3: Distributed deep graph learning at scale,” in 15th {USENIX} Symposium on Operating Systems Design and Implementation ({OSDI} 21), pp. 551–568, 2021. [34] M. Fey, J. E. Lenssen, F. Weichert, and J. Leskovec, “Gnnautoscale: Scalable and expressive graph neural networks via historical embeddings,” in International conference on machine learning, pp. 3294–3304, PMLR, 2021. [35] J. Yang, D. Tang, X. Song, L. Wang, Q. Yin, R. Chen, W. Yu, and J. Zhou, “Gnnlab: a factored system for sample-based gnn training over gpus,” in Proceedings of the Seventeenth European Conference on Computer Systems, pp. 417–434, 2022. [36] X. Ai, H. Yuan, Z. Ling, Q. Wang, Y. Zhang, Z. Fu, C. Chen, Y. Gu, and G. Yu, “Neutrontp: Load-balanced distributed full-graph gnn training with tensor parallelism,” Proc. VLDB Endow., vol. 18, p. 173–186, Oct. 2024. [37] G. Karypis and V. Kumar, “A fast and high quality multilevel scheme for partitioning irregular graphs,” SIAM Journal on scientific Computing, vol. 20, no. 1, pp. 359–392, 1998. [38] I. Stanton and G. Kliot, “Streaming graph partitioning for large distributed graphs,” in Proceedings of the 18th ACM SIGKDD international conference on Knowledge discovery and data mining, pp. 1222–1230, 2012. [39] S. Schlag, C. Schulz, D. Seemaier, and D. Strash, “Scalable Edge Partitioning,” in Proceedings of the 21th Workshop on Algorithm Engineering and Experimentation (ALENEX), pp. 211–225, SIAM, 2019. [40] W. Hu, M. Fey, M. Zitnik, Y. Dong, H. Ren, B. Liu, M. Catasta, and J. Leskovec, “Open Graph Benchmark: Datasets for Machine Learning on Graphs,” arXiv e-prints, p. arXiv:2005.00687, May 2020.

[41] W. Hamilton, Z. Ying, and J. Leskovec, “Inductive representation learning on large graphs,” Advances in neural information processing systems, vol. 30, 2017. [42] H. Yu, L. Wang, B. Wang, M. Liu, T. Yang, and S. Ji, “Graphfm: Improving large-scale gnn training via feature momentum,” in International conference on machine learning, pp. 25684–25701, PMLR, 2022. [43] K. Huang, H. Jiang, M. Wang, G. Xiao, D. Wipf, X. Song, Q. Gan, Z. Huang, J. Zhai, and Z. Zhang, “Freshgnn: reducing memory access via stable historical embeddings for graph neural network training,” arXiv preprint arXiv:2301.07482, 2023. [44] M. Wong, U. Butler, E. Farkash, P. Tammana, A. Sivaraman, and R. Netravali, “Gpus, cpus, and... nics: Rethinking the network’s role in serving complex ai pipelines,” arXiv preprint arXiv:2502.15712, 2025. [45] N. Sarkauskas, M. Bayatpour, T. Tran, B. Ramesh, H. Subramoni, and D. K. Panda, “Large-message nonblocking mpi_iallgather and mpi ibcast offload via bluefield-2 dpu,” in 2021 IEEE 28th International Conference on High Performance Computing, Data, and Analytics (HiPC), pp. 388– 393, 2021. [46] M. Khalilov, S. Di Girolamo, M. Chrapek, R. Nudelman, G. Bloch, and T. Hoefler, “Network-offloaded bandwidth-optimal broadcast and allgather for distributed ai,” in SC24: International Conference for High Performance Computing, Networking, Storage and Analysis, pp. 1–17, IEEE, 2024. [47] A. Rebai, M. A. Ojewale, A. Ullah, M. Canini, and S. A. Fahmy, “Squeezenic: Low-latency in-nic compression for distributed deep learning,” in Proceedings of the 2024 SIGCOMM Workshop on Networks for AI Computing, pp. 61–68, 2024. [48] T. Gu, J. Fei, and M. Canini, “Omniccl: Zero-cost sparse allreduce with direct cache access and smartnics,” in Proceedings of the 2024 SIGCOMM Workshop on Networks for AI Computing, pp. 75–83, 2024. [49] M. Sun, Z. Yang, C. Liao, Y. Li, F. Wu, and Z. Wang, “Luwu: An end-to-end in-network out-of-core optimizer for 100b-scale modelin-network data-parallel training on distributed gpus,” arXiv preprint arXiv:2409.00918, 2024. [50] G. Box and G. Jenkins, “Analysis: Forecasting and control,” San francisco, 1976. [51] C. C. Holt, “Forecasting seasonals and trends by exponentially weighted moving averages,” International journal of forecasting, vol. 20, no. 1, pp. 5–10, 2004. [52] S. Hochreiter and J. Schmidhuber, “Long short-term memory,” Neural computation, vol. 9, no. 8, pp. 1735–1780, 1997. [53] A. Khatua, V. S. Mailthody, B. Taleka, T. Ma, X. Song, and W. mei W. Hwu, “Igb: Addressing the gaps in labeling, features, heterogeneity, and size of public graph datasets for deep learning research,” Proceedings of the 29th ACM SIGKDD Conference on Knowledge Discovery and Data Mining, 2023. [54] T. N. Kipf and M. Welling, “Semi-supervised classification with graph convolutional networks,” arXiv preprint arXiv:1609.02907, 2016. [55] P. Veličković, G. Cucurull, A. Casanova, A. Romero, P. Lio, and Y. Bengio, “Graph attention networks,” arXiv preprint arXiv:1710.10903, 2017. [56] G. Bai, Z. Yu, Z. Chai, Y. Cheng, and L. Zhao, “Staleness-alleviated distributed gnn training via online dynamic-embedding prediction,” in Proceedings of the 2025 SIAM International Conference on Data Mining (SDM), pp. 578–587, SIAM, 2025. [57] Y. Xiao, D. Z. Tootaghaj, A. Dhakal, L. Cao, P. Sharma, and A. Kuzmanovic, “Conspirator:{SmartNIC-Aided} control plane for distributed {ML} workloads,” in 2024 USENIX Annual Technical Conference (USENIX ATC 24), pp. 767–784, 2024. [58] A. Rebai and M. Canini, “Optimusnic: Offloading optimizer state to smartnics for efficient large-scale ai training,” in Proceedings of the 5th Workshop on Machine Learning and Systems, pp. 176–182, 2025. [59] A. Jain, N. Alnaasan, A. Shafi, H. Subramoni, and D. K. Panda, “Accelerating cpu-based distributed dnn training on modern hpc clusters using bluefield-2 dpus,” in 2021 IEEE Symposium on High-Performance Interconnects (HOTI), pp. 17–24, IEEE, 2021.

Related documents

• Advancing graph neural networks : addressing representation challenges in the vision domain#413324
• DeepLMI: deep feature mining with a globally enhanced graph convolutional network for robust lncRNA-miRNA interaction prediction.#30516
• Semi-Supervised Classification with Graph Convolutional Networks#7014
• Plain Transformers are Surprisingly Powerful Link Predictors#1118471
• Training Deep Neural Networks with Limited Data: Techniques and Challenges#112815