Designed for server, cloud, AI, and embedded systems, the enterprise-grade OpenAtom openEuler delivers an operating system (OS) that lets you “develop once and adapt to many scenarios.” openEuler features a wide range of tools for AI, edge, high-performance computing (HPC), embedded systems, and conventional server operations (see for an overview).

openEuler 24.03 LTS SP4, released in June 2026, builds on the native UnifiedBus SuperPoD support introduced in SP3, adding major enhancements in reliability, usability, AI scheduling, kernel performance, and confidential computing.

Native SuperPoD Support

As one of its most significant features, SP4 offers native SuperPoD support to address the increased compute demands of AI and HPC workloads.

A SuperPoD, a hardware product (i.e., Atlas 950 and TaiShan 950), is built on the UnifiedBus (UB) high-speed, interconnect protocol, which functions as a unified interconnect protocol and fabric. This UB fabric allows for an ultra-low-latency interconnection for both scaling out and up that results in flexible resource composition, large-scale pooling of compute resources, and high system availability. Using all-optical, peer-to-peer connections, the UB-powered SuperPoD can link tens of thousands of AI NPUs and memory units, which then function as a single computer.

To harness the SuperPoD’s power, an OS needs to abstract the UB devices and schedule resources across nodes. openEuler 24.03 LTS SP4 accomplishes this by providing the UB OS Component and UB Service Core. The UB OS Component abstracts and decouples heterogeneous UB hardware; creates a unified memory address space; and handles device discovery, registration, configuration, error management and hotplugging. The UB Service Core provides cluster-level services (i.e., Engine, Virt, Mem, Comm, IO) over a peer-to-peer architecture and boosts application performance by 30-50 percent.

By offering native SuperPoD support, openEuler offers several advantages over other OS options. Rather than seeing the SuperPoD as several separate servers like a traditional Linux distro would, openEuler identifies the SuperPoD as one pooled machine. Because of this, openEuler schedules resource pooling of NPUs, CPUs, memory, and storage across the SuperPoD as a single entity. By taking advantage of the ultra-low-latency UB fabric natively supported by openEuler, compute can scale almost linearly with cluster size as opposed to the utilization drop-off typically found in a typical stacked server scenario. Cross-node load/store memory semantics let AI/HPC apps use the pooled hardware with little or no need for a rewrite, resulting in minimal code changes. Finally, native SuperPoD support in openEuler greatly enhances performance on the Atlas 950 and TaiShan 950 SuperPoD hardware.

SP4 includes several new enhancements to its native SuperPoD support. Building on the high-performance distributed communication via the UnifiedBus Memory Development Kit (UMDK) in SP3, SP4 adds IP over Unified Remote Memory Access (IPoURMA), which provides a standardized method for transmitting IP packets based on the UB protocol and hardware. IPoURMA replaces the Ethernet NIC on a UB network to expose the standard TCP socket API, thus integrating UB’s high-performance capabilities with the Ethernet’s broad compatibility.

Another enhancement, Remote Host-to-Device (RH2D) multi-level cache direct-pass acceleration, allows the transmission of the Key-Value (KV) Cache on a remote host to the local device through asynchronous pipelining. This can reduce the serial wait time in situations where large data blocks need to be fetched from remote nodes and written into the NPU.

Adding on to device pass-through and pooled device support for virtual machines (VMs) introduced in SP3, SP4 introduces Qemu support for NPU-card Device-to Host (D2H). UB memory sits between the guest OS driver and the host UB Memory Management Unit (UMMU), enabling transparent guest-to-host memory mapping/unmapping via a mapping driver.

SP4 improves UB reliability in three ways. First, a new UB reliability plugin intercepts events such as OOM conditions, kernel panics, power-off events, UB memory faults, and link failures and forwards them to the relevant management or recovery service before kernel processing continues. SP4 also introduces memory-pooling fault holding and notification, which works with the business fault-notification capability in shared memory scenarios, letting a business handle any faults it perceives on its own. Finally, memory-borrowing file cache fault containment in SP4 constrains pagecache placement when file sharing exists between remote and local ends thus preventing a fault in the remote pagecache from spreading to the local side.

Also new in SP4, the SuperPoD fault demarcation tool provides latency and disconnection fault demarcation for SuperPoD KV Cache and URMA communication scenarios with a problem-demarcation time of less than five minutes. This can be used as a standalone tool or integrated into an external operations and maintenance system.

AI Innovation

SP4 adds several critical improvements for AI workloads including intelligent diagnosis and tuning, AI software package adaptation, an LLM inference optimization solution, NPU compute slicing, and second-level fast fault recovery.

Intelligent Diagnosis: openEuler Intelligence is a comprehensive large language model (LLM) platform built on openEuler that integrates models, knowledge bases, MCP services, agents, and workflows. As part of openEuler Intelligence, intelligent diagnosis in SP4 offers container interference detection, interference source analysis, and interference recovery recommendation generation. It combines an Intelligent Diagnosis Agent with a Known-Issue Analysis Agent that automates complete full-link diagnosis. Instead of wasting time on manual troubleshooting, this tool provides rapid support for emergency loss mitigation.

Intelligent Tuning: Intelligent tuning in SP4 provides OS-layer performance analysis and tuning skills along with Top-Down Microarchitecture Analysis Methodology (TMA) for automatically identifying performance bottlenecks. TMA provides quick access to key system performance metric data, analysis of system performance, and optimization recommendations.

