Real-Time dApps for AI-RAN: Measured Interface Requirements for Inline PHY and Slot-Level Control Timothy O’Shea, Matthew Pennybacker, Andriy Kharchenko
arXiv:2609.07805v1 [cs.NI] 7 Sep 2026
DeepSig Inc., Arlington, VA, USA
channel. It is the right shape for spectrum sensing, interference detection, or integrated sensing and communication (ISAC), where a result 2 ms late is still useful and a dropped one is harmless. It is the wrong shape for two other kinds of work the AI-RAN literature also files under “dApp”: a neural channel estimator or receiver that must finish inside a PUSCH slot over tensors a GPU already holds, and a scheduling or linkadaptation decision the MAC is waiting on now. The first is not an observer at all but a stage, a replacement for a function in the pipeline, and for it the export is the cost. The second is a bounded call, and for it the process boundary is the risk. The OCUDU platform names these three contracts as classes: Class A, resident inline L1 work that runs on the PHY’s own stream; Class B, bounded real-time control that answers the MAC inside an admitted deadline; and Class C, asynchronous observation and advisory work whose producer never waits. The companion papers define the classes from a use-case corpus [8] and describe the embedded runtime that implements them inside the OCUDU DU [9]. This paper answers the question they leave open: why these interface mechanisms, at these costs, and why offer more than one. It measures the mechanisms the three public frameworks actually use, at the payload shapes the use cases produce, on the platform where the released runtime runs. Fig. 6 shows the outcome in one picture: one workload per class, each framework’s own path against the workload’s budget. Three findings carry the paper. First, 22 of the 39 runtime use cases in the audited corpus cannot cross the observer boundary, I. I NTRODUCTION 13 of them for a structural reason that no faster codec changes: The O-RAN application hierarchy has two established tiers. an indication carries data outward, and nothing brings a tensor rApps attach to the non-real-time RIC and act at management back into the same slot. Second, a process boundary inside a timescales of seconds and above; xApps attach to the near- 100 µs decision is fine on an idle host and not on the host that real-time RIC through E2 and close control loops between matters. Every carrier meets the Class B deadline on the quiet 10 ms and 1 s [1], [2]. Neither can observe or act on the state host; with the DU on the air, the same request over SCTP of a distributed unit (DU) within a slot, a few slots, or a loopback reaches 181 µs at P99.9 and over ZeroMQ 787 µs, frame. Distributed applications (dApps) were proposed to fill while the in-process validated call stays at 5.22 µs. Third, for that band [3], [4]: they run on the node that owns the data, the 17 asynchronous rows the observer boundary is the right consume observations that never leave it, and close loops below one, and what the in-process Class C positions add is not speed 10 ms. but accountability, bounded staleness with counted drops, and Every dApp framework published so far realizes that idea a path by which an observation reaches a per-slot decision the same way. The dApp is a separate process; the DU exports without a message. The paper contributes: an indication, the process computes, and a control message 1) a coupling spectrum for dApp interfaces with two comes back [4]–[7]. This is a tap: an observer with a reply legitimate ends, a tightly coupled C ABI inside the DU process and a protocol-standard out-of-process carrier * Preview version. This paper accompanies a preview release of the platform (E3AP over SCTP), on which the three classes are and its benchmark suite and will receive updates as the working group’s review, new use cases, and measurements land. positions and Class C spans three; Abstract—Distributed applications (dApps) bring AI to the microsecond-to-millisecond band beside the 5G distributed unit (DU), but every public dApp framework realizes them the same way: an external process that receives an indication and returns a control message. That boundary is right for sensing and advisory workloads. It cannot express a neural receiver that must finish inside a slot, and it cannot hold a scheduling decision the MAC is waiting on. This paper asks what a dApp interface must deliver, in latency and bandwidth, for the AI-RAN use cases now filed under that name to be realized as dApps at all. It treats the coupling between a dApp and the DU as a design axis with two legitimate ends, a C ABI inside the DU process and a protocol-standard E3AP association over SCTP, and places the three OCUDU dApp classes on it. An audited corpus of 39 runtime AI-RAN use cases, sized by 5G NR timing, shows that more than half cannot cross the observer boundary: inline PHY work because an indication has no return path into the same slot, and bounded control because of the tail under load. Measuring the mechanisms each framework actually uses, on a quiet host and with a live cell on the air, shows that every carrier meets a 100 µs control deadline on an idle host and that only the in-process paths still do once the DU is running. The asynchronous use cases remain feasible at every position, so the protocol-standard end is kept as a first-class option; what in-process placement adds for them is accountable staleness and an observation-to-decision path with no message on it. These measurements derive the released ABI, a stream for inline work, a validated call for bounded control, and a choice of lease, supervised ring, or portable E3 client for observation, and four dApps of all three classes are validated together on one over-the-air cell. Index Terms—AI-RAN, dApps, E3, O-RAN, OCUDU, GPU, ABI, SCTP, ASN.1, shared memory, real-time interfaces
2) an audited corpus of 39 runtime AI-RAN use cases with deadlines from 5G NR timing, byte counts at the live and envelope shapes, and a verdict on what an observer-only framework, a GPU-export framework, and an in-process ABI can each express; 3) measurements of the real mechanisms under one pinned harness with raw percentiles, on a quiet host and with the DU on the air: the asn1c APER E3AP codec and SCTP carrier, the OCUDU shared ring, SEQPACKET supervisor, and validated direct call, jBPF, and the ZeroMQ and device-to-host paths of the other frameworks; 4) a derivation of the released ABI from those measurements, including the case for keeping the protocolstandard end as a first-class Class C option and for the one position the spectrum admits but the platform does not ship; and 5) validation: four dApps of three classes composed on one over-the-air cell, with the runtime’s per-class checkpoints. Every number in the paper is produced by the accompanying suite or by the released runtime, every mechanism named is the one the runtime ships, and the suite, corpus, and raw traces are public in the study repository [10]. II. P RIOR F RAMEWORKS AND THE B OUNDARY T HEY A SSUME Three bodies of work define what a dApp is today; each is examined for the boundary it places between the DU and the application, because that boundary decides which use cases it can express at all. Northeastern dApp framework. Lacava et al. [4] pair an E3 agent embedded in OpenAirInterface with dApps that run as separate processes. Management uses E3AP, an ASN.1 service model compiled with asn1c in the E2 tradition, carried over ZeroMQ or TCP by default; the 2026 revision publishes the codec as a vendor-neutral library with SCTP among its link layers [11]. Data moves on a second plane: the agent publishes indications through ZeroMQ or a shared-memory reference, Python dApps subscribe, usually keeping only the newest message, and control actions return the same way to be applied at a safe point. The design is explicitly nonblocking; spectrum sharing, interference detection, and ISAC inference run on it [6], [12], [13], and jBPF has been evaluated as a verified in-process hook for small functions [14]. Boeira et al. [7] characterize the same framework’s performance: co-located containers add under 0.5 ms to a control loop and separated containers 1 to 2 ms, the CPU rather than the GPU saturates first, and about one core per dApp must be provisioned to keep a 10 ms loop. Those are loop-level figures over a Python data plane and an RF simulator; the present study measures the carriers and codecs beneath such a loop, at microsecond resolution, with a cell on the air. NVIDIA Aerial dApps. Villa et al. [5] add a dApp path to the CUDA-accelerated Aerial L1: a GPU-side export copies a slot’s IQ or channel-estimate tensor out of the PHY’s buffers to a second context, where an inference model runs and reports
through a host process, within a budget of a few milliseconds. Its defining property is an export that leaves the PHY’s own stream untouched. Vendor accelerators. Commercial L1 stacks expose configurable pipelines and, increasingly, neural components [15], [16], but in-pipeline replacement of a stage by third-party code is not a supported contract in any of them; the standard-compliant neural receiver of [17] ships as a vendor feature. The first two groups share two properties: the dApp lives outside the L1 process, and the L1 owns the clock, so the application sees a copy and replies when it can. These make the frameworks portable, restartable, and safe to write in Python, and they fix the set of use cases the frameworks can express: a tap can observe a stage but cannot replace one, so a neural equalizer cannot sit on the far side of an export, and a scheduler decision cannot be applied “at a safe point later” when the slot is now. OCUDU keeps the observer boundary, implements E3AP over SCTP with the same asn1c toolchain, and adds two positions on the coupling spectrum so that the rows the boundary cannot express have a home. III. T WO A XES , T HREE C LASSES , O NE S PECTRUM A. The Axes That Change the Interface For every use case in the corpus of Section IV, two properties decide the interface before any model is chosen. The blocking contract states who waits: in an inline contract the PHY cannot progress until the function returns; in a bounded contract the MAC or PHY control loop waits but has a conventional decision it can take at a deadline; in a nonblocking contract nobody waits and the result is consumed later or dropped. The payload residency states where the bytes are: grids, channel estimates, and LLRs are produced in GPU memory by the accelerated PHY [18] and stay there until the transport block is decoded; scheduler inputs are compact host structures the MAC already holds; spectrum windows and SRS responses are large and GPU-resident but read a few times per second. The three classes of [8] are the three non-empty combinations. Class A, Resident Inline L1, is inline over resident tensors; Class B, Bounded Real-Time Control, is bounded over compact host state; Class C, Asynchronous Observation and Advisory, is nonblocking over either. The missing combinations are the ones physics excludes: an inline contract over exported data pays a copy and a wake on the slot’s critical path, and a nonblocking contract over resident tensors is Class C with a lease. B. The Coupling Spectrum Fig. 1 presents the classes not as three boxes but as positions on one axis, the degree of coupling between the dApp and the DU, because that axis explains both the mechanism choices and the reason the platform keeps more than one. At the ABI-standard end the dApp is a shared object loaded into the DU process and bound to a frozen, size-tagged C interface; the DU passes device pointers, a CUDA stream, and a deadline, and the dApp writes into DU-owned buffers and returns, with nothing copied or serialized. The cost is trust: the module runs with the DU’s privileges and the ABI must not
change under it. Class A, Class B, and the in-process Class C live, 12 are design only, and 13 are out of scope for the released path live here. At the protocol-standard end the dApp is platform. The Appendix lists every row; the formulas and a process, a container, or a remote host that speaks a wire sources behind each are in the study repository [10]. Fig. 2 protocol. E3AP over SCTP is that protocol: the carrier the O- places every row against the two axes and the measured cost RAN E2 interface standardized [19], [20], one the Northeastern of the observer boundary. A verdict needs a definition of feasible. A row is feasible codec library supports, and the one several large vendors prefer for RAN control planes because their tooling, security posture, across a boundary when the measured P99.9 of the mechanism and conformance practice already exist for it. The cost is a that boundary uses, at the row’s byte count and with the DU codec and a kernel round trip per message; what it buys is on the air, is inside the row’s deadline; infeasible when a path vendor neutrality, language independence, crash isolation, and exists and that tail is outside it; and inexpressible when no placement wherever the operator’s security model requires. path returns the result into the consuming stage at all. The Between the ends sits the supervised position: a separate DU-on-air condition is the one that counts because a bounded process on the same host sharing memory with the DU, paying contract is defined by its tail under the load the DU itself creates (Section V-D). one copy and one wakeup for crash isolation and restart. Three facts carry the argument, and the verdicts behind them The rest of the paper uses a small vocabulary for the positions. A native dApp is a module in the DU process; for Class C use the byte and deadline arithmetic of the corpus tables and it reads a leased view, a zero-copy reference the DU refuses the measurements of Section V. Eleven of the 13 Class A rows to invalidate until the lease returns. A supervised dApp is a are inexpressible in either external framework, for a reason worker process on the same host fed through a shared-memory unrelated to speed: an indication carries data outward, and ring and restarted by the DU when it dies. A portable dApp is nothing brings a channel estimate, an equalized tensor, or an any E3 peer. The latest-context cache is a host-owned structure LLR tensor back into the PUSCH chain of the same slot; into which a Class C dApp publishes and from which a Class B the remaining two, PRACH detection and SRS estimation, call reads, so that an observation reaches a decision without a run rarely enough or on tensors small enough that they do not discriminate. Every Class B row has a return path in the message. Three consequences follow. The classes are not a ranking: observer-only framework, the E3 control action, and none in a position is right or wrong for a use case. Class C is not the export framework, which documents no decision-boundary “observer only”: its contract permits every position, and it closes hook; on the quiet host that return path fits the 100 µs budget, loops through the latest-context cache and through E3 control and with the DU on the air its tail does not (Section V-D), actions. And optionality is itself a requirement: a group already which is why Fig. 2 draws the boundary under both conditions. running Python dApps over E3 should be able to point them at Every Class C row is feasible in all three frameworks, which OCUDU unchanged, a vendor shipping a neural receiver needs is the case for keeping the protocol-standard end: for 17 of 39 the left end, and an operator with a hardened-container policy rows an out-of-process E3 client is a correct implementation, needs the right end for anything it did not write. Section V and removing it would trade portability for nothing. Table I lists the rows that most sharply separate the prices each position so the choice can be made per use case, and Section V-D prices the one combination the spectrum frameworks, with the mechanism each would have to use and its measured or published cost. Its Class C rows show where admits but the platform does not ship, a supervised Class B. the platform’s contribution lies once expressibility is settled: IV. T HE U SE -C ASE C ORPUS , AUDITED producer-side cost, survival across consumer restarts, and the The corpus of [8] listed 45 use cases drawn from the O- two return paths by which an observation re-enters control (the RAN nGRG report on dApps [21], the dApp literature [4]–[6], interference map consumed by the scheduler and the quiet[12], and AI-native PHY work. Every entry was re-examined period reservation admitted by a host authority) without a against the 5G NR timing that bounds it (a 500 µs slot at message on the decision path. 30 kHz, retransmission DCI after k2 ≥ N2 , SRS periods V. M EASURED I NTERFACE C OSTS of 5–40 ms, beam-failure timers of 10–200 ms), the bytes it moves at the released testbed shape (51 PRB, two receive ports) A. Method and at the 273-PRB, four-port envelope, and the contract the All rows were measured on one NVIDIA DGX Spark (GB10, released runtime offers. Rows mixing a per-slot half with a 20-core Arm host, coherent CPU–GPU memory) under two policy half were split, rows whose input the DU never sees conditions: quiet, with the host otherwise idle, and contention, or whose actuator sits inside the RU were moved out, and with the released OCUDU cell on the air on the same host ten rows the platform made possible, such as the observation- and sharing its GPU. The text and figures report the quiet run; to-avoidance composition, were added. The audited corpus Table II sets the two side by side for the rows the argument rests has 39 runtime rows (13 Class A, 9 Class B, 17 Class C), 9 on. Benchmarks ran pinned to the six cores the DU does not xApp/rApp rows acting through typed configuration or RAN use, with memory locked, a 10 % warmup, and raw nearest-rank control, one research row that needs a multi-DU substrate, and percentiles with no tail trimming; CLOCK_MONOTONIC above five compositions that flow only through host-owned caches and 1 µs and the cycle counter below it. Every CSV row carries its authorities. Of the runtime rows, 14 are shipped or demonstrated contract, placement, copies and system calls on the measured
ABI-standard end
Protocolstandard end
tight coupling, no copy, one process
loose coupling, wire format, any process
Class B Bounded RT Control
Class A Resident Inline L1 direct C ABI on the host CUDA stream pay: trust, ABI freeze get: 0 copies, slot deadline
direct call, validated intents, admitted deadline pay: validation, timeout get: 100 µs admitted loop
Class C inprocess
Class C supervised
leased views, latestcontext cache
shm ring + eventfd, SEQPACKET control, CUDA-IPC pool
pay: quiescence on unload get: no export, no wake
pay: 1 copy, 1 wake get: crash isolation, restart
Class C portable E3AP/APER over SCTP, FlatBuffers profile, container or remote host pay: codec, kernel, network get: vendor neutrality, E2 tooling
boundary used by prior dApp frameworks (observer with a reply channel)
Fig. 1. The coupling spectrum. The three classes are positions on one axis, and Class C spans three of them. Prior frameworks occupy the right-hand half; the left-hand positions are what make inline and current-slot use cases expressible. Each position states what the dApp author pays and what the placement buys. TABLE I D ISCRIMINATING ROWS OF THE AUDITED CORPUS . C OSTS ARE P50 UNLESS STATED ; meas. ROWS COME FROM THE SUITE IN S ECTION V OR FROM THE RELEASED RUNTIME , publ. FROM THE CITED PAPERS . “I NEXPRESSIBLE ” MEANS NO RETURN PATH INTO THE CONSUMING STAGE EXISTS . Row
Bytes, budget
Observer-only external (E3AP/SCTP External GPU pipeline (D2H or D2D OCUDU resident or bounded + msg. data plane) export) (in-process ABI)
A-03 neural receiver to LLRs
1.47 MB in, up to 4.4 MB out per slot; ≤500 µs occupancy
A-02 neural equalizer
68.5 KB in (live); same-invocation consumption
Inexpressible. For scale, a 734 KB indication costs 1.43 ms one way with the real APER codec over SCTP (meas.) Inexpressible
B-01 scheduler intents
≤4.2 KB in, ≤2.3 KB out; 100 µs to commit
B-04 avoidance from the C-01 map
≤275 B context; 100 µs to commit
C-01 spectrum sensing
137 KB (live) to 1.47 MB per slot; no deadline about 100 B intent; ≥1 slot ahead
C-02 quiet reservation
C-03 SRS-ISAC
Inexpressible. Export of 1.47 MB to host costs 73.5 µs before inference (meas.) Inexpressible
Infeasible under DU load: SCTP Inexpressible: no decision-boundary loopback round trip 15.6 µs P99.9 quiet, hook 181 µs with the DU on the air (meas.); about 400 µs in published loops Infeasible: the map is an indication, its Inexpressible consumption is the B-01 path
Feasible: 1.5 KB decimated indications in published loops; a full grid costs 1.68 ms one way (meas.) Feasible as an E3 control message; admission and duty bound absent from the published procedure set ≤210 KB per SRS Feasible: 255 µs one way at 64 KB occasion; ≤ SRS period (meas.)
Feasible: about 150 µs C API, 350 µs gRPC at 717 KB per slot (publ.) Inexpressible: no scheduler authority
Feasible: about 2.3 ms cuSense (publ.)
Feasible at the live shape: 81.6 µs / 112 µs P50 / P99.9 (meas.), 92.5 / 105.1 µs runtime checkpoint; 273-PRB kernels not yet qualified Feasible: 45–52 µs P50; 260,000+ invocations on air, 0 fallbacks Feasible: direct call 0.288 µs P99.9 quiet, 5.22 µs with the DU on the air, 20,000 validated calls (meas.); 3.6 µs on the runtime Feasible: latest-context cache, 3 bounded acquire attempts; demonstrated live Feasible on all 3 positions; producer critical section 2.34 µs P99.9, independent of the subscriber (meas.) Feasible: host reservation authority with clamp and duty budget; shipped Feasible: CUDA-IPC pool, 1 device-to-device snapshot; demonstrated live
path, and an evidence kind, measured or published baseline. Python dApps use; the NVIDIA-style rows use a device-to-host Where earlier drafts of this study modeled a cost, for example copy into pinned memory, a shared-memory hand-off, and a E3 as a fixed header plus a per-byte slope, the real mechanism ZeroMQ notification. Payloads are the corpus’s: 34 and 68 KB is now measured, and rows once labeled inter-process that ran for a 51-PRB slot as 16-bit and 32-bit complex, 734 KB and inside one process now fork. 1.47 MB for the 273-PRB, four-port envelope, 64 KB for an The mechanisms are the ones the frameworks ship. The SRS occasion, and a 16-candidate scheduler request of 3.2 KB E3 rows link the OCUDU asn1c APER codec and SCTP returning 1.2 KB of intents. transport from the SDK, with the message families and 64 KiB fragmentation of the E3AP wire contract, and the B. The Protocol-Standard End: APER and SCTP Northeastern libe3 codec beside it. The OCUDU inter-process Fig. 3 gives the cost of the protocol-standard end with rows use the released ring layout (128 B header, 64 B slot nothing modeled. The codec rows encode and decode real E3AP headers, 64 B-aligned stride, try-lock guard, eventfd signal) PDUs with the OCUDU asn1c APER codec: setup, subscription, and its SEQPACKET control channel with credential checks indications with bodies from 64 B to a fragmented 734 KB grid, on every message. The Northeastern-style rows use ZeroMQ a 2.2 KB scheduler control action, and an acknowledgment. publish/subscribe over ipc:// across a fork with the high- Two regimes appear. For control-sized messages the cost is the water mark and conflating-subscriber options that framework’s envelope, 2.27 µs to encode and 2.29 µs to decode a control
10
4
E3AP over SCTP, 2 pinned processes
Class A
live → max envelope
Class B Class C
E3 1-way P99.9, quiet E3 1-way P50, quiet
design only out of scope
E3 1-way P99.9, DU on air
srs.channel floor P50–P99.9 one way, P50 (encode → SCTP → reassemble → decode)
103
1 slot (500 µs)
102
Class B commit deadline (100 µs)
below a line: an E3 indication cannot arrive before the deadline on that host
102
103
104
105
107
106
delivery latency (µs)
deadline or freshness bound (µs)
105
23 frag.
request/response RTT/2, P50
10
3
12 frag.
1 slot
Class B commit deadline
102
101
bytes per invocation (live cell; line to 273-PRB envelope) 102
Fig. 2. The 39 runtime rows by bytes per invocation and deadline. Filled markers are shipped or live, hollow are design only, crosses are out of scope. The lines are the measured one-way delivery of an E3AP indication (APER over SCTP) on the quiet host, P99.9 solid black and P50 dashed, and with the DU on the air, P99.9 red; a row below a line cannot be served across that boundary within its deadline on that host. The Class B rows sit between the two lines, which is the whole Class B argument: the boundary fits on an idle host and not on the host the DU runs on. TABLE II T HE SAME ROWS UNDER THE TWO HOST CONDITIONS (µS ). Q UIET: HOST OTHERWISE IDLE . C ONTENTION : THE RELEASED CELL ON THE AIR ON THE SAME HOST, SHARING THE GPU, WITH THE BENCHMARK PINNED TO THE CORES THE DU DOES NOT USE . Quiet
Contention
Row
P50 P99.9 P50
A GPU-resident inline, 1.47 MB grid (floor) B direct ABI, validated call B same request over SCTP loopback C ring producer critical section, 68 KB C ring consumer wake, 68 KB C SEQPACKET control RTT/2, 256 B C E3AP indication 64 KB one way C E3AP control round trip
58 0.27 13 1.97 3.92 3.20 255 11
119 0.29 16 2.34 99 4.26 520 13
P99.9
13 801 0.27 5.22 13 181 1.97 167 4.91 1.62 ms 3.25 69 207 1.57 ms 12 492
action, independent of the few hundred bytes of body, and the Northeastern codec tracks it closely. For indications the cost grows linearly at 0.87 ns per byte because APER copies an OCTET STRING body bit-aligned: a 64 KB SRS indication costs 57.8 µs and a 734 KB grid 681 µs to encode, with decode near 0.97× the encode cost. The FlatBuffers data profile on the second association costs 42.1 µs to encode and 11.3 µs to decode for the same grid, which is why the platform has two associations. The carrier rows send those PDUs between two pinned processes over an SCTP one-to-one association on loopback, one PDU per message, fragmented at 64 KiB as the E3AP wire contract requires, and time one-way delivery through reassembly and decode. A 1.5 KB indication arrives in 10.5 µs at the median; the 734 KB grid, 12 fragments, in 1.43 ms (1.97 ms at P99.9); the 1.47 MB four-port grid in 1.68 ms. A control round trip on stream 0 with the real codec at both ends is 10.9 µs at the median and 12.6 µs at P99.9; the published loops of about 400 µs [4] sit between these compiled figures and the same path through a Python decoder. With the DU on
103
104
105
106
PDU body (B)
Fig. 3. The protocol-standard end, measured with the real codecs and carrier. One-way delivery of E3AP indications (asn1c APER encode, SCTP send, reassembly, decode) over an association between two pinned processes, and the control-plane request/response exchanges, against the deadlines that matter for each class. Codec costs alone are given in the text.
the air the medians barely move and the tails do: the 1.5 KB indication reaches 216 µs at P99.9, the 64 KB SRS indication 1.57 ms, and the control round trip 492 µs (Table II). These numbers draw the lines on the corpus map of Fig. 2. Every Class C row lies above both, most by an order of magnitude, so an E3 client is a correct implementation of all 17. Every Class A row lies below the quiet-host line, so even before the missing return path is counted the export alone does not fit. Every Class B row lies above the quiet-host line and below the DU-on-air line: the boundary fits the 100 µs budget on an idle machine and not on the machine the DU runs on. That is the whole case for the right-hand end: it costs nothing the asynchronous rows cannot afford, and no codec optimization moves the lines, because they are set by the copy, the wake, and the association. C. Class C Egress: The Producer Rule A Class C publisher runs on the PHY thread. Whatever the consumer does, the producer’s cost per slot must stay bounded and small, and the data the consumer eventually sees must have a known age. Fig. 4 tests both properties for the OCUDU positions and for the ZeroMQ publish/subscribe path of the observer frameworks, at the live 68 KB slot. The supervised ring is the released layout in a two-process harness: try-lock guard, reclaim read, memcpy into the next 64 B-aligned slot, release store, eventfd write, 3.0 system calls per publication. Its critical section costs 1.97 µs at the median for 68 KB and 23.9 µs for the 1.47 MB envelope, which is the memcpy; when the ring is full the producer returns in 0.144 µs with a counted drop and never waits. In the slot-timed run the producer publishes every 500 µs for 20,000 slots while the consumer either drains promptly or sleeps 5 ms on every 8th slot. With the sleeping consumer the ring drops 4457 slots across 1942 stalls, about two per stall, which is exactly the
excess of a 5 ms stall over an 8-slot ring, and the age of the shared the contested core); all still fit. With the DU on the air newest data the consumer sees is bounded at 3.15 ms median the picture changes: the direct call moves to 5.22 µs at P99.9 and 5.41 ms P99.9 by the ring depth. An unsubscribed stream and the SPSC to 16.8 µs, while the message paths move to costs the producer one relaxed atomic load, 0.032 µs P50, 181 µs (SCTP) and 787 µs (ZeroMQ) and miss the deadline 0.048 µs P99.9. on 0.35 % and 0.69 % of requests with the responder core ZeroMQ over ipc:// publishes the same 68 KB in 1.82 µs otherwise idle. APER encode and decode at both ends of the at the median, the same producer cost; the difference is what SCTP path add up to 22.2 µs at the median on the quiet host, happens to the data. With the default high-water mark the a floor for a compiled E3 control loop; the published loops socket queues everything a slow subscriber has not read, so of about 400 µs [4] include a Python decoder and the agent’s the age of the data it eventually sees grows to 981.95 ms at the data plane, and report no tails. median and 1045.61 ms at P99.9, with no drop reported; with The reading is not that ZeroMQ or SCTP are slow; on an the conflating subscriber option the Python dApps use, the idle host they would do. It is that a bounded contract is defined age stays at one slot but 10588 slots are discarded inside the by its tail under the load the DU itself creates, and the tail socket with no count anywhere. The ring is not faster than the of any path with a wake in it is then set by the kernel and socket; it is accountable: staleness is bounded by a configured by whatever else the DU runs. Nor is a miss free because the depth and every drop is counted, which is what an operator contract has a fallback. The conventional decision is taken at needs to know whether an advisory loop is still advising. On the deadline, but the MAC has already spent the wait, and the quiet host the ring producer’s P99.9 is 2.34 µs; with the a 787 µs tail is longer than the slot: the request outlives the DU on the air it is 167 µs, and the consumer’s wake tail grows decision it was for, the reply must be discarded on arrival, and from 99.4 µs to 1.62 ms (Table II), because the bench cores the intents for the next slot are computed from a context one then also carry DU worker threads and enter deep idle states slot stale. A miss rate of 0.35 % at three UEs on a 51-PRB cell between slots. is the floor of that cost, not its ceiling, since Boeira et al. [7] The SEQPACKET control channel, credentials verified on show the same framework’s CPU saturating before its GPU as every receive, completes a 256 B request/response in 3.20 µs dApps are added. at the median and 4.26 µs at P99.9 and a heartbeat in 3.06 µs, The busy-polling shared-memory SPSC deserves its own against 8.52 µs for ZeroMQ request/reply: the cost of noticing reading, because it is a process boundary that stays inside the a dead worker within one heartbeat and restarting it without budget under load, 16.8 µs at P99.9 with 0.04 % misses. It touching the ring. The consumer’s wake from eventfd to a is the supervised Class B position the spectrum admits: one leased slot is 3.92 µs at the median and 99.4 µs at P99.9. The copy of 3 KB, one copy of 1 KB back, crash isolation, and native lease costs the producer only the unsubscribed check. no wake, at the price of a core the responder must spin on and the DU therefore loses. The platform defines that position D. Class B: One Request, Six Boundaries as an alternative and does not ship it, for two reasons the The Class B question is whether a process boundary can measurements make concrete. The validation a Class B call sit inside a 100 µs decision. All six paths carry the same needs is the same on either side of the boundary, 72-byte intents request, a 16-candidate scheduler input of 3,240 B (the released range-checked field by field, so isolation buys protection against scheduler_input_v1 with two 275-bit masks) returning a crash but not against a wrong answer, and the circuit breaker 16 intents of 72 B. Each path invokes the same dApp function already bounds the crash. And the direct call is still an order through the released interface’s invoke pointer: a direct call; a of magnitude tighter, 5.22 µs against 16.8 µs, on a budget that heap SPSC pair between two pinned threads; a shared-memory the feature block and commit also have to share. The one path SPSC across a fork; ZeroMQ request/reply over ipc:// and whose tail stays inside the budget on the host that matters again over TCP loopback; and an SCTP one-to-one association without reserving a core is the direct call; the price, validating on loopback with real message boundaries, the carrier an E3 72 B intents, is small (Section VI). control action would use. The direct call is timed with the DU’s admission checks included, which cover structure size E. jBPF: A Verified Hook, and Why It Was Not Adopted and ABI major, candidate identity, allow flags, PRB range, jBPF [14] runs verifier-checked codelets inside the DU at MCS bound, and deadline. Each path runs 20,000 requests on named hooks, the one prior mechanism that is not an observer separate pinned cores under three conditions: the quiet host, with a reply channel, and the suite measures it as shipped. the quiet host with a 50 µs-on, 50 µs-off busy thread on the The hook is cheap, 1.54 µs for a 64 B context and 2.61 µs for responder’s core, and the host with the DU on the air. 16 KB, rising to 95.4 µs for a 1.47 MB grid the codelet must Fig. 5 shows the result. On the quiet host every carrier meets read in full. The limit is what the codelet can do with its result: the deadline: the direct call completes in 0.272 µs at the median its output goes into jBPF’s own ring, which an I/O thread and 0.288 µs at P99.9 with validation included, the shared- drains for a consumer, so a request/response through the hook memory SPSC in 0.784 µs and 0.944 µs, SCTP in 13.1 µs and costs 152 µs at the median, set by that thread’s polling interval, 15.6 µs, ZeroMQ over ipc:// in 18.0 µs and 21.3 µs. The and in every published use the consumer is an external process, antagonist adds about 50 µs to every tail (65.8 µs for SCTP, so the tap adds a copy into the ring before the copy across 73.4 µs for ZeroMQ, 53.2 µs for the direct call, whose caller the boundary. The verifier also excludes device pointers and
what the dApp sees
P50
103
unsubscribed stream: 1 atomic load (P99.9) P99.9, prompt subscriber P99.9, subscriber sleeps 5 ms every 8th slot
102 10
1
100 10−1 OCUDU ring 8 slots
ZMQ PUB/SUB HWM 1000
age of data at the consumer (µs)
producer cost per slot (µs)
on the PHY thread
ZMQ PUB/SUB conflate
4457 dropped (counted) 0 dropped
2877 dropped (silent)
0 dropped
10588 dropped (silent)
13 dropped (silent)
105 104 ring depth × slot = 4 ms 103 102 101 100 OCUDU ring 8 slots
ZMQ PUB/SUB HWM 1000
ZMQ PUB/SUB conflate
Fig. 4. Producer-side cost per 68 KB slot publication, P50 (tick) and P99.9 (bar), with a prompt subscriber and with a subscriber that sleeps 5 ms every 8th slot. The OCUDU ring’s producer cost does not move; a full ring is a counted drop. ZeroMQ’s producer inherits the subscriber’s backlog. 100 µs deadline
OCUDU direct ABI (validated call) SPSC queue, 2 threads SPSC shm, 2 processes SCTP loopback (E3-style RT) ZeroMQ REQ/REP ipc:// ZeroMQ REQ/REP tcp loopback 10−1
100
101
102
103
request → validated intents (µs); 20,000 requests per path P50
P99.9, quiet host, 50 µs antagonist on responder core
P99.9, quiet host
P99.9, DU on the air on the same host
Fig. 5. One Class B request (3.2 KB in, 1.2 KB of intents out) over six boundaries, 20,000 requests each, under three host conditions. Bars are P99.9, ticks are P50; the dashed line is the admitted deadline. On the quiet host every path fits; with the DU on the air only the paths without a wake keep their tails.
CUDA calls, which Class A needs, and bounds the loops a scheduler policy would write. The platform therefore keeps jBPF as an evaluated option for tiny Class B taps and adopts, for the same contract, a direct call whose output lands in the caller’s structure and is validated field by field, with no ring, no I/O thread, and no second copy. F. Class A: What an Export Costs Before the Model Runs The Class A rows are inexpressible on an external boundary for the structural reason of Section IV, so the measurement answers a narrower question: were a framework extended with a return path, what would the export alone cost before any inference ran? On the coherent-memory host a device-to-host copy of a 1 MB grid into pinned memory takes 73.5 µs at the median and 80.6 µs at P99. The full NVIDIA-style path (copy, shared-memory stage, ZeroMQ notification) takes 224 µs at the median and 306 µs at P99 for the 1.47 MB four-port grid, against a 300 µs planning budget. Both paths measure the outbound leg alone. A stage needs the result back, so the round
trip is at least twice the outbound figure, about 450 µs at the median for the NVIDIA-style path before a single model FLOP, and no framework provides the return copy. The in-process figure is the cost of enqueueing the dApp’s kernels on the lane’s stream and recording the completion event, measured with the released packages on the exclusive GPU. At the live shape (51 PRB, two layers, 256-QAM), the channel estimator submits in 19.9 µs at the median and the reference receiver completes in 81.6 µs / 112 µs P50 / P99.9, inside its 150 µs qualification deadline. At the 273-PRB envelope the same receiver submits in 45.9 µs but completes in 272 µs / 523 µs, so the reference kernels, not the interface, are what remains to be qualified at that shape. The framework-path suite shows the same thing at every payload from 256 KB to 23 MB: residency costs a launch, export costs a copy proportional to the tensor, and at the 64-port envelope the copy alone (about 17.4 ms at the measured 11 Gb/s device-to-host rate at 23.5 MB) exceeds the slot. G. The Frameworks at Matched Contracts Fig. 6 closes the section by putting the frameworks side by side under the harness above. For each of three workloads, one per class, the figure shows the median and P99.9 of each framework’s path at the workload’s byte count against its budget; published anchors from the cited papers appear as marks without percentiles. The picture is the one the corpus predicted. On the Class A workload only the resident path is inside the budget, and the other frameworks’ paths are shown hatched because they are outside their authors’ stated scope. On the Class B workload the resident path is more than two orders of magnitude inside the budget and the observer path is outside it. On the Class C workload all three are inside the budget by a wide margin, and the differences among them are the producer-side and restart properties measured above rather than feasibility. VI. D ESIGN C ONSEQUENCES : T HE R ELEASED ABI Each mechanism in the released runtime [9] can now be stated as a consequence of a measurement in Section V and a
10
budget 300 µs
103
103
102
102
101
101
100
100
10−1
10−1
−2
−2
10
10 OCUDU resident inline
Class C: spectrum window, 320 KB, one way
10
10
103
Class B: scheduler request → intents
4
budget 100 µs
OCUDU direct ABI validated
NEU ZMQ REQ/REP ipc, no codec
budget 5,000 µs
102
100 10−1 10
NEU NVIDIA ZMQ 1-way D2H+shm+ZMQ no return no return
4
101
inexpressible
latency (µs); tick P50, bar P99.9
Class A: 4-port PUSCH grid, 1.47 MB, inline 4
NVIDIA no hook
outside published scope published anchor
−2
OCUDU NEU NVIDIA shm ring ZMQ PUB/SUB D2H+shm fork, 1 copy +E3 encode +ZMQ
Fig. 6. Contract-matched framework paths, one workload per class, P50 (tick) and P99.9 (bar) against the workload budget (dashed). Hatched bars are outside the framework’s published scope and are shown as sensitivity only; marks without bars are published anchors.
DU process, frozen size-tagged C ABI Class A module same CUDA stream, device pointers, completion event invoke, grant checked
conventional stage armed as fallback DU-owned outputs
any process, any host UL grid (GPU)
EQ
CE
demap
LDPC Class C portable Python, container, or remote host observe over streams; FlatBuffers / SCTP (data assoc.) act over E3AP
E3AP APER / SCTP (mgmt. assoc.)
capture candidates
MAC scheduler decision boundary validated intents
slot publisher try-lock + eventfd
lease
latest-context cache interference map, 3 bounded acquires
Class B module direct call, 100 µs deadline
Class C native leased view, 0 copies
publish result
worker process, same host shm ring 128 B header, 64 B slot headers
Class C supervised CUDA-IPC pool, restartable
1 copy + 1 eventfd write; full ring = counted drop manages every class off the hot path
embedded E3 agent lifecycle, config, model slots, streams, RAN control
supervise, restart
SEQPACKET control credentials, heartbeat
Fig. 7. The three classes inside and around the OCUDU DU. Class A is invoked on the PUSCH lane’s own stream and writes DU-owned outputs; Class B is a direct call at the scheduler’s decision boundary returning validated intents; Class C has three positions: a leased in-process view, a supervised worker fed by a shared ring, and a portable E3 client over SCTP. Observations re-enter control only through host-owned caches and authorities, and one embedded E3 agent manages every class off the hot path.
row class in Section IV. Table III summarizes; the text gives the reasoning.
frozen and size-tagged, so a stale module is rejected at load, and the grant shape is checked against the module’s declared admission profile before any module code runs.
A. Class A: A Stream, Not a Message The inline rows have 50–300 µs budgets over 68 KB to several MB of GPU-resident tensors, and Section V-F shows that any path leaving the PHY’s stream exceeds the budget before a single model FLOP runs. The only admissible mechanism is enqueue on the PHY’s own stream: the ABI passes a cudaStream_t and device pointers, the DU records a completion event behind the dApp’s work and keeps its conventional stage armed if the event has not fired by the deadline. Because the dApp is inside the process, the ABI is
B. Class B: A Call With a Contract The bounded rows exchange kilobytes and wait for the answer, and Section V-D shows that every process boundary with a wake in it, however carried, moves the P99.9 from single microseconds to hundreds and adds misses at 100 µs once the DU is on the air. A direct call has no such tail, so the ABI uses one and spends the saved budget on what a boundary would have provided: every intent is range-checked against the cell’s PRB count, MCS table, and the operator’s allow flags,
TABLE III M ECHANISM ADOPTED PER CLASS , THE MEASUREMENT THAT JUSTIFIES IT, AND WHAT THE ALTERNATIVE WOULD HAVE COST ON THE SAME HOST. C OSTS ARE P99.9 UNLESS STATED . Class
Adopted mechanism
Measured cost of the adopted mechanism
Cheapest rejected alternative, and why
A
Direct C ABI on the lane’s CUDA stream; device pointers in, DU-owned buffers out; CUDA-event completion; grant shape checked against the declared admission profile Direct call at the decision boundary; intents range-checked and allow-flagged; deadline in the request, checked at commit; circuit breaker after 8 failures Leased zero-copy views; latest-context cache with 3 bounded acquires Shared ring: try-lock, reclaim read, 1 memcpy, release store, eventfd; full ring is a counted drop; SEQPACKET control with credentials; CUDA-IPC pool for device payloads E3AP over SCTP, APER via asn1c; FlatBuffers data profile on a second SCTP association; credentialed local socket
submit 19.9 µs P50, 27.7 µs P99.9 (estimator, live shape); receiver at the live shape 81.6 µs / 112 µs (P50 / P99.9)
Device-to-host export: 80.6 µs P99 at 1 MB before inference, plus a wake and a return copy no framework provides
B
C native C supervised
C portable
0.288 µs over 20,000 validated calls (quiet), 5.22 µs with the DU on the air; Same request over SCTP loopback: 3.6 µs on the runtime 15.6 µs quiet, 181 µs with the DU on the air; ZeroMQ ipc://: 21.3 µs and 787 µs Idle stream: 1 atomic load, 0.048 µs P99.9; context acquire 48 ns P50, 0.27 µs P99.9 Producer at 68 KB: 2.34 µs, full-ring return 0.144 µs (full ring, counted drop); consumer wake 3.92 µs P50; control round trip 3.20 µs P50 (RTT/2)
A copy per subscriber (the ring’s 2.34 µs), paid only when isolation is wanted ZeroMQ PUB/SUB at 68 KB: producer 3.14 µs P99.9; a slow subscriber’s data ages to 981.95 ms; conflation drops silently
Control round trip 10.9 µs P50 (RTT/2); 64 KB indication 255 µs one way; None rejected: kept because 17 of 39 rows 1.47 MB grid 1.68 ms one way fit it and E2 tooling exists for it
the deadline travels in the request and is checked at commit, and a circuit breaker removes a module after eight recoverable failures. That suffices because the outputs are 72 B each and fully validatable, and it is why the verified-hook alternative of Section V-E was evaluated and not adopted, and why the supervised Class B position of Section V-D, which fits the budget only by spinning on a reserved core, is defined but not shipped.
C. Class C: Three Positions, One Producer Rule The nonblocking rows tolerate milliseconds but their producer does not: the thread publishing a spectrum grid is on the slot’s critical path. Section V-C shows that producer cost and accountable staleness, not consumer latency, are the constraints, and each Class C position follows from them. Leased views cost the producer an atomic load when idle and a reference count when subscribed; the DU refuses to unload a module until its leases return, the quiescence proof of [9]. The supervised process costs the producer a try-lock, a reclaim read, one memcpy, and a release store on a shared ring, plus one eventfd write to wake the worker. A full ring returns immediately as a counted drop, so staleness is bounded by the ring depth and every loss is visible. Control travels on a SEQPACKET socket with credentials verified per message, so a dead worker is detected within one heartbeat and restarted without touching the ring. GPU payloads use a CUDA-IPC pool. Portable E3 is the protocol-standard end: its measured costs (Section V-B) are inside every Class C budget, so it is a legitimate choice for all 17 rows and the only choice outside the host’s trust domain. The platform ships it with the same asn1c toolchain and message families as the Northeastern agent, plus a FlatBuffers profile for bulk streams on a second SCTP association with its own
port.1 D. Closing the Loop Without a Message The reason Class C needs in-process positions at all is not speed, since Section V-C shows the ring and the socket cost the producer the same. It is the return path. An observation made by a Class C dApp re-enters control in one of two ways. Through the protocol-standard end it is an indication out and a control action back, 255 µs one way for a 64 KB body on the quiet host and 1.57 ms with the DU on the air, plus 492 µs for the action, and the action is applied at a safe point after the slot that produced the observation. Through the latest-context cache it is a publish into a host-owned structure and a bounded acquire by the next Class B call, 48 ns P50, 0.27 µs P99.9, inside that call’s 100 µs budget. The interference map of the spectrum dApp reaching the scheduler’s avoidance mask is the shipped instance, and it is the only row in the corpus in which an observation changes a per-slot decision with no message on the decision path. An observer-only framework can implement the observation and the control action; it cannot implement the cache, because the cache lives on the consuming side of the boundary. Supporting three positions costs the platform three egress implementations behind one publish call and the dApp author nothing: the package declares its position, and the price of looser coupling (Table III) is paid only by the dApp that chose it. VII. VALIDATION ON THE R ELEASED P LATFORM The mechanisms of Section VI ship in the public OCUDU dApp platform and SDK [22], [23]. Table IV places the runtime’s own per-class checkpoints beside this study’s measurement of the same mechanism on the same host, so the 1 The preview release’s default port numbers for the two associations, 36423 and 38472, are IANA assignments to the 3GPP SLm and F1 control planes respectively, and the F1 collision matters on a host that also runs a CU. The ports are configuration keys and the defaults are being reassigned; the paper therefore refers to the associations by role rather than by number.
TABLE IV RUNTIME CHECKPOINTS AND THE CORRESPONDING SUITE MEASUREMENT. RUNTIME COLUMN : THE PLATFORM ’ S OWN BENCHMARK BINARIES RUN ON THIS HOST FOR THIS STUDY, EXCEPT THE 92.5 / 105.1 µ S , 45–52 µ S , 3.6 µS , AND 0.87 G B / S FIGURES , WHICH ARE FROM THE RELEASE QUALIFICATION . S UITE COLUMN : THIS STUDY, CELL STOPPED , GPU EXCLUSIVE . Class Mechanism A A A A B B C C
All
Runtime
Suite
Receiver completion at the live 92.5 / 105.1 µs 81.6 µs / 112 µs shape (51 PRB, 2 layers, 256-QAM), P50 / P99.9 Receiver completion at 273 PRB, 2 — 272 µs / 523 µs layers, P50 / P99.9 (150 µs deadline) Estimator submit on the lane’s — 19.9 µs / 27.7 µs stream, live shape, P50 / P99.9 Equalizer, live cell, P50 45–52 µs — Direct call P99.9 (runtime: worst 3.6 µs 0.288 µs profile, 9,000 calls; suite: 20,000 validated calls) Latest-context acquire and release, 48 ns / 0.27 µs — P50 / P99.9 Export across forced restarts; suite: 0.87 Gb/s 2.05 µs / 3.89 µs ring producer per slot E3AP round trip: runtime 13.0 µs / 10.9 µs / 11.9 µs get-config (local socket) P50 / P99; (RTT/2) 51.7 µs suite: control action over SCTP 4 dApps, 3 classes, 1 OTA cell
260,000+ inv., 0 fallbacks
microbenchmark and the production number can be compared directly; the reference receiver’s earlier 92.5 µs figure is reproduced at the live shape and, as Section V-F shows, does not yet extend to the 273-PRB kernels. The composition run in the last row is the practical test of the argument: four dApps from three classes, built out of tree against the installed SDK, loaded through one E3 agent onto one over-the-air n78 cell (GB10 host, USRP B210, 51 PRB, 30 kHz TDD) with three live UEs. The Class A equalizer replaced the conventional stage for every PUSCH grant, the Class B scheduler returned validated intents at every decision boundary, the Class C spectrum and SRSISAC dApps published at producer rate, one in-process and one as a supervised CUDA worker through the CUDA-IPC pool, and a Python E3 client subscribed to the same cell over SCTP from outside the process. The spectrum dApp’s interference map reached the scheduler through the latest-context cache, the observation-to-control loop of Section VI-D that no observeronly boundary closes inside the slot. VIII. L IMITATIONS All measurements come from one host, an NVIDIA DGX Spark with a GB10 GPU and coherent CPU–GPU memory. On a PCIe-attached GPU the device-to-host rows move by the bus latency and the Class A argument only strengthens; the host-side rows should transfer with the usual caveat that tails depend on kernel configuration and isolation. Both host conditions are archived as raw traces. The DU-on-air condition is one cell at 51 PRB with three UEs, and the benchmarks ran on six cores the DU does not use. That is a light load and a generous placement: a production supervised worker would share cores with the DU, more UEs would lengthen the DU’s own bursts, and both move the
message-path tails the wrong way. The contention figures are therefore a floor for the cost of a boundary, not an estimate of it. The E3 rows measure the codec and the loopback carrier. A cross-host SCTP association adds network latency that depends entirely on the operator’s fabric and is out of scope here. The 273-PRB/four-port rows are the same code at the envelope size and were not exercised over the air. Class A is functionally resident and its interface cost is measured, but the reference receiver meets its deadline only at the live shape; the 273-PRB kernels are not yet qualified. Finally, the corpus verdicts are engineering judgments backed by byte and deadline arithmetic; a framework that adds an in-process position would move rows across the line, which is the point of the argument. IX. C ONCLUSION The dApp tier was born as an observer with a reply channel, and for the sensing and advisory use cases that motivated it that boundary remains right. The audit here shows that more than half of the AI-RAN use cases now filed under the same label cannot cross it, for reasons of arithmetic: a copy and a wake on a slot’s critical path, or a process hop inside a 100 µs decision, exceed the budget before the model runs, and the second of these is invisible on an idle host. Measuring the mechanisms the three public frameworks actually use prices each position on the coupling spectrum, and those prices derive the released ABI: a stream for Class A, a validated call for Class B, and for Class C a per-use-case choice among a lease, a supervised ring, and a protocol-standard E3 association. Three recommendations follow for the groups now shaping the dApp definition. First, a dApp specification should carry the blocking contract and the payload residency as first-class attributes of a use case, because they decide the interface before any model does, and a definition that names only the observer contract excludes 22 of the 39 use cases the community has already proposed. Second, E3AP should remain the common management plane for every class, so that lifecycle, subscription, and control look the same to an operator whether the dApp is a shared object or a container, and so that existing E3 dApps run unchanged; the classes differ in their data path, not in how they are managed. Third, the in-process position needs an ABI that is frozen, size-tagged, admission-checked, and validated at the boundary, because that is what replaces the isolation a process would have given; the released OCUDU interface is offered as one candidate, and the benchmark suite as the way to price any other. The released platform composes all three classes on one cell and records the checkpoints that let the argument be re-run. AVAILABILITY AND ACKNOWLEDGMENT The benchmark suite, corpus, raw CSVs, and this paper’s sources accompany the released platform, SDK, and quickstart images, public under the OCUDU WG2 AI-RAN group [22]– [24]. This work is supported by the U.S. Department of Defense
(DoD) Office of the Under Secretary of Defense for Research and Engineering (OUSD(R&E)) FutureG Office. R EFERENCES [1] O-RAN Alliance, “O-RAN architecture description,” O-RAN Alliance, Tech. Rep. O-RAN.WG1.O-RAN-Architecture-Description-v11.00, 2024. [2] M. Polese, L. Bonati, S. D’Oro, S. Basagni, and T. Melodia, “Understanding O-RAN: Architecture, interfaces, algorithms, security, and research challenges,” IEEE Communications Surveys & Tutorials, vol. 25, no. 2, pp. 1376–1411, 2023. [3] S. D’Oro, M. Polese, L. Bonati, H. Cheng, and T. Melodia, “dApps: Distributed applications for real-time inference and control in O-RAN,” IEEE Communications Magazine, 2022, arXiv:2203.02370. [4] A. Lacava, L. Bonati, N. Mohamadi, R. Gangula, F. Kaltenberger, P. Johari, S. D’Oro, F. Cuomo, M. Polese, and T. Melodia, “dApps: Enabling real-time AI-based open RAN control,” Computer Networks, vol. 269, p. 111342, 2025, arXiv:2501.16502. [5] D. Villa, M. Belgiovine, N. Hedberg, M. Polese, C. Dick, and T. Melodia, “Programmable and GPU-accelerated edge inference for real-time ISAC on NVIDIA Aerial testbed,” arXiv preprint arXiv:2512.06493, 2026. [6] N. N. Santhi, D. Villa, M. Polese, and T. Melodia, “InterfO-RAN: Realtime in-band cellular uplink interference detection with GPU-accelerated dApps,” arXiv preprint arXiv:2507.23177, 2025. [7] C. Boeira, E. Baena, A. Lacava, T. Melodia, D. Koutsonikolas, and I. Haque, “Performance characterization of dApps in open radio access networks,” arXiv preprint arXiv:2605.05426, 2026. [8] M. Pennybacker, T. O’Shea, and A. Kharchenko, “Three classes of real-time AI-RAN dApps: Use-case and benchmark evidence for an expanded dApp definition,” Companion paper, https://gitlab.com/ocudu/ work_groups/wg2_ai_ran/use_case_studies, 2026. [9] ——, “An embedded dApp runtime for the OCUDU 5G NR DU: Architecture for resident inline, bounded control, and asynchronous AI-RAN applications,” Companion paper, https://gitlab.com/ocudu/work_ groups/wg2_ai_ran/use_case_studies, 2026. [10] OCUDU WG2 AI-RAN, “dApp interface study: Benchmark suite, audited use-case corpus, raw traces, and paper sources,” https://gitlab.com/ocudu/ work_groups/wg2_ai_ran/use_case_studies, 2026. [11] WiNES Lab, “libe3: Vendor-neutral E3AP C++ library,” GitHub repository, 2026. [Online]. Available: https://github.com/wineslab/libe3 [12] R. Gangula, A. Lacava, M. Polese, S. D’Oro, L. Bonati, F. Kaltenberger, P. Johari, and T. Melodia, “Listen-while-talking: Toward dApp-based real-time spectrum sharing in O-RAN,” arXiv preprint arXiv:2407.05027, 2024. [13] M. Polese, R. Gangula, and T. Melodia, “Enabling programmable inference and ISAC at the 6GR edge with dApps,” arXiv preprint arXiv:2603.29146, 2026. [14] Microsoft, “jBPF: A userspace eBPF instrumentation framework for telecom applications,” https://github.com/microsoft/jbpf, 2024. [15] NVIDIA, “Aerial CUDA-accelerated RAN,” https://docs.nvidia.com/ aerial/, 2024. [16] K. Cohen-Arazi, M. Roe, Z. Hu, R. Chavan, A. Ptasznik, J. Lin, J. Morais, J. Boccuzzi, and T. Balercia, “NVIDIA AI Aerial: AI-native wireless communications,” arXiv preprint arXiv:2510.01533, 2025. [17] R. Wiesmayr, C. Dick, J. Hoydis, and S. Cammerer, “Design of a standard-compliant real-time neural receiver for 5G NR,” arXiv preprint arXiv:2409.02912, 2024. [18] M. Pennybacker, W. Liu, A. Kharchenko, and T. O’Shea, “GPU-resident CUDA acceleration for OCUDU 5G PHY and O-RAN fronthaul: Architecture and preliminary performance,” arXiv preprint arXiv:2608.04338, 2026. [19] O-RAN Alliance, “O-RAN near-real-time RAN intelligent controller, E2 general aspects and principles (E2GAP),” O-RAN Alliance, Tech. Rep. O-RAN.WG3.E2GAP, 2024. [20] R. Stewart, “Stream control transmission protocol,” IETF, Tech. Rep. RFC 4960, 2007. [Online]. Available: https://www.rfc-editor.org/rfc/rfc4960 [21] O-RAN Alliance nGRG, “dApps for real-time RAN control: Use cases and requirements,” O-RAN Alliance, Tech. Rep. RR-2024-10, Oct. 2024. [22] OCUDU WG2 AI-RAN, “ocudu-dapp-platform,” https://gitlab.com/ ocudu/work_groups/wg2_ai_ran/ocudu-dapp-platform, 2026. [23] ——, “ocudu-dapp-sdk,” https://gitlab.com/ocudu/work_groups/wg2_ai_ ran/ocudu-dapp-sdk, 2026. [24] ——, “ocudu-dapp-quickstart,” https://gitlab.com/ocudu/work_groups/ wg2_ai_ran/ocudu-dapp-quickstart, 2026.
A PPENDIX T HE AUDITED U SE -C ASE C ORPUS TABLE V RUNTIME ROWS OF THE AUDITED CORPUS ( IDENTIFIERS ARE THE ONES USED IN THE TEXT ). B YTES ARE PER INVOCATION AT THE LIVE 51-PRB, 2- PORT CELL AND AT THE 273-PRB, 4- PORT ENVELOPE (64 PORTS FOR A-04). V ERDICTS FOR THE OBSERVER - ONLY BOUNDARY (E3 INDICATION OUT, CONTROL ACTION BACK ) AND THE GPU- EXPORT BOUNDARY ( COPY INTO A SECOND CONTEXT ): inexpr., NO RETURN PATH INTO THE CONSUMING STAGE ; infeas., A PATH EXISTS AND ITS MEASURED P99.9 WITH THE DU ON THE AIR EXCEEDS THE BUDGET ( ON THE QUIET HOST THE SAME PATH FITS ); feas., FITS ; weak, THE ROW DOES NOT DISCRIMINATE . S TATUS IS ON THE RELEASED PLATFORM . ID
Use case
Class
A-01 A-02 A-03 A-04 A-05
Neural channel estimation Neural equalization (CE included) Neural receiver to soft LLRs Large-MIMO PUSCH at 64 rx ports Joint neural EQ and FEC decoding
A A A A A
67 KB 67 KB 67 KB 11.7 MB 176 KB
1.4 MB 1.4 MB 1.4 MB 22.4 MB 4.4 MB
A-06 A-07 A-08 A-09 A-10 A-11 A-12 A-13
Neural PRACH detection Neural SRS channel estimation Inline neural precoding PAPR reduction and neural DPD ISAC waveform and beam writeback Two-sided learned modem OTFS and Zak-OTFS air interface Semantic joint source-channel coding
A A A A A A A A
13 KB 5 KB 68 KB 60 KB 68 KB 68 KB 68 KB 68 KB
3.9 MB 210 KB 2.1 MB 240 KB 2.1 MB 1.4 MB 1.4 MB 1.4 MB
Scheduler intents Uplink power control (TPC) Link adaptation and MCS Interference-aware PRB avoidance Per-slot slice enforcement Subband mute for SBFD / dynamic TDD B-07 Beam selection at the decision boundary B-08 Security-gated forbid B-09 Layer reduction for energy
B B B B B B
512 B 64 B 512 B 275 B 512 B 275 B
4 KB 64 B 4 KB 275 B 4 KB 275 B
B
10 KB
B B
64 B 512 B
C-01 Spectrum sensing and interference map C-02 Quiet-period reservation / DSS windows C-03 SRS-ISAC feature extraction C-04 CSI prediction C-05 Advisory beam prediction C-06 Beam failure prediction C-07 Positioning and channel charting C-08 Positioning measurement enhancement C-09 Joint sensing and positioning C-10 RF fingerprinting C-11 Physical-layer security detection C-12 Codebook and beam-weight optimisation C-13 CSI feedback reconstruction C-14 Inter-cell interference coordination advisory C-15 RIS advisory C-16 RF gain policy C-17 Portable external observer
C
134 KB
C
100 B
C C C C C C
5 KB 5 KB 10 KB 1 KB 5 KB 5 KB
210 KB 210 KB 10 KB 1 KB 210 KB 210 KB
C C C C
5 KB 134 KB 134 KB 5 KB
210 KB 2.9 MB 1.4 MB 210 KB
C C
1 KB 275 B
C C C
100 KB 1 KB 134 KB
B-01 B-02 B-03 B-04 B-05 B-06
Live
Max Deadline / freshness
Observer-only
GPU export
OCUDU status
100 µs goal; 800 µs wall 100 µs goal; 800 µs wall 150 µs goal; 2 ms wall 1 UL slot occupancy 300 µs; soft buffer host-owned 1–2 ms per occasion SRS period 5–40 ms DL slot; 100 µs goal per symbol (35.7 µs) DL slot 50–300 µs per allocation 100–500 µs per allocation 50–300 µs per allocation
inexpr. inexpr. inexpr. inexpr. inexpr.
inexpr. inexpr. inexpr. inexpr. inexpr.
shipped (0x00010003) 45–52 µs P50 live; 260k+ inv. 92.5 / 105.1 µs P50 / P99.9 proxy 453 µs P50, 1.4 ms P99 out of scope (HARQ buffer)
weak (rate) weak (size) inexpr. inexpr. inexpr. inexpr. inexpr. inexpr.
weak weak inexpr. inexpr. inexpr. inexpr. inexpr. inexpr.
design only (no PRACH seam) design only as A; C path shipped out of scope (no DL seam) RU-seam plugin path (vendor id) out of scope (sensing half is C-02) out of scope (UE pairing) out of scope out of scope (DL seam; paired UE model)
100 µs to commit 100 µs (shared) 100 µs (shared) 100 µs to commit 100 µs (shared) 100 µs (shared)
infeas. (on air) infeas. infeas. infeas. infeas. infeas.
inexpr. inexpr. inexpr. inexpr. inexpr. inexpr.
10 KB 100 µs (shared)
infeas.
inexpr.
3.6 µs P99.9 runtime; 5.2 µs suite shipped (TPC field) shipped (OLLA reference) demonstrated live (K-01) shipped (fields + envelope) mask path shipped; host support open output defined; input context absent
64 B 100 µs (shared) 4 KB 100 µs (layers)
infeas. infeas.
inexpr. inexpr.
design only nof_layers intent; gain via C-16
feas.
3 positions; 0.87 Gb/s across restarts
1.4 MB 0.5–10 ms; per captured slot feas. (decimated) 100 B ≥ 1 slot ahead
feas. (no admission) inexpr.
shipped (reservation authority)
≤ SRS period 1–10 ms; ≥ 5 ms over E3 ≤ 1 slot native; 5–20 ms E3 10–200 ms timer 10 ms–1 s 1–20 ms
feas. feas. feas. feas. feas. feas.
feas. feas. feas. feas. feas. feas.
live (CUDA-IPC pool) data path shipped; consumer design design only design only design only (srs.channel) design only
10 ms–1 s 0.5–10 ms 0.5–10 ms; gating via B-08 10 ms–1 s
feas. feas. feas. feas.
feas. feas. feas. feas.
design only design only (pusch.grid) design only design only (xApp candidate)
1 KB ≤ 1 slot fresh; 2 ms cadence weak 275 B 1–10 ms; multi-cell via E2 feas.
weak feas.
design only (no UCI seam) design only
feas. feas. feas.
out of scope actuation shipped (ranControl) live (Python E3 client)
100 KB 1–20 ms 1 KB 1–10 ms actuation 1.4 MB stream floors
feas. feas. feas. (native)
Table V lists the 39 runtime rows and Table VI the xApp/rApp and research rows that Section IV excludes from the runtime count; the identifiers are the ones used throughout the paper, and the mapping to the earlier corpus of [8] is kept in the repository. The five compositions counted in Section IV couple rows already listed here through host-owned caches and authorities, so they are described in the study repository rather than given separate entries. The byte counts are the inputs each row needs per invocation, computed from the 5G NR grid dimensions at 30 kHz subcarrier spacing; the deadline column gives the 5G NR bound or, for asynchronous rows, the freshness after which the result loses value. The verdict columns apply the arithmetic of Section V to the observer-only boundary (an E3 indication out and a control action back) and to a GPU-export boundary (device-to-host or device-to-device copy into a second context). The status column names what the released platform ships, has demonstrated on the air, defines but has not implemented, or leaves out of scope. The same rows, with their formulas and sources, are in the study repository’s use-case inventory and performance matrix.
TABLE VI ROWS THAT ARE NOT DA PPS : MANAGEMENT- PLANE APPLICATIONS ACTING THROUGH TYPED CONFIGURATION OR RAN CONTROL , X A PP / R A PP POLICY, AND ONE RESEARCH ROW THAT NEEDS A MULTI -DU SUBSTRATE . T HEY CONSUME SUMMARIES OR POLICIES AND DO NOT SIZE THE MICROSECOND INTERFACES . ID
Application
Bucket
Timescale
OCUDU status
X-01 X-02 X-03 X-04 X-05 X-06 X-07 X-08 X-09 R-02
QoS and slice-aware flow classification RAN fault and anomaly detection Energy saving, carrier sleep, DTX/DRX SON self-optimisation Slice SLA management Handover and load-balancing advisory Fronthaul and UL-throughput configuration Slice envelope LLM-agent operations (28 MCP tools) Distributed and cell-free MIMO
xApp/rApp xApp/rApp xApp/rApp xApp/rApp xApp/rApp xApp/rApp mgmt. mgmt. mgmt. research
1–10 ms 10 ms–1 s 100 ms–1 s >1s >1s 10 ms–1 s 10 ms–1 s 100 ms–1 s seconds per slot / 100 ms
out of scope: no packet-path seam live: MCP observe ring; ranControl actuation partial: actuation shipped; policy out of scope out of scope: out of scope out of scope: out of scope partial: handoverUe / releaseUeToIdle shipped partial: gain actuation shipped shipped: typed configuration writes live: MCP server on the E3AP endpoint out of scope: multi-DU substrate