Searcharxiv⌕ Search

arXiv · 2611.08511

Akira: Towards Operating System Architecture for Agile Specialization

Abstract

Operating Systems (OS) specialization tailors abstractions and privileges to specific use cases, enabling configurable tradeoffs between performance and isolation. However, increasing application diversity makes low-cost and non-invasive agile specialization challenging. First, modular OS designs decompose the system into components and reduce coupling, but lack abstractions separating component implementations from OS configuration. Second, diverse workloads require different isolation strengths, yet existing OSs largely fix isolation models at design time, making isolation adaptation changes costly and invasive. To address these, we present Akira, an OS architecture that enables efficiently adapt OS composition and isolation. Akira introduces the Abstraction and Encapsulation Unit (AEU), which separates component interfaces and isolation requirements from implementations, hiding modular OS internals and enabling non-invasive reconfiguration. Based on the abstraction, Akira introduces the Control Logic Unit (CLU) and the Bridge-based Isolation Unit (BIU) to separately manage component communication and isolation, enabling their independent adaptation without system-wide modifications. Results show that Akira enables rapid and low-cost OS reconfiguration with only a 1.10x slowdown over native FreeRTOS and reduces reconfiguration effort from 1.38 KLOC of intrusive changes to 0.28 KLOC of incremental updates. On Unikraft-based Redis and Nginx, Akira configurations expand the performance-isolation space by up to 10.4x and 7.8x. We publicly release Akira's source code, at https://github.com/JiangRS17/Akira.

Explore related subjects

Keep this discovery

Explore connections, maps & timelines

BibTeXRIS

Renshuang Jiang, Pan Dong, Yichong Wang, Lei Li, Yuchen Dong, Xiaoxiang Fang, Qirui Yu, Jianfeng Zhang, Zhe Jiang. 2026-09-30. Akira: Towards Operating System Architecture for Agile Specialization. https://arxiv.org/abs/2611.08511

Cite the original work for its findings. Save a collection to share your selection of sources.

KEEP EXPLORING

Related papers

Towards Fully-fledged GPU Multitasking via Proactive Memory Scheduling

Limited HBM capacity has become the primary bottleneck for hosting a growing number of increasingly larger-scale GPU tasks. While demand paging extends capacity via host DRAM, it can incur order-of-magnitude slowdowns due to the massive working sets of GPU workloads. However, we observe that GPU memory accesses are inherently predictable from kernel launch arguments, prior executions, and the asynchronous execution nature. Leveraging this opportunity, we propose MSched, an OS-level scheduler that extends GPU context switching to include proactive working set preparation. This approach coalesces fragmented, eventual, and expensive page faults into a single efficient migration. MSched combines parameterized templates with page fault feedback to accurately predict working sets, and co-designs the task scheduler and memory manager to resolve global access order and enforce near-optimal page replacement. Across scientific, deep learning, and LLM workloads, MSched outperforms demand paging by up to 186.69x and whole-process swapping by up to 8.63x. MSched is open-source and has been integrated into https://github.com/XpuOS/nvxsched.

cs.OS↗

Memory Fit: Architectural Support for Page Placement by Learning Models of Good Behavior

Server main memory is increasingly heterogeneous, incorporating technologies such as zswap, CXL memory expanders, and emerging phase-change memories (PCM). To decide where to place pages, operating systems have to choose between efficient but coarse-grained access bits, out-of-band profiling, or costly runtime instrumentation. This paper proposes memory fit, a hardware abstraction that provides precise and accurate page placement information to an operating system. Memory fit measures how well a page "fits" each type of memory in the system. Memory fit separates the mechanism of measuring affinity between pages and memories from the OS policy of choosing which pages to move when. The paper describes soft trace matching (STM), a computationally and space efficient algorithm to compute memory fit. The key technical insight behind STM is that it can estimate memory fit by comparing accesses to a page with a learned model of "good" traces for a memory. We have implemented memory fit and STM in a BOOMv3 RISC-V processor running Linux 6.6. On extended GUPS, memory fit placements recover 2.2-3.8 times as much of the performance gap to optimal placement as Linux TPP. For Redis with equal DRAM and PCM capacities, placements selected by memory fit recover 80% of the performance gap, versus 19% for TPP, in a placement replay. Memory fit requires only 64 bits of state per 4 KiB page and can be updated on every main-memory access with only a 1.2% overhead of OS kernel notification processing.

cs.OS↗

MORTIS: Compiler-Guided KV-Cache Management for LLM Agent Programs

Existing agent serving systems divide each prompt into a reusable prefix and an opaque suffix, managing the KV-cache at this coarse granularity without distinguishing the components within each part. We observe that prompt components differ in which LLM calls share their values and how long those values remain reusable, a property we term intra-prompt heterogeneity. Our key insight is that, in frameworks that generate prompts from typed LLM function calls, these components correspond to program variables, allowing compiler analysis to recover their sharing patterns and lifetimes. We present MORTIS, a compiler-serving co-design that combines this analysis with runtime observations to improve KV-cache management. MORTIS reorders prompt components to expose additional prefix reuse and uses their predicted reuse and lifetimes to guide cache retention, eviction, and prefetching. Our evaluation shows that MORTIS achieves up to 1.99x job completion time (JCT) speedup and 1.97x throughput improvement over SGLang, with geometric-mean speedups of 1.45x and 1.49x, respectively.

cs.OS↗