Bringing dApps to OCUDU: An E3 Controller for Real-Time Open RAN Intelligence
summary
The gist
Real-time control loops in Open RAN are increasingly colocated with the gNB, where dApps, i.e., programmable applications with sub-millisecond access to PHY- and MAC-layer signals…
In short
The E3Controller framework brings a defined interface (E3) to OCUDU software using a sidecar architecture. It allows programmable applications (dApps) to access real-time RAN signals for latency-critical tasks like spectrum sensing. Experiments confirm this adds no measurable throughput penalty, proving a real-time dApp/RAN interface is feasible on production Open RAN software.
Key concepts
- E3 Interface
- A protocol defining how a dApp subscribes to telemetry (data), receives indications (events), and issues control actions back to the RAN. It cleanly separates what the application exchanges from how the specific RAN exposes its internal signals, allowing flexibility across different software stacks.
- E3Controller
- An open-source sidecar framework designed to host the E3 protocol stack and dApp logic outside the core RAN processing. It uses a three-stage pipeline (poll, worker, publisher) executed on dedicated threads to minimize latency for real-time interactions.
- Sidecar Architecture
- The deployment pattern where the E3Controller runs alongside the main OCUDU gNB process. It communicates with the RAN using lightweight Inter-Process Communication (IPC) mechanisms like jbpf's shared memory and LCM socket, keeping most of the complex logic external to the core software.
- L1 Service Model
- A specific service model used by the framework that streams O-RAN fronthaul I/Q samples directly to a spectrum-sensing dApp via shared memory. This method avoids encoding overhead in ASN.1, providing a high-speed data path for demanding real-time applications.
Terminology used across episodes
This episode discusses
- Bringing dApps to OCUDU: An E3 Controller for Real-Time Open RAN Intelligence · Paper Radio
- Enabling Real-Time Programmability for RAN Functions: A Wasm-Based Approach for Robust and High-Performance dApps
- TENORAN: Automating Fine-grained Energy Efficiency Profiling in Open RAN Systems
- Programmable GPU-Accelerated dApps for Real-Time Edge Inference and ISAC on NVIDIA Aerial Testbed · Paper Radio
The paper
Bringing dApps to OCUDU: An E3 Controller for Real-Time Open RAN Intelligence · Read on arXiv
Institute for Intelligent Networked Systems, Northeastern University
Real-time control loops in Open RAN are increasingly colocated with the gNB, where dApps, i.e., programmable applications with sub-millisecond access to PHY- and MAC-layer signals, enable latency-critical use cases such as spectrum sharing, channel-aware scheduling, and integrated sensing. What turns dApps from a per-vendor mechanism into a portable component of the emerging AI-RAN ecosystem is the E3 interface: this interface defines how a dApp subscribes to RAN telemetry, receives indications, and issues control actions back to the RAN. To date, E3 has been implemented on OpenAirInterface and on NVIDIA Aerial; OCUDU, i.e., the Linux Foundation's open-source CU/DU project, has lacked a comparable E3 path. We close that gap with an open-source E3Controller for OCUDU, designed as a sidecar daemon so the E3 protocol stack, service-model logic, and dApp interactions live entirely outside RAN core processing, which is touched only through well-defined instrumentation hooks. We validate the controller with two reference service models, Spectrum and L1, that deliver O-RAN fronthaul I/Q samples to a spectrum-sensing dApp over a Foxconn RPQN 4800 radio unit. Our evaluation shows that the E3 path imposes no measurable throughput penalty on the OCUDU RAN, demonstrating that a real-time dApp/RAN interface is feasible on production-grade open RAN software.
Transcript
Introduction to the show: ident: Computer Science. The day in computer science: software, systems and theory on arXiv.
Tom: I'm Tom.
Jane: And I'm Jane, here with Lu, Meng and our in-house large language model, Lalam.
Tom: We're looking at the paper: "Bringing dApps to OCUDU".
Jane: Here's the gist of the paper. Real-time control loops in Open RAN are increasingly colocated with the gNB, where dApps, i.e., programmable applications with sub-millisecond access to PHY- and MAC-layer signals, enable latency-critical use cases such as spectrum sharing, channel-aware scheduling, and integrated sensing The E3 interface defines how a dApp subscribes to RAN telemetry, receives indications, and issues control actions back to the RAN This paper closes that gap by presenting E3Controller, an open-source framework that brings the E3 interface to OCUDU through a sidecar architecture The evaluation shows that the E3 path imposes no measurable throughput penalty on the OCUDU RAN, demonstrating that a real-time dApp/RAN interface is feasible on production-grade open RAN software The Core Concept of the E3 Interface The E3 interface serves as a well-defined protocol for interacting with RAN components, defining how a dApp subscribes to telemetry, receives indications, and issues control actions back to the RAN This interface allows the same dApp to run across different stacks and serve different RANs by cleanly separating what dApps exchange from how a given RAN exposes it The E3Controller is designed as a sidecar daemon so that the E3 protocol stack, service-model logic, and dApp interactions live entirely outside the RAN core processing This decoupling requires only lightweight instrumentation hooks in the RAN software stacks to interact with the controller Architecture of the E3Controller The E3Controller is organized as a three-stage pipeline comprising a poll, worker, and publisher stage, each executed on a dedicated thread to minimize latency along the RANto-dApp data path The architecture follows a sidecar pattern where the E3Controller runs alongside the OCUDU gNB process It communicates with the RAN via jbpf’s shared-memory IPC for data and via jbpf’s LCM IPC socket for codelet lifecycle management This design ensures that only hook macros and agent initialization need to live inside OCUDU, while the rest of the pipeline sits behind a clean IPC boundary Service Models and Data Flow The framework supports two reference service models, Spectrum and L1, which deliver O-RAN fronthaul I/Q samples to a spectrum-sensing dApp over a Foxconn RPQN 4800 radio unit The Spectrum service model supports both information reporting and E3 control actions The L1 service model streams O-RAN fronthaul I/Q samples, and it delivers the sample buffers via shared memory to avoid the overhead of encoding them in ASN.1 Performance Validation The experimental evaluation focuses on the L1 service model, which represents the most demanding data path currently supported by the E3Controller The results show that enabling the controller hooks, exporting fronthaul I/Q samples to dApps through the E3 interface, and encoding choice introduces no measurable impact on OCUDU RAN throughput The median latency remains between approximately 115 and 120 µs across all four configurations, which is well below the sub-millisecond latency budget required by real-time dApps under heavy traffic The dominant cost of the framework is therefore CPU occupancy, not energy, as the polling threads are statically pinned to dedicated cores Future Directions The authors envision the E3Controller as a general execution platform for programmable RAN services rather than solely a data-export mechanism Enabling dApps to dynamically inject logic into selected RAN functions would allow runtime extension of scheduling, PHY processing, and other protocol-stack components without modifying or redeploying the underlying RAN software This capability would transform dApps into active extensions of the RAN processing pipeline The resulting platform exposes fronthaul- and PHY-level data streams to E3-compliant dApps and is validated on a commercial O-RAN 7.2x deployment Acknowledgments This work was supported by OUSW(R&E) through Army Research Laboratory Cooperative Agreement Number W911NF24-2-0065 The views and conclusions contained in this document are those of the authors and should not be interpreted as representing the official policies, either expressed or implied, of the Army Research Laboratory or the U.S.
Tom: Government The U.S.
Jane: Government is authorized to reproduce and distribute reprints for Government purposes notwithstanding any copyright notation herein The paper's arXiv id is 2609.
Title and authors: Tom: So we're diving deeper into the paper, "Bringing dApps to OCUDU: An E3 Controller for Real-Time Open RAN Intelligence." We talked about the basic idea of making real-time control loops possible by decoupling the application from the core radio stack. Jane Before we get into how it works, I want to talk about who wrote this; Angelo Feraudo, Ravis Shirkhani, Stefano Maxenti, A. Lacava, M. Polese, and T. Melodia are the authors.
Lu: They’re researchers who have deep roots in the field of model training and representation learning, which is key because they’re focused on how these applications can actually interact with the radio layer's data structures.
Meng: I'm more interested in what they did specifically for OCUDU; how does this E3 Controller fit into the existing Open RAN software environment? Is it just an add-on that adds complexity?
Tom: They tackle that by presenting the E3Controller as a sidecar process running on the same edge host as the OCUDU gNB. It’s not trying to replace OCUDU; it's sitting alongside it, interacting with it through lightweight instrumentation hooks.
Jane: So they are using this sidecar architecture to bring the E3 interface directly into OCUDU, which is a bit of a clever way to introduce new capabilities without touching the core software.
Lu: They leverage jbpf for instrumenting that gNB process, using eBPF style codelets to inject verified bytecode, and then they use shared memory for the data path communication.
Meng: That’s where I get skeptical; relying on instrumentation hooks inside a production network makes me wonder about stability and verification. How do you guarantee those hooks don't introduce unexpected bugs?
Tom: The paper addresses that by emphasizing that these hooks serve as attachment points for jbpf codelets, which compile to no-ops if the feature is disabled, meaning it’s designed to be safe and verifiable while the feature is off.
Jane: So they’ve made a point about safety there—it's not just adding functionality; it's built with a mechanism to control when that functionality is active. But what about how they handle the data flow itself?
Lu: They use a three-stage pipeline: poll, worker, and publisher stages running on dedicated threads to minimize latency along the RANto-dApp data path. It’s a very structured approach to handling the flow.
Meng: That structure sounds good for performance, but does it mean we have three separate points where data could potentially get delayed? I need to know if that pipeline is truly minimal overhead.
Tom: They state that this specific organization minimizes latency along the RANto-dApp data path by dedicating a thread to each stage, which is crucial for meeting those tight timing requirements.
Jane: So the next step in our conversation should be about what these service models actually deliver; what kind of signals are we talking about receiving?
Lu: They focus on two reference service models: Spectrum and L1. The Spectrum model handles information reporting, while the L1 model streams the raw I/Q samples from the O-RAN fronthaul directly to a spectrum-sensing dApp via shared memory.
Meng: The raw I/Q samples again. That’s high bandwidth, high fidelity data. Are we talking about millions of points per second that we need to handle in real time?
Tom: They are specifically focused on the L1 model for their performance validation, showing how it handles the most demanding data path currently supported by this framework.
Jane: So, if I’m listening on the show right now and I’m driving, what am I actually hearing about this paper? It sounds like they are building a bridge between complex network software and smart applications.
Lu: They're bridging that gap by providing E3Controller so that dApps don't have to understand the deep intricacies of the OCUDU gNB structure themselves.
Meng: And from an engineering deployment standpoint, what’s the actual cost of running this whole thing? Is it just CPU cycles, or are there other hidden resource constraints at scale?
Tom: As we discussed earlier, they found that for their validation on a Foxconn RPQN four thousand eight hundred unit, the dominant cost is CPU occupancy because of those statically pinned polling threads.
Jane: So we have the setup; now we know what it does. Next up, let’s look at how they prove it actually works in terms of performance and what that means for us on the ground.
The paper's summary: Tom: Now that we know the architecture, I want to walk you through what the authors summarize as the core achievement of this paper. They are showing that they’ve successfully brought this E3 interface—this standardized way for apps to interact with the RAN—to OCUDU.
Jane: So, they are demonstrating feasibility: proving that a real-time dApp/RAN interface is actually achievable on production-grade open RAN software like OCUDU, and it's not just theoretical.
Lu: The summary emphasizes that this framework successfully brings the E3 interface to OCUDU through that sidecar architecture, which requires only lightweight instrumentation hooks in the RAN software stacks.
Meng: So they managed to integrate this into existing systems without requiring a massive overhaul of the core radio stack's codebase? That’s a huge win for deployment speed.
Tom: Exactly; the paper highlights that this decoupling is key. The E3 protocol stack, service model logic, and dApp interactions all execute outside the OCUDU process itself.
Jane: I think what they want us to grasp is that this separation allows the same dApp to run across different stacks and serve different RANs by cleanly separating what dApps exchange from how a given RAN exposes it.
Lu: They achieved this by designing the E3Controller as a sidecar daemon, ensuring that only hook macros and agent initialization need to live inside OCUDU.
Meng: That sounds like good isolation for debugging purposes; if something breaks in the dApp logic, you don't necessarily have to dig into the deeply nested RAN code.
Tom: It really does simplify the operational side of things, moving complexity away from the core processing unit where it impacts performance most.
Jane: And they’ve used this framework to show that even under heavy traffic conditions, we can maintain very tight timing requirements for these latency-critical use cases.
Lu: They did that by measuring median latencies at approximately one hundred fifteen to one hundred twenty microseconds across all four configurations, which is well below the sub-millisecond budget.
Meng: So if I’m deploying this, I can bet that the performance metric they report is reliable because they tested it on a real commercial unit.
Tom: They did test it using a commercial Foxconn RPQN four thousand eight hundred radio unit, which gives their results some weight in the eyes of production engineers.
Jane: So we’ve seen the structure and now we see the summary of what they actually accomplished: proving that real-time dApp/RAN interfaces are feasible on current production software.
Lu: It’s a demonstration that you can have these sophisticated interactions happening without compromising the performance of the underlying RAN processing.
The paper's improvements: Tom: Now we look at what they suggest are the improvements this framework offers over previous approaches, moving beyond just showing it works. They are really pushing for a more powerful future for this concept.
Jane: What kind of improvements are they suggesting? Are they just making it faster, or are they changing the fundamental way dApps interact with the RAN?
Lu: The major improvement is vision: they want to move E3Controller from just being a data-export mechanism to becoming a general execution platform for programmable RAN services.
Meng: A general execution platform—that means dApps can actually inject logic into the radio functions dynamically? That sounds like it could be very powerful, but it also introduces massive stability risks if we’re talking about runtime modification.
Tom: They are describing this as enabling dApps to dynamically inject logic into selected RAN functions—like scheduling or PHY processing—without needing to modify or redeploy the underlying RAN software.
Jane: That sounds like a huge step toward true programmability, moving beyond just reading data and reacting to it. It means dApps become active extensions of the processing pipeline itself.
Lu: They envision this resulting platform exposing fronthaul- and PHY-level data streams to E3-compliant dApps, which is a very deep integration point.
Meng: If that’s true, then the cost shifts from just CPU usage to managing the complexity of dynamically loaded logic across potentially many different application versions. That’s a deployment headache I haven't seen much of.
Tom: They are validating this concept on commercial O-RAN seven point two times deployments, which shows they aren't just in the lab; they are aiming for real world validation <ref:2609.03162#pg2>.
Jane: So, the improvement isn't just about latency anymore; it’s about empowering applications to influence network behavior dynamically at runtime. That’s a big shift in capability.
Lu: It means the platform is designed to support multiple, independent data types being exposed as separate E3 RAN functions, allowing a single dApp to correlate across different data types using a common identifier for demultiplexing indications based on the corresponding ranFunctionId.
Meng: That correlation capability is definitely valuable; if I can get context from spectrum sensing and channel scheduling in one go, that reduces the complexity of my own application logic.
Tom: So they’re not just solving a single latency problem anymore; they are building an extensible platform for future RAN intelligence.
Jane: It’s about moving toward a system where dApps can truly participate in the network's intelligence, rather than just being observers attached to it.
Conclusion: Tom: So we wrap up with the conclusion of this paper on "Bringing dApps to OCUDU: An E3 Controller for Real-Time Open RAN Intelligence." They summarize that they’ve successfully brought the E3 interface to OCUDU through this sidecar architecture.
Jane: In short, they proved that a real-time dApp/RAN interface is feasible on production-grade software, and they showed that the performance impact on throughput was negligible.
Lu: The core takeaway is that the E3Controller provides a clear separation between what applications exchange and how the RAN exposes it.
Meng: For me, the main implication for deployment is that we can deploy this with confidence knowing we’re dealing with no measurable throughput penalty on the underlying OCUDU RAN.
Tom: And they also showed that achieving end-to-end latencies between one hundred fifteen and one hundred twenty microseconds, which keeps us well within the sub-millisecond budget for real-time use cases.
Jane: It’s a solid piece of work because it validates a specific technical approach for integrating intelligent applications into the radio layer. It sets a clear path forward for how we can evolve Open RAN intelligence.
Lu: They are moving toward an execution platform where dApps can inject logic dynamically into the RAN functions at runtime without needing to redeploy the core software.
Meng: I still see the deployment complexity in managing that dynamic injection, but it's a capability we need to track as we move toward these seven point two times deployments <ref:2609.03162#pg2>.
Tom: So that’s what this paper is about: bringing dApps to OCUDU with an E3 Controller for real-time intelligence. It’s a solid piece of work that proves the concept is viable in a production environment. Jane And we'll be ready for whatever comes next in the world of Open RAN research.
More episodes
- 2505.16254-Human-AI Writing as Distributed Cognition: Reassessing Collaborative Writing Theories in the Age of LLMs
- 2506.10913-Choreographic Quick Changes: First-Class Location (Set) Polymorphism
- 2507.14812-A Black-Box Approach for Exogenous Replenishment in Online Resource Allocation
- 2507.15448-Frames over finite fields with respect to the Galois inner product and their connections to self-orthogonal and LCD codes
- 2508.21572-NewsReX: An Open-Source Multi-Framework for Neural News Recommendation
- 2509.17028-Impact of Packetization on Network Calculus Analysis
- 2510.17342-AoA Services in 5G Networks: A Framework for Real-World Implementation and Systematic Testing
- 2511.04088-Efficient and rate-optimal list-decoding in the presence of minimal feedback
- 2511.17264-Notes on Stack Machines and Quantum Stack Machines
- 2601.15318-On the closest balanced game