GreenDyGNN: Runtime-Adaptive Energy-Efficient Communication for Distributed GNN Training

Abstract: Distributed GNN training is dominated by remote feature fetching, which can be very costly. Multi-hop neighborhood sampling crosses partition boundaries and triggers fine-grained RPCs whose fixed initiation cost and GPU-stall latency waste energy. Prior systems try to reduce this overhead with presampling and static caching, but cache policies cannot react to runtime network variation. We show that under time-varying congestion, static caching can increase energy by up to 45% because a fixed rebuild schedule is insufficient. We present GreenDyGNN, which formulates cache window management as a sequential decision problem. GreenDyGNN performs intra-epoch cache rebuilds and uses a Double-DQN agent, trained in a calibrated simulator with domain-randomized congestion, to adapt rebuild window size and per-owner cache allocation at each boundary. An asynchronous double-buffered pipeline makes adaptation effectively free. Under congestion, GreenDyGNN cuts total energy by up to 43% over Default DGL and 4-24% over the best static policy, while closely matching the optimum under clean conditions.

• The paper introduces a runtime-adaptive RL approach that optimizes cache window size for energy-efficient distributed GNN training.
• It leverages a simulated environment calibrated with real measurements to capture initiation costs and GPU stall energy.
• Experimental results demonstrate up to 43% energy reduction and faster convergence compared to static caching baselines.

GreenDyGNN: Runtime-Adaptive Energy-Efficient Communication for Distributed GNN Training

Motivation and Context

The paper "GreenDyGNN: Runtime-Adaptive Energy-Efficient Communication for Distributed GNN Training" (2604.23139) addresses a critical bottleneck in distributed GNN training: remote feature fetching across partition boundaries. Unlike traditional DNN training, where communication is dominated by gradient synchronization, distributed GNNs suffer high energy costs due to numerous fine-grained remote procedure calls (RPCs). These calls incur a substantial per-RPC initiation overhead and cause GPU stalls, with remote feature fetches dominating per-step time and energy consumption in practical cluster setups. These effects are amplified by network congestion and time-varying communication delays commonly observed in shared compute environments.

Figure 1: Per-RPC energy decomposed into initiation (red) and payload (blue) cost as a function of batch size; initiation dominates in typical GNN settings.

Prior approaches, such as presampling and static caching mechanisms (e.g., RapidGNN), reduce communication volume but cannot react to dynamic network states. Static cache rebuild schedules become suboptimal under congestion, inflating energy by up to 45% due to mismatched communication plans and failure to account for evolving bottlenecks. The paper identifies the cache window size as a dynamic control variable and formulates online cache adaptation as a Markov decision process—a paradigm not previously employed in distributed GNN systems.

System Architecture

GreenDyGNN introduces fine-grained, intra-epoch window-based cache rebuilding in distributed GNN training. The architecture consists of an asynchronous double-buffered pipeline with three concurrent stages:

• Stage 1: Background sampling of mini-batches from local partitions.
• Stage 2: Cache builder executing windowed rebuilds. It examines the next $W$ mini-batches, selects hot remote nodes weighted by an RL agent's per-owner cost weights, and fetches features into a pending buffer.
• Stage 3: Feature resolver serving cache hits and remote misses, feeding the RL controller with fetch-time statistics.

Adaptation occurs at each cache rebuild boundary, where a Double-DQN RL agent decides the joint cache window size ($W$) and owner-specific cache allocation.

Figure 2: GreenDyGNN runtime training pipeline (single-worker view) highlighting decoupled stages for cache rebuilding and remote feature resolution.

Cost Modeling, Simulator Calibration, and RL Policy

GreenDyGNN leverages a calibrated simulator, constructed from measured communication latencies (including injected congestion), cache hit-rate curves, and per-node power readings. The simulator models per-step time analytically, capturing the tradeoff between amortized cache rebuild cost and miss-induced stall energy. Key phenomena include:

• Initiation-dominated regime: For batch sizes typical in GNNs, initiation cost outweighs payload cost.
• GPU stall energy: Every millisecond of RPC-induced stall translates to wasted GPU idle power.

