Near RT RIC Segmentation for Low Latency
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
The Radio Access Network (RAN) in telecommunications networks faces challenges in achieving low latency and high-speed data processing due to limited computing power at base stations, which is exacerbated by the increasing functions required for 5G standards.
Innovation Solution
The implementation of novel RAN intelligent controllers (RICs) that separate functions into multiple components operating on different machines, with high-speed non-blocking, lockless interfaces, and internal non-blocking architectures to ensure low latency and efficient data processing.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Adaptability or versatility
If RAN functions are consolidated at base stations to enable 5G functions, then network functionality is improved, but computing power limitations at base stations cause latency and processing speed degradation
Solution Approach 1:
The RIC is segmented into multiple independent components (datapath component, service component, SDL component) that can operate on different machines. This segmentation allows computational tasks to be distributed across multiple processing units, reducing latency while maintaining enhanced network functionality. The datapath component handles high-speed data forwarding, the service component manages control plane applications, and the SDL component provides shared data services, enabling parallel processing without compromising functional integration.
Solution Approach 2:
The architecture transitions from a single-machine consolidation model to a multi-machine distributed model, adding a spatial dimension to the system architecture. By deploying RIC components across multiple machines with high-speed interfaces, the system achieves low-latency performance through distributed parallel processing while maintaining the functional versatility required for 5G operations.
2Productivity
If multiple RIC components operate on different machines, then processing parallelism is improved, but interface complexity and communication overhead increase
Solution Approach 1:
The shared data layer (SDL) component provides a universal interface that multiple RIC components can access simultaneously. This universal data access mechanism simplifies inter-component communication by providing a standardized interface for data sharing, reducing the complexity that would otherwise arise from multiple specialized communication channels between distributed components.
Solution Approach 2:
The SDL component acts as an intermediary between the datapath component, service component, and external systems. This mediator approach simplifies the interface complexity by providing a centralized data access point that multiple components can interact with through standardized protocols, reducing the need for direct point-to-point interfaces between all component pairs.
3Ease of manufacture
If blocking interfaces are used for simplicity, then implementation ease is improved, but critical datapath operations experience delays and stalling
Solution Approach 1:
The interface architecture transitions from static blocking operations to dynamic non-blocking operations. The datapath component implements non-blocking data forwarding mechanisms that can dynamically handle multiple requests without stalling, while the service component uses blocking operations for less time-critical control plane functions. This dynamic approach optimizes speed for critical paths while maintaining implementation feasibility.
Solution Approach 2:
The system changes the operational parameter of interface handling from blocking to non-blocking mode for the datapath component. This parameter change enables the datapath to process multiple data packets concurrently without waiting for individual operations to complete, significantly improving datapath speed while the service component maintains blocking operations for simpler, less time-sensitive tasks.
4Ease of operation
If computational operations are concentrated in single threads, then control simplicity is improved, but data IO performance and throughput are limited
Solution Approach 1:
The datapath thread is segmented into multiple specialized threads including a data IO thread for high-speed data reception and transmission, and multiple data processing threads for parallel data manipulation. This segmentation allows the system to maintain simple control logic in each individual thread while achieving high overall throughput through parallel execution. Each thread has a specific, simple function, but their combined operation delivers superior data IO performance.
Solution Approach 2:
The non-blocking data IO thread continuously receives and forwards data packets without interruption, while multiple data processing threads continuously process different aspects of the data stream in parallel. This continuous parallel action ensures that the datapath maintains high throughput without the idle periods that would occur with sequential single-threaded processing, while each thread maintains operational simplicity through dedicated functionality.
Data Source
AI summary
To provide a low latency near RT RIC, some embodiments separate the RIC's functions into several different components that operate on different machines (e.g., execute on VMs or Pods) operating on the same host computer or different host computers. Some embodiments also provide high speed interfaces between these machines. Some or all of these interfaces operate in non-blocking, lockless manner in order to ensure that critical near RT RIC operations (e.g., datapath processes) are not delayed due to multiple requests causing one or more components to stall. In addition, each of these RIC components also has an internal architecture that is designed to operate in a non-blocking manner so that no one process of a component can block the operation of another process of the component. All of these low latency features allow the near RT RIC to serve as a high speed IO between the E2 nodes and the xApps.