Part of: 4G / 5G & O-RAN
NVIDIA Aerial runs the 5G physical layer on a GPU. This page explains what it is, how it is laid out on COSMOS, which COSMOS hardware it uses, and which tutorial to take first.
The same GH200 servers also serve general GPU work (machine learning, Sionna, language models): see GPU computing on the GH200 servers, which also explains how the GH200 images use shared content and what to know before saving an image of your own.
A 5G base station spends most of its computing on the physical layer (PHY): channel estimation, equalisation, LDPC decoding and modulation, repeated for every slot and every cell. OCUDU, Duranta and Amarisoft run it on CPU cores. NVIDIA Aerial CUDA-Accelerated RAN runs it on a GPU instead, as CUDA kernels, so one server can serve many cells.
Aerial is open source (Apache 2.0) and has three parts that matter here:
cuphycontroller drives the GPU pipelines and an O-RAN 7.2 fronthaul, and talks to a layer-2 stack over the 5G FAPI interface.COSMOS runs Aerial release 26-2.
The 3GPP base station splits into a central unit (CU) and a distributed unit (DU); the O-RAN Alliance adds the radio unit (RU) behind a 7.2x fronthaul. 5G SA fundamentals and O-RAN and the 7.2x fronthaul explain both.
Aerial is the lower half of the DU: the high physical layer. A layer-2 stack (MAC and scheduler) sits above it, and an O-RU sits below it on the fronthaul.
| Part | What it does | Aerial component | Where it runs on COSMOS |
|---|---|---|---|
| High PHY | channel processing for every cell and slot | cuPHY | the GH200 GPU in srv8.rrail |
| Real-time control | slot timing, the GPU pipelines, the fronthaul | cuBB cuphycontroller |
the Aerial container on srv8.rrail |
| Fronthaul | O-RAN 7.2 packets to and from the O-RU | GPU-initiated DOCA GPUNetIO on a BlueField-3 NIC | srv8.rrail BlueField-3 (NIC mode) — not used by the first tutorial |
| Test traffic | stands in for layer 2 or for an O-RU | test vectors (HDF5 files with inputs and reference outputs); later testMAC and an RU emulator |
the image (test vectors); srv9.rrail (RU emulator, planned) |
| Python | simulation and machine learning on cuPHY | pyAerial | a Python environment on the image |
Everything runs inside NVIDIA's cuBB container. The command aerial-run starts it with the right devices and mounts.
Server. srv8.rrail, a Supermicro ARS-111GL-NHR with an NVIDIA GH200 Grace Hopper Superchip: a 72-core Arm Neoverse V2 CPU and a Hopper GPU on one module, joined by NVLink-C2C. It is an arm64 server, so it runs arm64 images only. NVIDIA's Aerial installation guide for Grace Hopper names this server model.
Fronthaul NICs. Two NVIDIA BlueField-3 cards in NIC mode, firmware 32.48.1000, configured with the Aerial settings (accurate TX scheduling, real-time clock).
Image. Load aerial-26-2-gh200.ndz with omf load. It holds Ubuntu 24.04 arm64 with NVIDIA's 6.17-nvidia-64k kernel, GPU driver 610.57.04, DOCA 3.3.0 and GDRCopy.
Aerial software on a shared drive. The Aerial 26-2 software is not in the image. It sits on a read-only COSMOS network share that the image mounts at /opt/aerial, one directory per Aerial release, as with Xilinx and Matlab:
/opt/aerial/26-2/sdk: the Aerial source tree built for aarch64, with pyAerial and the tutorial test vectors. /opt/aerial-cuda-accelerated-ran points to it./opt/aerial/26-2/containers: the cuBB container and the Duranta layer 2 containers, as archive files.At every boot the image copies what runs faster locally. The service aerial-sdk-local syncs the SDK to the local data disk (/mnt/datadisk/aerial-sdk-26-2; the GPU slot timing is about twice as slow when the SDK is read from the share), and /opt/aerial-cuda-accelerated-ran points to that copy. Without a data disk it points to the share instead. The service aerial-images loads the containers into the server's local docker store. Check that both have finished with systemctl is-active aerial-sdk-local aerial-images (both say active). The share is read-only: to rebuild the Aerial software, copy the tree to your work area first.
Local data disk. /mnt/datadisk is about 7.8 TB of local NVMe: a cache for the SDK copy and a work area for captures and builds. It is not storage. Whoever reserves the server next can load any image, which may wipe it, so copy results off the server before your reservation ends.
Saving your own image. The Aerial containers loaded at boot are in the docker store on the system disk, so an image saved as is carries them (tens of GB). /root/prepare.sh removes them for you when they are unmodified, and they are loaded again at the next boot; see Saving your own image.
Domain. rrail is a reserved project domain: access is by group membership. srv9.rrail is the same model and will be the RU emulator for the second tutorial.
Licence. Aerial's source is Apache 2.0. The cuBB container is covered by the NVIDIA Deep Learning Container licence, which it prints each time it starts; using it means accepting those terms.
| Tutorial | Radio? | Domain | Time | What you learn |
|---|---|---|---|---|
| aerial-cuphy | no (GPU only) | rrail |
60–75 min | how the GPU runs the 5G physical layer: the PUSCH, PDSCH and SSB pipelines checked against reference outputs, per-slot GPU latency, and how many cells one GPU can carry |
| aerial-ru-emulator (planned) | no (emulated O-RU) | rrail |
— | the full cuBB application with testMAC above it and an RU emulator on srv9 over a real 7.2 fronthaul |
| Duranta on NVIDIA Aerial (results; tutorial aerial-ota planned) | yes: O-RAN 7.2 O-RU + 5G modem | rrail |
— | a live cell with the Duranta layer 2, a core and a commercial modem, on the Foxconn, Benetel or LiteOn O-RU |
| OCUDU on NVIDIA Aerial (results; tutorial planned) | yes: three O-RAN 7.2 O-RUs + 5G modems | rrail |
— | the OCUDU gNB on the Grace cores with the Aerial L1 on the GPU: three cells on three O-RUs from ONE gNB, all loaded at once (1.2 Gbit/s UDP total, GPU under 50 %) |
GPU only — aerial-cuphy. Run cuPHY on test vectors. No timing, fronthaul or radio can fail here, so this is where you learn what correct output and normal GPU latency look like.
Emulated radio (planned). Add the real-time controller, a layer-2 test driver and an RU emulator on a second GH200 server.
Over the air. Replace the emulator with an O-RU from the O-RU pool and attach a commercial modem. This works today with two layer-2 stacks:
The tutorials are in preparation.
Best over-the-air results. All results are on the same GH200 server and image (aerial-26-2-gh200, Aerial 26-2), with O-RAN 7.2 O-RUs at n78, 100 MHz, 4T4R. The modems are commercial 5G modems on USB 3. TCP uses iperf3 (receiver line) and UDP uses fixed-rate iperf2. The two linked pages have the details.
| CPU / GPU platform | Layer 2 | Setup | DL (Mbit/s) | UL (Mbit/s) | Measured |
|---|---|---|---|---|---|
| NVIDIA GH200 (Grace, 72 Arm Neoverse V2 cores / 72 threads + Hopper GPU) | OCUDU | one gNB, three cells on three O-RUs, all loaded, UDP | 1190 (every cell < 2 % loss); 1365 with TDD 7 DL / 2 UL | — | 2026-11-09 |
| NVIDIA GH200 (Grace, 72 Arm Neoverse V2 cores / 72 threads + Hopper GPU) | OCUDU | one gNB, three cells on three O-RUs, all loaded, TCP | 650–727 | 248–265 | 2026-11-09 |
| NVIDIA GH200 (Grace, 72 Arm Neoverse V2 cores / 72 threads + Hopper GPU) | OCUDU | one cell (Benetel RAN650), TCP | 474 (UDP 700) | 144 | 2026-11-09 |
| NVIDIA GH200 (Grace, 72 Arm Neoverse V2 cores / 72 threads + Hopper GPU) | OCUDU | one cell (Foxconn RPQN-7801), TCP | 464 (UDP 700) | 147 | 2026-11-09 |
| NVIDIA GH200 (Grace, 72 Arm Neoverse V2 cores / 72 threads + Hopper GPU) | OCUDU | one cell (LiteOn FlexFi), TCP | 190 | 26 | 2026-11-09 |
| NVIDIA GH200 (Grace, 72 Arm Neoverse V2 cores / 72 threads + Hopper GPU) | Duranta | one cell (Foxconn RPQN-7801), TCP | 528 (UDP 690) | 105 | 2026-11-04 |
| NVIDIA GH200 (Grace, 72 Arm Neoverse V2 cores / 72 threads + Hopper GPU) | Duranta | one cell (Benetel RAN650), TCP | 340–352 | 107 | 2026-11-04 |
| NVIDIA GH200 (Grace, 72 Arm Neoverse V2 cores / 72 threads + Hopper GPU) | Duranta | one cell (LiteOn FlexFi), TCP | 472–487 | 56.8 | 2026-11-04 |
| NVIDIA GH200 (Grace, 72 Arm Neoverse V2 cores / 72 threads + Hopper GPU) | Duranta | three gNBs, three cells on air, one modem at a time, TCP | 430–502 per cell | 60–191 per cell | 2026-11-04 |
With OCUDU's three cells loaded, the GPU stays under 50 % busy and every per-slot PHY job finishes in under half of its 500 µs slot.
GPU capacity.
How many cells one GPU carries in NVIDIA's standard multi-cell workload (cubb_gpu_test_bench with NVIDIA's cubb_gpu_test_config.yaml: use case F08, TDD pattern dddsuudddd, all channels, 400 slots per cell count). A cell count passes when every channel finishes inside its latency budget in 100 % of slots.
| GPU / CPU platform | Cells (100 % on time, all channels) | Measured |
|---|---|---|
| NVIDIA GH200 480GB (Hopper GPU at 1980 MHz) + NVIDIA Grace, 72 Arm Neoverse V2 cores / 72 threads | 21 — every count from 10 to 21 passes; the stock configuration cannot set up 22 or more | 2026-11-01 · aerial-26-2-gh200 (Aerial 26-2) |
Glossary
- PHY / high PHY — the physical layer; "high PHY" is the part of it that stays in the DU at the 7.2x split.
- cuPHY — Aerial's GPU physical-layer library. cuBB — the real-time application built on it.
- Test vector (TV) — an HDF5 file with a channel's configuration, input samples and the reference output from NVIDIA's MATLAB model; a pipeline passes when its GPU output matches the reference.
- FAPI — the interface between layer 2 and the physical layer (Small Cell Forum).
- MPS — CUDA Multi-Process Service, which lets several processes share one GPU; the multi-cell bench uses it to run every channel at once.
- GH200 — NVIDIA Grace Hopper: an Arm CPU and a Hopper GPU in one package with a shared, coherent memory link.