AI Software Package Adaptation: To address AI search and recommendation scenarios, SP4 offers AI software package adaptation (for 30+ new packages) by proactively planning AI ecosystem software compatibility. This feature solves installation and usage problems of leading search/recommendation software on openEuler. It supports the Qwen deployment, 910B CANN and driver/OS compatibility adaptation (including software package/container release and a compatibility list), and search/recommendation software adaptation.

XPU Turbo: XPU Turbo, formerly sysHAX, optimizes LLM inference via inference dynamic scheduling and CPU inference acceleration. Currently, XPU Turbo supports transformer architecture models (e.g., DeepSeek, Qwen, and Llama). In these models, XPU Turbo accelerates CPU execution and can offload selected inference phases or operators between the CPU and XPU, including prefill-decode separation and, for MoE models, Attention-FFN separation.

xSched: xSched, a general-purpose NPU scheduling framework for small and medium-sized LLMs, has been integrated into SP4 to handle NPU compute slicing. xSched provides basic scheduling mechanisms like task preemption, time-slicing, gang scheduling, and compute bandwidth and device-memory capacity control. It also supports fair scheduling and real-time scheduling policies. xSched handles a variety of AI scheduling tasks, including solving overallocation of resources, allowing high priority inference tasks to quickly preempt low-priority tasks for training-inference co-location or online-offline co-location, and improving NPU resource utilization without compromising high-priority task performance.

Fast Fault Recovery: SP4 offers fast fault recovery for AI inference containers. It can reduce recovery time from minutes to seconds for hardware failures. By integrating with the Kubernetes ecosystem, it can achieve second-level timeframe (1-60 seconds) recovery of inference containers.

Kernel Improvements

Running on Linux kernel 6.6, SP4 adds a new 64K kernel option for Arm images in addition to the default 4K kernel option. While remaining compatible with upstream community features by default, the 64K option improves OS baseline performance. In addition to this new feature, SP4 introduces several new kernel-level capabilities.

Programmable Page Cache: This capability enables userspace-customized filesystem caching strategies to tackle bottlenecks that occur during model loading in inference scenarios. Transparently stacked on an existing filesystem, the programmable page cache forwards filesystem page faults to userspace, which improves I/O efficiency for loading different models. ModelFS builds on the programmable page cache mechanism to support customizable filesystem caching policies, helping improve model-loading efficiency and reduce LLM inference startup time.

Cross-Process Zero-Copy Data Transfer: This offers efficient inter-process data transfer within a node. This transfer allows applications to map pages associated with a virtual memory address space in the source process to the virtual address space in the destination process. This innovation supports both page middle directory (PMD) big page and page table entry (PTE) small page mappings. Cross-process zero-copy data transfer ensures that the mapped destination addresses can be accessed with the same permissions as the source addresses. As a result, it prevents data duplication when moving information between memory address spaces, reducing CPU overhead and memory bandwidth consumption.

FUSE over io_uring: To improve userspace filesystem performance, SP4 uses FUSE over io_uring technology. In the current FUSE architecture, communication occurs in the /dev/fuse character device (the communication bridge between the OS and FUSE), leading to performance bottlenecks. These bottlenecks arise from lock contention in multithreaded environments, the lack of batch processing for I/O intensive tasks, and frequent core switches when the user program and FUSE back end run on different CPU cores. SP4 employs FUSE over io_uring concurrency to solve for these performance bottlenecks. To improve concurrency, it replaces /dev/fuse with the io_uring communication interface, while allowing the back-end FUSE service the flexibility to use either /dev/fuse or io_uring.

Dynamic SMT: SP4 also introduces Dynamic Simultaneous Multithreading (SMT) to improve CPU utilization. Dynamic SMT guarantees the operation of latency-sensitive (LS) tasks, while automatically throttling best-effort (BE) tasks to free up microarchitecture resources. BE tasks can resume on otherwise idle execution slots or idle cores.

Network Enhancements: Network multi-path Receive Packet Steering (RPS) is enhanced in SP4 to achieve multi-core CPU balancing, taking NUMA and cluster affinity into account, which reduces memory-access latency and improves network throughput performance. Additionally, sockmap acceleration of same-host TCP flows bypasses the protocol stack by connecting the send and receive queues of two sockets and redirecting packets to the peer end, reducing the packet-forwarding process and lowering latency.

HiSock: For Internet scenarios, the enhanced HiSock function improves performance and throughput for high-concurrency, low-latency network loads. New capabilities include local acceleration, packet parse/decapsulation logic enhancement, packet capture logic, address translation, and neighbor handling.

NetKit Support: SP4 adds support for eBPF kernel-level traffic governance and chained dynamic scheduling of custom multi-eBPF programs. NetKit is a lightweight virtual networking device designed as an efficient alternative to conventional veth pairs in container networking. It eliminates bottlenecks and reduces CPU overhead.

sched_ext: The sched_ext programmable scheduling framework, based on eBPF, allows for the dynamic loading and unloading of custom scheduling algorithms at runtime without requiring the kernel to be recompiled. This framework reduces the development cycle and lowers the threshold for schedulers, which allows for optimization in specific workloads. For BPF scheduler malfunctions, sched_ext features a built-in safety mechanism that automatically switches back to the system’s default scheduler to avoid system hang-ups and other irregularities.

Cgroup v2: SP4 enhances cgroup v2 with asynchronous cgroup-level memory reclamation, reducing performance loss and jitter caused by synchronous reclamation during short-lived memory-pressure spikes.