parallel graph neural network
**Parallel Graph Neural Network (GNN) Training** is the **distributed computing challenge of scaling graph neural network training to large-scale graphs (billions of nodes and edges) — where the neighbor aggregation (message passing) pattern creates irregular, data-dependent communication that prevents the regular batching and partitioning strategies used for CNNs and Transformers, requiring graph sampling, partitioning, and custom communication patterns to achieve practical training throughput**.
**Why GNNs Are Hard to Parallelize**
In a GNN, each node's representation is computed by aggregating features from its neighbors (message passing). For L layers, each node's computation depends on its L-hop neighborhood — which can be the entire graph for high-degree nodes in power-law graphs. This creates:
- **Neighborhood Explosion**: A 3-layer GNN on a node with average degree 50 accesses 50³ = 125,000 nodes, many redundantly.
- **Irregular Access Patterns**: Each node has a different number of neighbors at different memory locations — no regular tensor structure for efficient GPU computation.
- **Cross-Partition Dependencies**: Any graph partition has edges crossing to other partitions. Message passing across partitions requires communication.
**Scaling Strategies**
- **Mini-Batch Sampling (GraphSAGE)**: For each training node, sample a fixed number of neighbors at each layer (e.g., 25 at layer 1, 10 at layer 2). The sampled subgraph forms a mini-batch that fits in GPU memory. Introduces sampling variance but enables SGD training on arbitrarily large graphs.
- **Cluster-GCN**: Partition the graph into clusters (METIS). Each mini-batch consists of one or more clusters — intra-cluster edges are included, inter-cluster edges are dropped during that mini-batch. Reduces neighborhood explosion by restricting message passing to within-cluster. Reintroduces dropped edges across epochs.
- **Full-Graph Distributed Training (DistDGL, PyG)**: Partition the graph across multiple GPUs/machines. Each GPU owns a subset of nodes and stores their features locally. During message passing, nodes at partition boundaries exchange features with neighboring partitions via remote memory access or message passing. Communication volume proportional to edge-cut × feature dimension.
- **Historical Embeddings (GNNAutoScale)**: Cache and reuse node embeddings from previous iterations instead of recomputing the full L-hop neighborhood. Stale embeddings introduce approximation but dramatically reduce computation and communication.
**GPU-Specific Optimizations**
- **Sparse Aggregation**: Message passing is a sparse matrix operation (adjacency matrix × feature matrix). DGL and PyG use cuSPARSE and custom kernels for GPU-accelerated sparse aggregation.
- **Feature Caching**: Frequently accessed node features (high-degree nodes) cached in GPU memory. Less-frequent features fetched from CPU or remote GPUs via UVA (Unified Virtual Addressing) or RDMA.
- **Heterogeneous Execution**: Graph sampling and feature loading on CPU (I/O-bound); GNN computation on GPU (compute-bound). CPU-GPU pipeline overlaps preparation of batch N+1 with GPU computation on batch N.
**Parallel GNN Training is the frontier of irregular parallel computing applied to deep learning** — requiring the combination of graph processing techniques (partitioning, sampling, caching) with distributed training infrastructure (all-reduce, parameter servers) to scale neural networks over the inherently irregular structure of real-world graphs.