Simulator calibration enables efficient RL agent training via sim-to-real transfer with domain randomization, exposing the agent to diverse congestion profiles and measurement noise.

Figure 3: RL agent architecture—state inputs include per-owner congestion, cache statistics, and previous actions; outputs are joint window size and cache allocation.

The RL policy maps runtime signals to optimal decision pairs (window size, owner allocation), absorbing delayed and coupled effects not amenable to threshold-based heuristics. The agent is trained on reward signals reflecting negative normalized energy penalized for allocation instability.

Congestion Adaptation and Experimental Results

Under realistic, time-varying congestion, GreenDyGNN consistently achieves the lowest energy consumption across all datasets and batch sizes, outperforming static policies (RapidGNN, BGL, Default DGL) by substantial margins.

Figure 4: Total energy (GPU + CPU, all nodes) under congestion; GreenDyGNN demonstrates robust energy savings compared to baselines.

The RL controller shortens window sizes and biases cache capacity toward slow owners in congested epochs, precisely tracking energy-optimal cache configurations driven by observed fetch latencies. Energy overhead from congestion is minimized relative to both static and non-adaptive baselines.

Figure 5: Energy overhead from congestion (percentage increase over clean baseline) at $B{=}2000$; GreenDyGNN absorbs more congestion-induced overhead.

Under clean conditions, GreenDyGNN converges to the static optimum established by RapidGNN, incurring no penalty from unnecessary adaptation.

Figure 6: Total energy (GPU + CPU, all nodes) under clean network conditions; adaptation matches optimal static caching.

The RL agent's adaptation dynamics are displayed on large-scale datasets such as OGBN-Papers100M: when congestion arises, the policy switches from $W{=}16$ to $W{\approx}8$ dynamically.

Figure 7: RL agent behavior—rebuild window adjustment and cache hit rate tracking during congestion.

Simulator validation confirms predicted step times match real measurements to within 5%, supporting reliable sim-to-real RL policy transfer.

Figure 8: Simulator validation—heatmap of prediction error and comparison of predicted vs. measured step time.

Cumulative energy profiles show GreenDyGNN's energy gap over baselines widens during prolonged congestion.

Figure 9: Cumulative energy trends—GreenDyGNN consistently accumulates less energy, especially during congested epochs.

Training accuracy versus wall time curves corroborate faster convergence for GreenDyGNN due to reduced remote stall durations.

Figure 10: Accuracy vs. wall time—accelerated convergence for GreenDyGNN under network congestion.

Ablation and Component Analysis

Ablation studies reveal the synergistic effect of adaptive window sizing (via RL) and per-owner cost weighting. Disabling RL adaptation increases energy 6.9–8.6%; removing cost weighting provides a smaller but consistent improvement (2.9–3.4%) across datasets.

Figure 11: Results of ablation experiments—energy increases when RL adaptation or cost-weighted allocation are omitted.

Implications and Future Directions

The work formalizes cache window management as an online control problem, arguing the necessity of runtime adaptation for energy efficiency in distributed GNN training. Practically, such adaptive strategies cut total training energy by up to 43% and absorb previously unaddressable congestion overhead. Theoretically, this establishes a new framework for integrating RL-based controllers in dynamic distributed ML systems, with sim-to-real transfer as a scalable solution for RL policy deployment.

Extensions to heterogeneous clusters (e.g., mixed GPU types, RDMA fabrics), multi-agent cache adaptation, and joint optimization of compute-side parameters (e.g., GPU frequency scaling) are promising future directions. Incorporating continuous online policy refinement from production telemetry could further improve adaptation performance.

Conclusion

GreenDyGNN demonstrates that runtime-adaptive cache window and allocation management through RL control substantially improves energy efficiency in distributed GNN training under real-world conditions, outperforming all known static baselines. The system design leverages sim-to-real RL training, precise cost modeling, and asynchronous pipeline engineering, providing a foundation for future advances in energy-aware, scalable graph ML systems.