If a million-dollar esports AR broadcast experiences stuttering (frame drops) during a live stream, the boss would typically roar: “Why didn't we swap in the best graphics cards? Didn't we install four RTX 4090s?!”
At this point, as the TD (Technical Director), you can only roar in despair inside your mind:“It's not the GPU's fault at all! The CPU main thread is being choked to death by I/O data!”
In a complex real-time pipeline built on Unreal Engine 5 (UE5), rendering polygons is never the only burden. During a large-scale live broadcast, the system is swallowing a desperate amount of external data every millisecond:
- 4 channels of uncompressed 4K video signals (SDI/2110) constantly flooding the PCIe bus;
- Extremely high-frequency motion capture (MoCap) and camera tracking data demanding millisecond-level responses;
- Hundreds of network API data streams (e.g., real-time scores, live comments) pouring in via HTTP or WebSocket;
- Plus OSC/MIDI control protocols continuously sending parameter modification commands.
The core architecture of native UE5 is designed for games—it is a polling system heavily reliant on a single main thread (Game Thread/Main Thread). When you forcibly cram these massive external I/O operations into UE's Blueprint or Tick events, a disaster begins: The main thread will experience microsecond-levelthread stallsdue to processing string parsing (e.g., JSON-formatted score data) or waiting for video frame buffers. Even worse, the massive instant generation and destruction of data objects frequently trigger UE'sGarbage Collection (GC), causing severe memory thrashing and periodic spikes in frame time.
On screen, this manifests as noticeable “stuttering” and “freezing” every few seconds.
Faced with this deep-seated architectural flaw in the engine,Aximmetryit brings out the core weapon of an industrial-grade control system:I/O Bypass Scheduling and complete thread decoupling.
Core Solution 1: Intercept and “Isolate” All External I/O
The first step for Aximmetry to solve I/O blocking is absolute “centralization of power” and “physical isolation.”
It strictly prohibits external data from directly entering UE5. Whether it's Ncam tracking data, JSON-formatted esports APIs, or multiple high-bandwidth video streams, Aximmetry intercepts all I/O requests at the lowest level (OS and driver layer) and directs them into its own highly optimized processing pipeline, independent of UE.
Aximmetry itself is a real-time operating system-level framework written in extremely low-level C++, focused on graphics and data flow scheduling. Its efficiency in handling string parsing, network requests, and video frame decoding far exceeds the overhead of UE's Blueprint virtual machine. It efficiently digests these “dirty and heavy tasks” within its own memory pool, completely avoiding frequent GC (Garbage Collection) stuttering on the UE side.
Core Solution 2: “Zero-Copy” Transfer via Shared Memory
Intercepting the data is only the first step; how do you smoothly hand the processed results to UE5 for rendering? If using traditional middleware communication (e.g., UDP network sending), it still incurs huge deserialization overhead.
Between Aximmetry and UE5 (deeply embedded via the Aximmetry DE architecture), a high-speed“Zero-Copy Shared Memory”channel is established.
- When Aximmetry finishes parsing external API data or calculating the camera's 6DOF matrix, it doesn't “send” the data to the engine. Instead, it directly writes these extremely streamlined, pure floating-point numbers (Float) or transformation matrices (Transform) into a memory/VRAM address shared with UE.
- Before executing, UE5's rendering thread only needs to instantly read the prepared variable from this address. The entire process involves no data copying, completely bypassing the UE main thread bottleneck, achievingnanosecond-level handover。
between two complex systems.
Core Solution 3: Node-Level Heterogeneous Asynchronous Computing
In large-scale galas, we often need to use live audio to drive complex AR effects (e.g., bass making a virtual building shake). Doing FFT (Fast Fourier Transform) audio analysis in UE not only consumes a lot of CPU but also severely drags down the rendering frame rate.Aximmetry's node flow graph perfectly supportsheterogeneous asynchronous computing.
In its pipeline, you can easily drag out an “Audio Spectrum” node. This node runs completely asynchronously at the bottom layer (and can even be assigned to specific physical CPU cores), causing no blocking to the video rendering pipeline. After silently completing complex mathematical operations in the background, it simply tosses the final calculated "vibration amplitude (Float value)" to UE5 via shared memory to drive mesh deformation.Heavy mathematical operations are digested asynchronously within Aximmetry, while UE5 is only responsible for the final "visual expression."
This extreme division of labor squeezes the last bit of performance out of the hardware.
Conclusion: Reject Single Points of Failure, Build a Bulletproof PipelineIn the world of real-time graphics engineers, the standard for judging an architecture's quality is not how many frames it can run when idle, but
whether the system will crash under sudden extreme loads.
Native Unreal Engine is like a supercar with a top-tier V12 engine (excellent GPU rendering), but if you directly place the heavy burden of hauling cargo (massive I/O and data processing) on its driveshaft (main thread), the supercar will break down instantly.
Aximmetry deeply understands this structural fragility. Through its powerful bypass scheduling mechanism, it transforms into an indestructible “heavy escort vehicle.” It builds a breakwater around the engine, blocking the impact of massive video streams, digesting complex network data, and isolating fatal memory thrashing.
简体中文 
English