Anonymized Network Sensing using C++26 std::execution on GPUs

TL;DR

The paper demonstrates a transportable, vendor-agnostic approach to large-scale network sensing analytics on dense-GPU systems by leveraging the C++26 std::execution Senders model to compose asynchronous tasks across multiple GPUs. It integrates standard containers and a concurrent batching strategy to partition data and push workloads to device contexts, avoiding vendor-specific kernel code. Empirical results show up to $55\times$ speedups over a serial GraphBLAS baseline on 8x NVIDIA A100 GPUs and roughly $2\times$ end-to-end improvements relative to a Graph Challenge champion, underscoring the practical viability of Senders-based workflows for large matrix workloads. The work highlights productivity benefits (low code for common operations) alongside challenges in complex algorithm mapping and data-distribution management, arguing that batching remains a critical tool for modern multi-GPU analytics. Overall, the study contributes an early, actionable demonstration of C++26 Senders for scalable, multi-GPU graph analytics in network sensing.

Abstract

Large-scale network sensing plays a vital role in network traffic analysis and characterization. As network packet data grows increasingly large, parallel methods have become mainstream for network analytics. While effective, GPU-based implementations still face start-up challenges in host-device memory management and porting complex workloads on devices, among others. To mitigate these challenges, composable frameworks have emerged using modern C++ programming language, for efficiently deploying analytics tasks on GPUs. Specifically, the recent C++26 Senders model of asynchronous data operation chaining provides a simple interface for bulk pushing tasks to varied device execution contexts. Considering the prominence of contemporary dense-GPU platforms and vendor-leveraged software libraries, such a programming model consider GPUs as first-class execution resources (compared to traditional host-centric programming models), allowing convenient development of multi-GPU application workloads via expressive and standardized asynchronous semantics. In this paper, we discuss practical aspects of developing the Anonymized Network Sensing Graph Challenge on dense-GPU systems using the recently proposed C++26 Senders model. Adopting a generic and productive programming model does not necessarily impact the critical-path performance (as compared to low-level proprietary vendor-based programming models): our commodity library-based implementation achieves up to 55x performance improvements on 8x NVIDIA A100 GPUs as compared to the reference serial GraphBLAS baseline.

Figures (6)

• Figure 1: C++26 asynchronous Senders programming model in std::execution. Using this standardized model, asynchronous workloads can be composed over diverse execution environments, for e.g., scheduling data manipulation tasks on multiple GPUs, captured here.
• Figure 2: Graph Challenge workflow overview with our proposed processing method using the C++26 Senders Model. The "Preprocessing Steps" graphics are adapted from graphchallenge. Under the C++26 Senders Model, we load and aggregate traffic matrix files, forming an asynchronous workflow, comprised of batching and bulk pushing data operations to multiple GPUs.
• Figure 3: Demonstrates input data batching from host to GPUs, where individual device partitions are sub- partitioned into fixed-size batches, sequentially moved on GPUs by the host during computation.
• Figure 4: Scalability (analysis time, lower is better) on 1--8 GPUs with varying batch counts. Best performance is observed using 8 GPUs and 10 batches at $\sim$1 seconds compared to $\sim$64 seconds for sequential baseline.
• Figure 5: Relative performance improvement (compared to serial reference implementation, higher is better) on 1--8 GPUs with varying batch counts. Best performance observed at 8 GPUs using 10 batches: 55$\times$.