Low-Latency 5G/6G Core Networks

Modern cellular core networks are evolving from monolithic, purpose-built infrastructures into cloud-native, microservice-based systems. The 5G Core (5GC) adopts a service-based architecture, where control-plane network functions communicate through standardized Service-Based Interfaces (SBI), while the User Plane Function (UPF) handles packet forwarding, tunneling, buffering, and QoS enforcement. This disaggregated design improves flexibility, programmability, and deployment agility, but it also introduces new performance bottlenecks.

This project explores how to redesign and optimize the 5G/6G cellular core to support low-latency control-plane operations, high-throughput user-plane packet processing, efficient control/data-plane coordination, and flexible multi-tenant services. The goal is to preserve 3GPP compliance and cloud-native modularity while removing unnecessary overheads from kernel networking, HTTP/REST-based inter-NF communication, inefficient rule lookup, and software-only packet processing.

Research Overview

The central observation behind this project is that cellular core latency is not only a data-plane problem. Control-plane procedures such as UE registration, PDU session establishment, paging, and handover directly affect when user traffic can start or resume. In a disaggregated 5GC, these procedures require many message exchanges among control-plane network functions. When implemented using kernel-based HTTP/REST APIs, these exchanges incur data copies, protocol processing, serialization/deserialization, context switches, and scheduling overheads.

At the same time, the UPF must process increasingly complex traffic. Emerging 5G/6G use cases, such as cloud gaming, AR/VR, connected vehicles, fixed wireless access, cellular home gateways, and flow-specific firewalls, may require many Packet Detection Rules (PDRs) per user session. A linked-list-based PDR lookup, as commonly used in 3GPP-style UPF implementations, does not scale well as the number and complexity of packet-processing rules grow.

My work in this area develops a series of systems and techniques that jointly optimize the cellular core:

• L25GC (Jain et al., 2022) re-architects the 5G Core using a high-performance NFV platform. It replaces kernel-based SBI and N4 communication with shared-memory-based zero-copy communication, consolidates related control and data-plane functions, improves handover and paging with UPF-based buffering, accelerates PDR lookup, and adds fast failure recovery.

• L25GC+ (Liu et al., 2023) improves L25GC by introducing a shared-memory-based I/O stack (X-IO (Qi et al., 2023)) that supports synchronous request-response semantics, concurrent user sessions, and seamless integration with Golang-based free5GC network functions. This makes shared-memory communication compatible with 3GPP SBI while reducing porting effort.

• L26GC / 6G Core exploration (Jain et al., 2022; Qi et al., 2024) extends the design toward future cellular networks. It studies how shared-memory SBI, fast PDR lookup, SmartNIC-based UPF offload, and context-aware QoS can help future 6G cores support lower latency, higher throughput, and richer service differentiation.

• Recent L25GC+ extensions (Lin et al., 2025) further add fairness-aware QoS enforcement, rate limiting for hotspot control-plane NFs, network slicing, and geographically distributed deployment on the NSF FABRIC testbed. These features make the platform more suitable for multi-tenant, programmable, and realistic 5G research environments.

Together, these works form a coherent research direction: rethinking the cellular core as a high-performance, cloud-native, and programmable system, where control-plane communication, user-plane packet processing, and resource management are co-designed for low latency and flexibility.

Key Ideas

Low-Latency Control Plane with Shared Memory

The 5G control plane is implemented as a set of disaggregated network functions, such as AMF, SMF, AUSF, NRF, PCF, UDM, and NSSF. Although this service-based architecture improves modularity, the default HTTP/REST-based SBI introduces substantial overhead.

Our work replaces kernel-based inter-NF communication with shared-memory-based communication. Messages are exchanged through lightweight descriptors, while the actual payload remains in shared memory. This avoids repeated serialization, deserialization, protocol processing, data copying, and kernel/userspace boundary crossings.

A key challenge is that 3GPP SBI expects synchronous request-response semantics, while high-performance NFV frameworks such as OpenNetVM are designed around asynchronous, non-blocking shared-memory communication. L25GC+ and X-IO bridge this gap by providing POSIX-like socket APIs and HTTP/REST-compatible APIs on top of shared memory, allowing existing 5GC network functions to retain their programming model while benefiting from a faster datapath.

High-Performance User Plane

The UPF is responsible for forwarding user packets between the RAN and the data network. It must perform GTP tunneling, packet classification, forwarding-rule lookup, buffering, and QoS enforcement. As 5G/6G use cases become more diverse, the number of PDRs per user session may grow significantly.

Instead of relying on a simple linked-list lookup, our work explores scalable packet classification mechanisms such as Tuple Space Search and PartitionSort. These mechanisms reduce PDR lookup latency and improve throughput when the UPF must support many fine-grained flow rules.

We also explore SmartNIC-based UPF offload, where packet forwarding and GTP tunneling are accelerated using programmable NIC hardware. This design allows the SmartNIC to handle common fast-path traffic while the host-based UPF processes more complex or missed flows.

Control/Data-Plane Co-Design

In cellular networks, the control plane and data plane are tightly coupled. Control-plane events install or update forwarding state in the UPF, while data-plane events such as downlink packet arrival may trigger paging or buffering behavior.

L25GC exploits this relationship by splitting the UPF into UPF-C and UPF-U. UPF-C handles control-plane interactions, while UPF-U focuses on packet processing. Shared memory allows them to access common state with minimal synchronization overhead. This design reduces control/data-plane interference while enabling fast state updates.

The project also redesigns handover buffering. Instead of relying on source-gNB buffering and hairpin forwarding, L25GC buffers packets at the UPF during handover. This avoids unnecessary forwarding paths, reduces packet loss, and better supports small-cell environments where base stations may have limited buffering capacity.

Reliability, Fairness, and Slicing

Low latency alone is not sufficient for a practical cellular core. The system must also support failure recovery, fairness, isolation, and multi-tenant deployment.

L25GC includes a resiliency framework that avoids forcing UEs to reattach after failures. It uses local and remote replicas, state replication, and packet replay to recover from software and node failures while maintaining control/data-plane consistency.

The latest L25GC+ work further adds fairness-enhanced QoS support in the UPF. It combines 3GPP-style trTCM traffic marking with token-bucket shaping to provide bandwidth guarantees while avoiding starvation of non-QoS flows.

Network slicing support enables multiple virtual 5GCs to share the same physical infrastructure. This allows the platform to support differentiated services, multi-tenant isolation, and more efficient resource sharing across slices.

Broader Impact

This project demonstrates that the cellular core can be both cloud-native and high-performance. By co-designing control-plane communication, user-plane packet processing, shared-memory I/O, programmable hardware offload, QoS enforcement, and network slicing, this line of work provides a foundation for future 5G/6G core networks that are low-latency, scalable, flexible, and suitable for open research platforms.