GPU-Powered 5G/6G PHY Revolution with NVIDIA Aerial

Image courtesy of NVIDIA Aerial Expands With New Tools for Building AI-Native Wireless Networks | NVIDIA Blog

NVIDIA Aerial Framework serves as a high-level orchestration layer built atop the Aerial CUDA-Accelerated RAN libraries, enabling developers to construct modular 5G NR pipelines while leveraging optimized GPU kernels for signal processing.

Architectural Relationship

The Aerial Framework provides abstractions for tasks, pipelines, memory management, and tensor operations, defining interfaces that orchestrate 5G NR workflows. Beneath it, the Aerial CUDA-Accelerated RAN (cuRAN) layer delivers low-level CUDA implementations through cuPHY and cuBB libraries, containing GPU-optimized kernels for PHY operations like modulation, FFT, and channel estimation. This layered design separates concerns: the Framework handles composition and runtime management, while cuRAN supplies the computational primitives.

Accessibility Enhancements

Aerial Framework makes the underlying cuRAN more accessible by abstracting CUDA complexity into C++ pipelines and Python bindings (pyAerial), reducing boilerplate for memory allocation, stream synchronization, and kernel launches. Developers define high-level tasks — like a PUSCH receive chain — that automatically map to cuPHY components via standardized tensor interfaces, shared LUTs, and type variants aligning FAPI parameters to GPU data structures. This enables rapid prototyping of channel estimation pipelines without deep CUDA expertise, while retaining performance through features like CUDA graphs, memory pools, and integrated profiling.

Key Integration Points

• Build Dependencies: Framework’s CMake integrates cuRAN as submodules, linking cuPHY static libraries during compilation for seamless tensor passing.
• Type System: Framework variants (e.g., TensorView<cuPHY::cfloat>) directly map to cuRAN data types, ensuring zero-copy handoff between orchestration and kernels.
• Runtime References: Framework tasks invoke cuPHY via cuPHY::ChannelEstimator::estimate(), with test configs pulling from cuPHY-CP validation suites.

This structure allows cuRAN’s optimized signal processing — critical for real-time 5G NR — to pair with Framework’s modern orchestration, paving the way for custom pipelines like channel estimation on DM-RS.

Example Overview

The below example demonstrates how to implement a production-ready GPU-accelerated signal processing feature in NVIDIA’s Aerial framework, specifically focusing on 5G NR channel estimation. The implementation showcases a complete end-to-end workflow from low-level CUDA kernel development to high-level pipeline orchestration, illustrating how modern 5G baseband processing can achieve both high performance and developer productivity. The channel estimation module supports multiple algorithms (Least Squares, MMSE, and linear interpolation) and demonstrates key optimization techniques including CUDA graphs for reduced launch overhead, shared memory utilization for pilot symbol processing, and framework-integrated memory pool management for large tensor allocations. The example includes a comprehensive pipeline implementation that handles memory management, performance monitoring, and error handling while maintaining clean separation between framework abstractions and computational kernels. With benchmark results showing up to 45,000 operations per second for typical configurations and sub-25 microsecond latency, the implementation demonstrates how the Aerial framework enables developers to build high-performance 5G applications without sacrificing code maintainability or development velocity. The complete example serves as a template for implementing other signal processing algorithms in the framework, showing best practices for GPU memory management, CUDA optimization, and framework integration patterns.

Steps to implement in Aerial Framework

1. Implement Your Module Class

• Derive from pipeline::IModule and implement required methods: get_module_id(), execute(), is_input_ready(), is_output_ready()
• Handle tensor inputs/outputs and return task::TaskResult with proper status and error messages
• Implement any GPU kernel setup and launch logic in the execute() method

2. Create Module Factory

• Derive from pipeline::IModuleFactory to handle module instantiation
• Implement create_module() to parse ModuleSpec parameters and return your module instance
• Define get_supported_types() to specify which module types your factory can create

3. Implement Pipeline Orchestration (if needed)

• Derive from pipeline::IPipeline for multi-module workflows
• Implement execute_pipeline() and optionally execute_pipeline_graph() for CUDA graph optimization
• Handle memory pool setup, resource management, and performance statistics collection

4. Setup GPU Resources and Memory Management

• Configure CUDA graphs, streams, and kernel launch parameters in setup methods
• Use framework’s memory pools (memory::MemoryPool) for efficient tensor allocation
• Implement proper cleanup in teardown methods with RAII patterns

5. Configure Pipeline Specification

• Define pipeline::PipelineSpec with module configurations and parameters
• Create factory instances and register them with the framework
• Setup tensor dimensions, data types, and validation logic for your specific use case

6. Execute and Monitor

• Call execute_pipeline() with input/output tensor spans and cancellation tokens
• Use get_stats() to monitor performance metrics (execution time, success/failure rates)
• Handle task::TaskResult responses for error handling and status reporting

Some example code

Channel Estimation Pipeline Development:

The implementation started by defining a ChannelEstimationPipeline class inheriting from Aerial’s IPipeline interface, then implementing core algorithms (Least Squares and MMSE) using CUDA kernels with cuBLAS for matrix operations. The pipeline was integrated with Aerial’s tensor management system for efficient GPU memory handling, followed by creating a factory pattern for algorithm selection and configuration. Performance benchmarking was added using CUDA events for timing, comprehensive validation against known channel models was implemented, and finally both simple and comprehensive example applications were created to demonstrate real-time processing capabilities with synthetic 5G channel data generation.

Git location : samuel-sujith/nvidia-aerial-examples: Examples with aerial nvidia framework

Use this source code as a starter pack so as to structure your experiments.

Call to action

Armed with these Aerial Framework abstractions and cuPHY primitives, you now have everything needed to prototype and extend 5G NR pipelines for your own research workflows — experiment with multi-UE batches, tweak MMSE covariances, or swap in ML interpolators to push the boundaries of channel estimation accuracy.

6G researchers, it’s time to integrate GPU acceleration into your core workflows: start by porting your terahertz channel models, integrated sensing algorithms, and ultra-massive MIMO simulators to Aerial’s CUDA kernels, benchmarking against CPU baselines to quantify latency and throughput gains.

Profile your XL-MIMO beamforming or OTFS modulation prototypes on A100/H100 GPUs, leveraging cuPHY’s stream management for real-time execution.

Publish your accelerated baselines, share optimized kernels via open-source forks, and collaborate on 6G PHY standards — GPU acceleration isn’t optional for production-grade 6G; it’s the multiplier that turns research into deployable reality. Dive in today and lead the acceleration revolution.

References & Further Reading

Official Documentation:

• **Aerial Framework Docs**​
• **pyAerial Channel Est Notebook**​
• **cuPHY Channel Estimation API**​

3GPP Standards:

• **TS 38.211: NR Physical Channels/Signals**​
• **DM-RS PDSCH/PUSCH Mapping**​

Research Papers:

• **“NVIDIA AI Aerial: AI-Native Wireless” (40% UL throughput gain via CNN estimation)**​

GitHub & Tools:

• **NVIDIA Aerial Framework**​
• **Aerial CUDA-Accelerated RAN**​