WorksComputer Science
CapBuddy: Efficient Physical Memory Management for Capability-based Resource-controlling Microkernel
Abstract
Capability-based resource-controlling microkernels securely multiplex hardware by exposing low-level resource abstractions guarded by capability systems. Such a design helps provide an application-specific resource management policy to achieve high performance without sacrificing security. However, the misuse of capability-protected secure abstractions can introduce performance overhead in user-level resource management, affecting the runtime performance of dynamic applications in emerging scenarios. In this paper, we focus on the secure abstraction of physical memory in microkernels with capability-based resource management delegation to investigate an appropriate design for dynamic memory management. We propose CapBuddy, an approach to building an efficient buddy system on capability-protected secure abstractions of memory, to bypass the performance overhead of the capability system by offloading functionalities that can run offline from the critical path of serving a memory request. We implemented a prototype system on the seL4 library OS, and the evaluation results show that our approach improves the performance of the seL4 user-level buddy system by 20 to 54.5 times and achieves the same order of magnitude as Linux. Further burst experiments evaluate CapBuddy's scalability and show that it maintains low median allocation latency as the number of concurrent clients increases.
CCS Concepts: • Software and its engineering → Operating systems.
Additional Key Words and Phrases: Microkernel, Capability System, Memory Management, Buddy System
Authors’ Contact Information: Zhuang Lu, [email protected], State Key Laboratory of Cyberspace Security Defense, Institute of Information Engineering, Chinese Academy of Sciences, Beijing, China, School of Cyber Security and University of Chinese Academy of Sciences, Beijing, China; Guangtao Zhu, [email protected], UNSW Sydney, Sydney, NSW, Australia; Shijun Zhao, [email protected], State Key Laboratory of Cyberspace Security Defense, Institute of Information Engineering, Chinese Academy of Sciences, Beijing, China; Qianying Zhang, [email protected], College of Information Engineering, Capital Normal University, Beijing, China; Lixin Chen, [email protected], State Key Laboratory of Cyberspace Security Defense, Institute of Information Engineering, Chinese Academy of Sciences, Beijing, China; Zekun Xu, [email protected], College of Information Engineering, Capital Normal University, Beijing, China; Wu Luo, [email protected], State Key Laboratory of Cyberspace Security Defense, Institute of Information Engineering, Chinese Academy of Sciences, Beijing, China; Rui Hou, [email protected], State Key Laboratory of Cyberspace Security Defense, Institute of Information Engineering, Chinese Academy of Sciences, Beijing, China.
Introduction
Over three generations [12, 19, 37], microkernels from L3 to seL4 have steadily evolved toward a primary goal: securely multiplexing hardware resources among different programs [19, 21, 60]. To achieve this, they provide simple, low-level abstractions that closely match the hardware while protecting them through a capability system for security purposes [6, 35, 58]. Operating systems (OS) built on top of the microkernel can safely use these abstractions to create a library OS (LibOS) that provides application-specific resource-management policies. The feasibility of such a design idea was justified years ago by Exokernel [20, 28], but microkernels extend it further by adding strong protection guarantees through capability systems. Consequently, microkernels are now widely used in systems where safety and security are critical [25], as they provide strong isolation and a small trusted computing base (TCB).
Meanwhile, recent works on microkernel-based systems such as M3 [2], HongMeng [10], MettEagle [44], and Split-container [60] show that microkernels are evolving towards new scenarios (e.g., mobile devices, heterogeneous devices, and cloud computing). A key merit of the above works is that they demonstrate the feasibility of a microkernel-based approach for achieving performance, dynamism, and scalability. However, these systems fall short of the policy-free ideal of microkernels, as they either retain resource-management policy in the kernel or fail to securely delegate resource management to the user level. Therefore, we argue that the aforementioned works leave a central question unanswered—Can we still achieve competitive performance with a policy-free microkernel without sacrificing security?—in particular, when the kernel delegates hardware resources such as memory to the user level via capability-protected kernel abstractions?
The above question matters because keeping memory management inside the kernel is risky unless the approach can be formally justified or verified [19, 45]. As evidence, researchers have found covert channels in in-kernel memory management from one of the above cases [49] (i.e., L4Re [24] under MettEagle and M3). Fundamentally, the core tension in a policy-laden microkernel is that efficiency gains may come at the expense of the very isolation that gives microkernels their security advantages. In contrast, once memory management is delegated to the user level, such threats are confined to user-level components, reducing the chance of breaking isolation. We refer to such microkernels as “capability-based resource-controlling microkernels”.
The remaining challenge is performance, i.e., whether user-level physical-memory management can remain efficient. Fundamentally, there is a trade-off between performance and protecting hardware resources with a capability system, as each access to a capability-protected resource inherently incurs a security check by the capability system [10]. The cost compounds when the capability system resides in the kernel [6, 30], as each check further requires a system call with two CPU mode switches. We further argue that existing work on user-level memory management is incomplete, as it struggles to find a viable solution for capability-protected resources. Some systems provide only ad hoc or inefficient user-level policies (e.g., CantripOS [62], Barrelfish OS [3, 5], and seL4 LibOS [56]) while others avoid dynamic allocation altogether by statically draining memory at startup (e.g., Genode [22], LionsOS [25]).
In this paper, we aim to explore efficient user-level methods for managing capability-protected resources on microkernels. We focus on physical memory, as they are crucial for supporting dynamic OS mechanisms such as copy-on-write [33], on-demand process spawn [9, 33, 63], and anonymous mappings [10], which are crucial in the emerging scenarios. Given the aims, we propose to build a high-performance, user-level buddy system on the seL4 LibOS [56]. We are motivated by the following reasons:
The buddy system is a widely used approach for physical memory management, making it a natural first step for us to explore high-performance user-level management of capability-protected resources [32, 34].
seL4 is a policy-free microkernel with capability-based resource control [18, 19].
LibOS is practical for providing application-specific policies for resource management to improve runtime performance [20, 34, 53], making it a good match for microkernels whose resource management is delegated to the user level.
To investigate how much performance impact a capability system can have on memory management, we analyze the canonical dynamic memory allocator from the seL4 LibOS [56], which is a long-standing buddy system that has served the seL4 ecosystem for over twelve years. The result shows that the buddy system in seL4 LibOS is 101.8 times slower than its counterparts in other LibOSes (e.g., Unikraft [34]) and 33.4 times slower than Linux. We also implemented a capability system for the Linux buddy system to remove the noise of kernel architecture. Performance analysis indicates that it likewise becomes 2.3 times slower due to the introduction of a capability system.
However, it is unjustified that memory management will perform poorly with a capability system inherently. We argue that the poor performance stems from a flawed design that results from misusing the secure abstractions of microkernels. Misuse can introduce a long call chain for applications to access resources. In the context of seL4 LibOS, such misuse leads to a design that places “the cost of the capability system” [3, 17] on the critical path of physical memory management. The cost increases the response latency for applications served by the memory allocator, leading to a performance bottleneck.
We further argue that an appropriate design can bypass the above bottleneck. To prove this claim, we propose CapBuddy, an approach to building an efficient buddy system on microkernels with capability-based resource management delegation. CapBuddy provides a user-level abstraction of memory for enforcing memory management policies. Building around the new abstraction, CapBuddy breaks a memory allocator into two halves via adopting a “split-design”, which offloads the functionalities that can run offline from the critical path of serving a memory request. It intercepts state updates at the user level whenever possible, without passing them to the kernel and performing capability bookkeeping asynchronously.
To validate our design, we implemented a CapBuddy prototype on seL4 LibOS and compared it against baseline systems (e.g., Linux). The results show that our prototype achieves performance in the same order of magnitude as Linux. To demonstrate the universality of CapBuddy, we implemented two buddy system variants in the prototype for different purposes: a common variant (similar to Linux) and a specialized variant for optimization. The latter improves the batching behavior with an acceptable overhead of . The contributions are as follows.
We explain the reasons why and how the misuse of secure abstractions in microkernels leads to poor performance in dynamic memory management.
We propose an approach for dynamic user-level physical memory management on capability-based resource-controlling microkernels, which opens up the possibility of supporting efficient user-level policies in emerging scenarios while still providing competitive performance.
We implement a high-performance buddy system prototype for seL4 and its ecosystem, improving the seL4 LibOS buddy system’s performance by 20 to 54.5 times and matching that of the Linux buddy system.
Background
Capability System and Its Variant in seL4
Access control is a mechanism that defines who (subject) can access what (object) in which ways [36]. Microkernels usually implement access control through a capability system [6, 35, 58], which is a system that associates each subject (user-level programs) with a list of unforgeable tokens that contain the permissions to access different objects (kernel abstractions). A capability is an unforgeable token that contains the permissions required to access an object. To access a capability-protected object, a program must present the capability associated with that object and pass the security checks enforced by the capability system. In this paper, we refer to the operations required for a subject to pass the security checks of the capability system as the cost of capability.
seL4 uses a capability system to protect “kernel objects”, which refer to a system resource that the kernel maintains and exposes to user-level programs (i.e., the kernel abstractions). The primary usage of these capability-protected resources is enabling systems construction on seL4. Different user-level programs can access identical kernel objects through capabilities with different permissions. seL4 manages the capabilities of user-level programs through CSpace, an abstraction of a hierarchical namespace for organizing capabilities. Each CSpace consists of CNodes, each of which is an array of slots while each slot stores a capability [7]. On seL4, the capability system functions within the kernel, which means the user-level programs should access capabilities via syscalls by providing a pointer-like reference (called CPtr) that points to a slot (a.k.a, cslot) in CSpace.
In seL4, all kernel objects derive from the Untyped kernel object, which represents unused memory. From the perspective of a user-level program, an Untyped object is the kernel abstraction of physical memory. A user-level program can use the untyped memory to create new kernel objects for different purposes, e.g., threads, pagetable structures, or a new Untyped object. Upon object creation, the user-level program invokes a retype syscall that instructs the kernel to convert a part of an Untyped object into a “typed” kernel object (i.e., an object whose type is specified). Each retype operation initializes the new objects from an Untyped object and generates a new capability for accessing the derived objects accordingly.
The Evolution of Kernel Abstractions of Physical Memory on Microkernels
In this section, we review the evolution of the kernel abstraction of physical memory across three generations of microkernels, aiming to understand the trade-offs. We then use seL4 as a case study to describe how capability-based resource-controlling microkernels abstract memory.
Mach [68] represents the first generation of microkernels, which do not expose any abstraction of physical memory to the user level for resource management delegation. Instead, it manages physical memory inside the kernel. This design violates the policy-free principle of microkernels [23]. It also reduces flexibility and limits the ability of user-level systems to customize policies for varying applications [38].
L4 [37] represents the second generation of microkernels. L4 also does not expose a physical memory abstraction to the user level, but it addresses part of Mach’s issues by separating mechanism from policy [37]. L4 reserves a portion of physical memory as a kernel heap and provides mechanisms for recursively constructing address spaces and creating page mappings [37, 65]. User-level systems then manage the remaining physical memory based on these mechanisms. This design improves flexibility. However, it requires the kernel to maintain a mapping database, which consumes a large amount of kernel-heap memory and exposes the kernel to denial-of-service (DoS) attacks [19].
seL4, the world’s first formally-verified microkernel [29], represents the third generation of microkernels [19]. Building on the experience of the previous two generations, seL4 delegates physical-memory management to user space via Untyped objects. The sole purpose of Untyped is creating kernel objects from unused memory, i.e., treats all memory as the kernel heap, but it is not implied that all the unused memory is only for kernel use. seL4 provides another abstraction of physical memory over Untyped called Frame, which represents a piece of memory that is mappable to an address space. Other than Untyped and Frame, seL4 provides abstractions for memory that are mapped as pagetable structures for MMU/IOMMU, which are architecture-dependent. Such a design allows user space to implement application-specific memory management policies [19], reduces the risk of DoS attacks against the kernel [19], as all physical memory are seen as the heap, and makes the life cycle of each kernel object traceable through capability-based access control over physical memory, which helps the formal verification of the kernel [19, 30]. The idea of delegating memory management out of the kernel via abstractions has influenced the design of other modern OSes and kernels, e.g., Barrelfish OS [5], CheriOS nanokernel [21], and Asterinas [48, 69].
LibOS and Buddy System
A library OS (LibOS) [20], a.k.a, unikernel [42], places OS services and the application in the same address space. Applications can access the services via function calls, avoiding mode-switch overhead. LibOSes are famous for providing application-specific policies through customized OS services [34].
The buddy system [32] is a popular method for physical memory management in OSes [34, 67]. It serves requests with varying size requirements by partitioning memory into blocks whose sizes are powers of two (e.g., 4KB, 8KB, etc.). Specifically, when a user requests a block of memory of a given size, the buddy system locates the smallest available block that is at least the requested size, then recursively splits it into pairs of equal-sized buddy blocks until the size matches the request. When freeing a memory block, the system marks it as free and checks its buddy block. If both blocks are free, it merges them into a larger block and continues merging recursively.
Case Study: seL4 LibOS and Its Resource Management Framework
We use seL4 LibOS [56] as an example to show how a user-level system manages physical memory on top of microkernels with capability-based resource management delegation. We will begin with how memory is initialized as Untyped, then introduce how the allocators within LibOS work.
Initialization. At boot time, the kernel initializes all available memory and has it mapped into the kernel address space. It then generates Untyped capabilities for the available memory, delegates all resources via capabilities as “bootstrap information” (BootInfo) to the first user-level process, i.e., the init-task, and schedules the init-task for user-level initialization.
The init-task is a process that parses the BootInfo and initializes other user-level components. It can set up new CSpace for user-level components, and dispatches the Untypeds by putting their capabilities into the CSpaces of other components. Components who has been granted the capabilities to access the Untypeds and CSpaces can manage the memory. Such components are usually a trusted pager, a centralized memory manager, or a LibOS application that controls the memory itself. Once initialized, the components will use seL4 LibOS to bootstrap and handle runtime memory requests.
Allocator Internals. In seL4 LibOS, the client program and the LibOS reside in the same address space, and a user-level memory allocator in the LibOS handles physical memory requests. A client program can be a pager, a virtual machine monitor (VMM), or even an application. The allocator consists of three components: a metadata manager, an Untyped manager, and a capability bookkeeper. The Untyped manager records the size and state of available Untyped objects, and selects a suitable Untyped object when an application requests memory. The capability bookkeeper uses a bitmap to record the availability of the in-kernel cslots, which store the capabilities of kernel objects and the Untypeds. The metadata manager provides metadata allocation support. It controls the heap of the LibOS and receives metadata bookkeeping requests from the other parts of the allocator, i.e., the Untyped manager and the capability bookkeeper.
Figure 1 shows how an application on seL4 LibOS interacts with the allocator through a UNIX mmap-like request. In this example, the application requests a one-page, read-only, and anonymous mapping at a given virtual address. When the allocator receives the request, it explicitly allocates a Frame, a kernel object representing mappable physical memory, as the backing memory. The allocator then returns a pointer to a cslot that stores the Frame capability, which will be passed to the mapping syscall to install the mapping in the target address space (also referenced by a capability pointer).

Figure 1. Pseudocode of how an application requests a Frame object from seL4 LibOS and maps it into an address space.
1 vaddr = arg(0) # virtual address to map
2 cptr_vspace = arg(1) # pagetable capability pointer
3 cptr_frame = sel4_libos_allocator_alloc(KOBJ_TYPE_FRAME) # allocate a Frame kernel object
4 # mmap(vaddr, PAGE_SIZE, PROT_READ, MAP_ANONYMOUS | MAP_PRIVATE, -1, 0)
5 err = seL4_Syscall_Map(cptr_vspace, cptr_frame, vaddr, PROT_READ, MAP_ANONYMOUS | MAP_PRIVATE, ...)
1 def sel4_libos_allocator_alloc(obj_type: int) -> int: # type is provided by the application
2 cptr = capability_bookkeeper_slot_pin() # reserve a CSpace slot for the new capability
3 cookie = untyped_manager_alloc(cptr, obj_type) # create the object and place its cap at cptr
4 allocator_internal_record(cookie, cptr, obj_type) # record allocator metadata for the created object
5 return cptr # return the CPtr used to invoke the new object
We also present the workflow of how the allocator responds to an allocation request in Figure 2. First, the allocator instructs the capability bookkeeper and pins a slot for the requested object. The Untyped manager then selects a suitable Untyped object regarding the request, and asks the kernel to perform a retype syscall, which creates the target object and stores its capability into the pinned slot. The process of de-allocation is in reverse order of allocation, i.e., the Untyped manager instructs the kernel to delete the kernel object first, the Untyped manager then restores the state of the Untyped object, and the bookkeeper releases the pinned slot once the above process finishes.

Figure 2. Pseudo code of how seL4 LibOS handles request.
Quantitative Analysis and Insights
This section analyzes the impact of capability systems on memory management performance and presents our design insights. We analyze from two aspects. First, we quantify the performance overhead of allocation and deallocation operations in the buddy system of seL4 LibOS (hereafter referred to as seL4 Buddy), showing how capability systems affect the basic operations of a user-level buddy system. Second, we provide a breakdown analysis to the overhead to investigate the root cause. We hypothesize that the impact of capability systems on buddy systems is not limited to system calls; it also introduces a longer call chain into the state updating operations. To validate the hypothesis, we implement a capability-protected buddy-system prototype in the Linux kernel. This prototype converts the capability invocations that are performed via seL4 syscalls into function calls. We then propose some insights, which help us design a buddy system suitable for capability-protected physical memory.
Performance Bottleneck in seL4 Buddy
By comparing seL4 Buddy with the Linux buddy system, we found that the performance bottleneck of seL4 Buddy mainly stems from its reliance on a physical memory abstraction that requires costly state updates (Figure 3). First, seL4 Buddy and the Linux buddy system adopt a similar design approach, as both implement the buddy algorithm (i.e., split and merge operations) based on their respective physical memory abstractions. The difference is that seL4 Buddy relies on the Untyped object, whereas the Linux buddy system is based on struct page2. Furthermore, we discovered that seL4 Buddy’s physical memory abstraction causes the split/merge operations to trigger a long call chain within the seL4 LibOS, which requires not only syscalls but also complex capability bookkeeping. Specifically, the long call chain of seL4 Buddy consists of the following three stages. In contrast, the memory abstraction underlying the Linux buddy system allows it to execute the buddy algorithm using only stage 1, requiring no syscalls but only in-kernel function calls

Figure 3. Different buddy systems among the Linux kernel, seL4 LibOS, and CapBuddy over seL4 LibOS. Components within the dark-red, dotted box are operations for materializing the vblks, which are not on the critical path.
Updating block metadata. The memory allocator updates the metadata describing the block whenever it is split or merged.
User-level capability bookkeeping. The allocator allocates or frees a cslot for recording a protected block and updates accounting data. Such processes can involve the overhead of searching the target cslot.
Capability Invocations. Every basic operation can bind with an seL4 syscall to split or merge the blocks, which leads to two switches between machine modes, one security check at each kernel entry, and an internal state update of the capability system.
From the above facts, we realized a design flaw of seL4 Buddy is that it builds a synchronous model of buddy system on abstractions that are costly to update. To validate our thoughts, we compared seL4 Buddy’s performance with other baselines (i.e., Linux and Unikraft [34]). The results in Figure 4 show that seL4 LibOS underperforms other systems in both allocation and deallocation by orders of magnitude; see § 6 for details.
Figure 4. Single-page performance comparison between seL4, Linux, and Unikraft buddy systems.
The Cost of Capability Invocations
One major overhead in seL4 Buddy stems from operations that access the in-kernel capability systems, which lead to the overhead of mode switches and capability security checks.
Suppose we are allocating a 4 KB Frame out of a 4 MB Untyped via seL4 Buddy. We consider the worst-case splitting scenario, where no smaller suitable Untyped is available and splitting must start from 4 MB. In this case, it will need 11 system calls in total: 10 to split the Untyped to new Untypeds of 4 KB, and 1 to retype a 4 KB Untyped into a Frame for actual mapping. Each split halves the size of the Untyped. Since 4 MB is times 4 KB, 10 split operations are required along the allocation path of the target Frame. To quantify the overhead, we measured the above operations on an ARM platform (Cortex-A53, 1.4 GHz), where the average cost of one retype call is 1,396 cycles (breakdown see Table 1). In total, the above split operations take 16,625 cycles. By contrast, performing the same split in Linux Buddy requires 137 cycles on average and 1,596 cycles in total.
| Variant | Mode Switch | Kernel Path | Ave |
| Linux | - | - | 137 |
| seL4 LibOS | 295 | 1,101 | 1,396 |
Table 1. The breakdown of the average cost of splitting a block (cycles). “Kernel Path” includes the cost of capability checks, metadata update triggered by the split operation, and scheduler involvement in seL4.
User-level Capability Bookkeeping
Complex capability bookkeeping is another significant source of overhead in seL4 Buddy, which relies on a capability bookkeeper to record the availability of cslots. Every memory request requires allocating/reclaiming slots and metadata. Concretely, when a user requests one block, the allocator must search for a slot in the CSpace, allocate memory for metadata, and initiate the metadata to track the slot’s state. We measured the average cost of allocating a cslot on the same platform as above, the latency is 568 cycles. Note that the reason why seL4 Buddy spends hundreds of cycles searching for cslots is the lack of optimization, as it adopts a design that uses bitmaps plus linear scan searching without batching as the bookkeeping policy for capabilities.
Validating the Long-Call-Chain Hypothesis
To evaluate the performance impact of the long call chain without the mode-switch overhead of system calls, we built a capability system prototype in the Linux kernel for its buddy system. This prototype follows seL4 Buddy’s design principles, introducing a long call chain for each basic operation of the buddy system in Linux (i.e., adding the length of the critical path for serving a request). This experiment isolates and validates the performance impact of the long call chain itself.
The specific design includes: (1) maintaining a simplified capability derivation tree [7] for each block of physical memory, (2) simulating seL4 LibOS’s user-level capability bookkeeping model, and (3) capability invocations as function calls that perform security checks. The evaluation results (Figure 5) show that the introduction of a capability system likewise makes the Linux buddy system 2.3 times slower on single-page allocation, while the cost increases sharply for batch allocations.
Figure 5. Performance impact of the capability system on Linux Buddy.
Insights
Insight 1: Specific Strategy for Frame objects. As described in § 2.2, there is a classification about seL4 kernel abstractions of memory: Untyped helps create other kernel objects from unused memory, which treats all memory as kernel heap. Frame builds on Untyped and makes a memory mappable to an address space.
seL4 Buddy serves requests of varying sizes for all kernel objects, credited by the features of the Untyped object. However, we argue that a microkernel’s buddy system is best suited to provide only page-sized mappable memory (i.e., Frame), due to the following reasons. First, the distribution of the sizes of seL4 kernel objects is highly skewed and clustered around a small number of size classes and page-size classes, and among page-sized objects, Frame objects account for the vast majority. Many architecture-independent objects [55] are small, falling in the Bytes range, while the rest are dominated by objects of page-sized at 4 KB (e.g., Frame, vcpu, pagetable structures) 3. We analyzed two seL4-based systems (i.e., a Windows VM based on seL4 Microkit [54] and Google CantripOS [62]) and found that Frame objects account for the vast majority of all objects (98% and 69%, respectively) (see Table 2). Second, related research [17, 34] shows that buddy systems are inherently inefficient when managing a heap where requests of varying, small sizes dominate (usually much smaller than page-size), compared to other general-purpose allocators (e.g., minimalloc, tinyalloc).
| System | Frame | PageTable | VCPU | Others | Total |
| seL4 Microkit | 10,619 | 147 | 1 | 86 | 10,853 |
| CantripOS | 245 | 20 | 0 | 89 | 354 |
Table 2. Kernel objects counts for a seL4 Microkit-built Windows VM and CantripOS.
Insight 2: Buddy system operations on physical memory (or memory abstractions) can be modeled as operations on array indexes. A buddy system can model pages of physical memory (or memory abstractions, such as Linux’s struct page) as an array, where each element represents a page (or a memory abstraction) and the index of the element corresponds to the page’s (memory abstraction’s) offset from a base address. Under this view, split and merge operations can be represented as operations over array indexes. Following the same idea, if we model the capabilities of contiguous frames as an array and maintain the mapping between array indexes and CSpace slots at the user level, we can build a user-level buddy system over frame capabilities by manipulating array indexes.
CapBuddy System Design
We propose CapBuddy, an approach to building an efficient user-level buddy system without kernel modifications on capability-based resource-controlling microkernels. CapBuddy introduces a user-level abstraction for representing allocatable memory, called virtual_zone (vzone).
Based on insight 1 (see § 3.4), vzone manages memory at page granularity and serves as a shadow representation of page-aligned memory region. It records allocation states at the user level while maintaining the correspondence between these states and the underlying capabilities. Based on insight 2 (see § 3.4), CapBuddy enables the manipulation of the vzone in user space to implement the buddy system, thereby allowing buddy operations to be implemented through function calls. CapBuddy adopts a split design that triggers capability operations only when needed, which separates memory-management policies from expensive capability-protected resource provisioning. Specifically, CapBuddy divides the allocator into a front-end and a back-end. The front-end enforces buddy algorithms on vzones, while the back-end maintains a memory pool that materializes the vzones.
Vzone Abstraction
The size of each vzone (Figure 6) is a multiple of the page size, which means a vzone contains multiple page-granular blocks (for brevity, vblks). Each vblk has its equivalence in physical memory, while the relationship is recorded in a data field called vblk_sequence, which is a list of CSpace descriptors that link the vblks with their underlying capability-protected resources. The memory that a vzone describes begins at base_physical_address, which is page-aligned and contiguous.

Figure 6. Simplified definition of CapBuddy abstraction.
class virtual_zone:
if CONFIG_ENABLE_BITMAP:
if CONFIG_WORD_SIZE == 32:
arch_data: arch32_single_level_bitmap_t
else: # 64 arch
arch_data: arch64_two_level_bitmap_t
elif CONFIG_LINUX_STYLE:
free_areas: list[free_area] # MAX_ORDER entries
base_physical_address: uintptr_t # base address of the original untyped object & vblk_sequence
vblk_sequence: list[cspacepath_t]# metadata for frames retyped from the original untyped
largest_avail: size_t # current largest available memory region size in bits of frame number
block_size: size_t # small/huge
state: int # state of the vzone
vzone_t = virtual_zone
CapBuddy maintains a vzone pool that organizes vzones according to their base_physical_address or the first cslot in vblk_sequence. The pool maintains two invariants. First, every vzone visible in the pool is structurally valid: its metadata must have been fully initialized before adding to the pool. Second, only vblks marked as provisioned are exposed to the front-end as allocatable memory; such vblks always have valid Frame capabilities that can be returned to clients. A vblk whose Frame capability has been reclaimed remains tracked by its vzone, but it is marked unavailable to the front-end until the back-end materializes it again. CapBuddy preserves these invariants by publishing and removing vzones through synchronization mechanisms (e.g., locks or atomics). The state field in each vzone records whether the vzone is visible to pool users.
Execution Model
CapBuddy uses a single-client, single-daemon execution model. We design CapBuddy for LibOS, so the client program and the LibOS allocators (e.g., CapBuddy) share the same address space. The front-end and the client run in the same “client” thread so that the front-end serves requests synchronously. The back-end runs as a daemon thread that maintains the vzone pool. We adopt this single-client model because (1) it aligns well with LibOS because single-client applications are popular in LibOS environments [4, 33, 52], and (2) CapBuddy focuses more on offloading capability cost than scaling the allocator across many cores.
At boot time, the LibOS runtime initializes the vzone pool with a capacity that adjusts dynamically. The source of the memory to supply the pool is from a bootstrap allocator or external allocators, as CapBuddy does not consume all Untypeds. The vzone pool also has a watermark and thresholds, which are for recording the number of memory in-use and a point for the pool to ask for refill/shrink. The default capacity, watermark, and thresholds are all application-specific, blessed by the LibOS architecture.
The front-end is the only instance that directly serves memory requests. It performs the buddy algorithm and selects an appropriate vblk from vzones in the pool. No resource provisioning operations are necessarily performed by the front-end unless the pool is empty. Before entering the pool, the front-end checks the current watermark. If it grows above/below a threshold, the front-end sends an asynchronous signal to the daemon and then continues the current request without waiting. This implies that the threshold for refill should be lower than the pool capacity, which promises a slack that the front-end can finish without provisioning vzones itself.
The back-end daemon has high scheduling priority and remains passive until it receives a signal. Being passive means that the kernel does not schedule it unless it has been driven by events [41]. Once woken, the daemon provisions memory in bounded batches. One refill/shrink batch is one vzone, containing multiple vblks (e.g., 1024 per batch). Upon refill, the daemon initializes a vzone outside the front-end critical path, materializes its capabilities, and publishes the completed vzone to the pool atomically. The shrink operation is similar: the daemon atomically detaches an empty vzone from the pool, recycles it, and donates its memory to other allocators whoever is in need.
The pool slack is the key to hide provisioning latency. Since the front-end and the daemon are two different threads, the client can continue requesting existing provisioned vzones while the daemon prepares the next vzone. The refill threshold is set conservatively, e.g., at 50% of a pool capacity, so that the remaining memory can cover the worst-case daemon refill latency under peak allocation rate.
Resource Provisioning Design Space
_Why Memory Pool?_ To reason about the design choice of using a memory pool, we model a client’s resource request by the temporal relation among requesting, provisioning, and using a resource, as shown in Figure 7.
Figure 7. Request models. Components in red dotted boxes are on the critical path of serving a request.
The request and the provisioning can be synchronous: resource provisioning happens on the request path.
The request and the provisioning can be asynchronous: (a) pre-provisioning. Provisioning happens before the request, so the resource has already been materialized when the client uses it. (b) fault-driven provisioning. The client first attempts an access without a materialized resource, and the resulting fault/event/exception triggers a handler that materializes the missing resource.
Applying the above model to the buddy system in § 2.4, the resources under provisioning are a set of mappable memory. The request is mapping-oriented: a client requests Frames so that it can consume them via syscalls to create mappings.
Motivated by the issue that seL4 Buddy couples state updates with expensive capability invocations, CapBuddy adopts an asynchronous provisioning model for memory resources. Being asynchronous implies more opportunities to amortize provisioning overhead, e.g., a fault-driven model with batching and interrupt coalescing [1] can help optimize the average fault handling latency. For CapBuddy, however, the more sensible asynchronous model is to materialize Frames before the syscalls that map them (i.e., pre-provisioning). This is because the fault-driven model does not work for seL4 syscalls, which are atomic, meaning a client cannot invoke a mapping syscall without presenting the required capability and then supply it later through a fault handler.
Provisioning Granularity. The basic granularity for pool management is vzone, which means the back-end refills or shrinks the pool with memory in batches. During shrink, the daemon atomically detaches an empty vzone from the pool, deletes all capabilities to the Frames in that vzone, and reclaims the cslots. It then reclaims the corresponding Untyped resources for use by other allocators. However, given the granularity for the front-end to consume memory is vblk (as each Frame behind a vblk is the granularity for invoking syscalls), internal fragmentation within vzones could be an issue for shrink operations, as the granularity for draining is smaller. To address this issue, CapBuddy provides a fine-grained provisioning mechanism that allows the back-end to reclaim at vblk granularity. The back-end can pin some available vblks, delete their Frame capabilities and reclaim the corresponding Untyped resources, while preserving their states within the vzone as “allocated”. Reclaiming the corresponding Untyped resources must not affect other pages still in use in the vzone. For Frames in the vzone created from the same Untyped, that Untyped can be reclaimed only after the Frame capabilities of all corresponding vblks, including any copies, have been deleted. Such a mechanism is similar to the idea of memory ballooning [64]. The trade-off is that it introduces longer latencies, making vzone the default granularity unless the fragmentation issue is severe.
To ensure both granularity for pool management work without breaking CapBuddy’s validity invariants, we also record the capability of Untyped that each Frame of vblks is retyped from. This helps the daemon to reclaim and re-materialize these “allocated” vblks safely, as their Frame capability could have been deleted during page-granular reclaim, keeping their backing vzone structurally valid and visible to the pool. To prevent the front-end from misusing these “allocated” vblk by requesting a deallocation on them, CapBuddy records each vblk in a visible vzone with one of three states: (1) provisioned-available, meaning that the vblk has a valid Frame capability and can participate in front-end allocation and merge operations; (2) provisioned-allocated, meaning that the vblk has a valid Frame capability but is currently owned by a client; and (3) unprovisioned, meaning that the vblk remains tracked by the vzone but has no capability available to the front-end, so it is excluded from buddy operations until the back-end materializes it again.
Fastpath
The process of allocating an object from seL4 LibOS allocator was: (1) pin capability slots, (2) perform buddy algorithm, (3) allocate the object by creating new capabilities into the pinned slots, and (4) return the reference to the slots.
When using CapBuddy, however, steps (1) and (3) are not performed as long as the pool contains suitable provisioned-available vblks, meaning only (2) and (4) are on the critical path, which is the definition of “fastpath”. The fastpath relies on CapBuddy’s validity invariant in § 4.1, which ensures all allocation requests finish at the level. Once an allocation request has gone through the buddy algorithm and arrived at , the allocator returns by serving the clients with the and physical address of the allocatable . The client then uses the returned reference to map the through a seL4 system call, during which the kernel checks the corresponding capability. CapBuddy does not modify the seL4 microkernel. Operations on kernel objects still go through seL4 system calls, so these objects remain protected by the microkernel’s capability mechanism.
For deallocation fastpath, the request arrives with an input of a cookie (e.g., or physical address). Before submitting this request, the client must stop accessing the page and unmap it through seL4 LibOS. It must also remove mappings established through any copied capabilities and delete those copies. The front-end uses the input to locate the to update, performs buddy algorithm, and changes the relevant states. The pool retains the existing capability for subsequent allocations, but the client must stop using the previously returned reference. On reallocation, the front-end returns the corresponding reference for a new mapping.
No actual capability invocations or capability bookkeeping operations are involved in the fastpath. The front-end only changes the state recorded in free_areas or arch_data, i.e., the data field that left for building buddy algorithms on . Neither capability slots pin/unpin will happen due to capability bookkeeping, nor retype due to kernel object allocation. Such operations happen only when the pool is drained, while the front-end, in that case, needs to signal and wait synchronously for the daemon to refill.
Capability Bookkeeping
Though capability bookkeeping is largely offloaded to the daemon, a faster bookkeeper can still improve the latency for the daemon to provision memory for . When initializing the , the back-end uses the capability bookkeeper to pin slots for the capabilities. Given the lessons learned from § 3.2, we provide the capability bookkeeper with batching mechanisms that help amortize the average search latency per slot. This design aligns well with how the daemon materializes , i.e., creates in batch. The capability bookkeeper now allocates contiguous in batch for each when initializing its vblk_sequence.
In seL4 Buddy, bookkeeping operations are coupled with every split/merge operation. While in CapBuddy, bookkeeping operations are coupled with materialization. The lifetime of a is then tied to a rather than to an individual split/merge operation.
CapBuddy’s Prototype on seL4
We prototype CapBuddy over the seL4 microkernel and implement the abstraction using utilities provided by the seL4 LibOS (referred to as a seL4-based CapBuddy). The front-end and the back-end daemon run on separate cores under seL4’s SMP kernel. We base CapBuddy’s prototyping work on seL4 Buddy by redirecting the requests for mappable memory from seL4 Buddy to seL4-based CapBuddy. Such a choice can (1) prevent a revamp of the entire memory management framework, and (2) reuse the framework to manage other kernel objects for convenience. We chose seL4 Buddy as a starting point because of its resource management framework, including a capability bookkeeper, a buddy system that provides a universal allocation strategy for varying kernel objects, and a minimum compatible layer that simplifies the use of capability invocations.
Vzone Provisioning
We use a red-black tree to organize the vzones in seL4-based CapBuddy. For synchronization, we now use a coarse-grained lock that ensures the atomicity of state updates from the front-end and the daemon. Such an implementation can be replaced when a multi-client, multi-daemon model is required. To materialize the vzones, seL4-based CapBuddy provides the capability bookkeeper with an interface to create and initialize a region in the CSpace for initializing vblk_sequence.
Front-end Variants.
With the help of vzone, seL4-based CapBuddy provides the system designer with the ability to implement their own variants of buddy systems or algorithms over vzone. The variants build on the policy-oriented data structure (i.e., arch_data and free_areas) and integrate with the vblk_sequence.
By binding the free_areas field with the struct page metadata in Linux buddy system, we have implemented a Linux-style buddy system variant in seL4-based CapBuddy (referred to as CapBuddy-Linux Style). Based on the evaluation, we found that the Linux-style implementation has space for optimization when deallocation in batch (see § 6.1), which motivates us to implement an optimized, bitmap-based variant called CapBuddy-Standard. CapBuddy-Standard replaces the linked list in Linux Buddy for organizing metadata with bitmaps and a red-black tree. Such an approach imposes an overhead of tens of CPU cycles while effectively improving batching deallocation (see § 6.1). To further optimize CapBuddy-Standard, we implement “CapBuddy-Stripped”, a streamlined variant of CapBuddy-Standard. CapBuddy-Stripped applies two optimizations. First, it organizes bitmaps by machine word through conditional compilation, avoiding repeated architecture-dependent checks during bitmap queries and updates. Second, it inlines frequently executed fastpath logic, including bitmap operations, buddy-merge checks, and updates to the largest available block. With a shorter execution path, CapBuddy-Stripped preserves scalability while reducing the performance gap with CapBuddy-Linux Style.
Back-end Daemon
We use the threading utilities of seL4 LibOS to spawn the back-end daemon during CapBuddy’s bootstrap. To apply the event-driven model, we bind an seL4 thread to an seL4 Notification, which is a kernel object that receives asynchronous signals and wakes up the bound thread. The Notification is also bound with a SchedContext, which is a kernel object that allows the thread to execute on a specific CPU core for a period. When a signal from the front-end arrives, the Notification directs the signal to the daemon thread, which then appends to the kernel scheduler for having obtained the SchedContext of the Notification. After execution, the SchedContext will be taken from the thread until the next time it receives a signal, making it unable to execute proactively.
Capability Bookkeeping Optimization.
To optimize capability bookkeeping, we replaced the linear scan search in seL4 Buddy with a hierarchical bitmap-based search. Such a bitmap-based approach can speed up search operations using hardware instructions (e.g., “count leading zeros”). seL4-based CapBuddy provides the capability bookkeeper with batching mechanisms, allowing the allocation of contiguous slots in CSpace for vblks.
Integrate CapBuddy into seL4 LibOS.
Figure 8 shows how we prototype seL4-based CapBuddy on seL4 LibOS. In seL4 LibOS, client programs request memory through the POSIX APIs provided by musllibc. These requests pass through multiple LibOS layers before reaching libsel4vka, which is a library that provides a set of generic kernel-object allocation interfaces. libsel4vka forwards concrete allocation and deallocation requests to an allocator instance (i.e., libsel4allocman in our case) through function hooks.

Figure 8. Implementation path of seL4-based CapBuddy.
To prototype CapBuddy into this framework, we add two hooks to libsel4vka that intercept requests for mappable memory from libsel4allocman: (1) try_alloc_from_pool(), which handles allocation requests for Frames. (2) try_free_from_pool(), which handles deallocation requests. These two hooks are the starting point to implement the front-end of CapBuddy, which serves requests with materialized vblks.
We implement core functions of CapBuddy (e.g., buddy algorithm, vzone management) as a library and integrate both the front-end and the back-end into libsel4allocman, which allows CapBuddy to reuse a majority of utilities for managing CSpace and Untyped memory. With this design, Frame requests issued through libsel4vka will first enter CapBuddy and go through the front-end, if they complete after a fastpath walk through the front-end returns to libsel4vka, otherwise the front-end will wait for the back-end daemon to refill the pool.
We know that the front-end signals the daemon when a threshold is met. When the front-end requires new provisioned vblks, i.e., new Frame capabilities, the back-end daemon receives signals and is scheduled to replenish the vzone pool through seL4_Untyped_Retype syscall, which creates Frames in batch for vzones. This organization inserts CapBuddy into the existing seL4 LibOS memory management path while keeping the upper library interfaces unchanged.
Large-Page Support. We use the vzone abstraction to support large pages in seL4-based CapBuddy, with separate vzones and refill/shrink thresholds in the pool. In our prototype, each 32 MB large-page vzone contains 16 vblks, each corresponding to a 2 MB Frame. The back-end prepares resources for these vzones. Similar to Linux HugeTLB’s management of free huge pages [39], the front-end maintains a linked list of free vblk indices in each vzone. Allocation removes an index from the list and returns the corresponding cslot reference. Deallocation returns the index to the list. The interfaces in § 5.5 forward requests to new large-page allocation and deallocation hooks in libsel4vka based on the Frame type and page size. During deallocation, we check whether the Frame belongs to a large-page vzone.
Evaluation
Given that we prototype CapBuddy on top of seL4 Buddy and seL4 LibOS, it is difficult to conduct a fair comparison against other OSes that are neither LibOS (i.e., Linux) nor managing physical memory by themselves (i.e., Unikraft). In this context, our evaluation focuses on the performance improvement CapBuddy brings to physical memory management in seL4 LibOS. We also use buddy systems in other OSes as performance references to assess the performance CapBuddy can achieve under capability-based resource management delegation. Our evaluation answers the following questions.
How does CapBuddy improve physical memory allocation and deallocation performance?
How does CapBuddy improve the end-to-end performance of user-level memory operations?
How do emerging scenarios benefit from CapBuddy?
How do real-world applications benefit from CapBuddy?
Experimental Setup. We run all benchmarks on a Raspberry Pi 3B+ (64-bit) platform. This platform features a quad-core Cortex-A53 processor (fixed at 1.4 GHz) and 1 GB of DRAM. We choose it because seL4 is mature in the ecosystem of ARM processors [57]. User space relies on musl libc to provide compatibility.
Baselines. We run three seL4-based CapBuddy variants: CapBuddy-Standard, CapBuddy-Stripped, and CapBuddy-Linux Style. For baselines, we compare CapBuddy with:
Linux Buddy (kernel version 6.12.48). Represents physical memory management in a mature operating system. To minimize the impact of services on memory layout, it runs a minimal BusyBox (version 1.36.1).
seL4 Buddy. The native allocator in seL4 LibOS. It does not support allocating or deallocating multiple physically contiguous 4 KB pages in a single request. We use it to quantify the performance improvement CapBuddy brings to the LibOS.
Unikraft Buddy. Implements a minimal, pure buddy system algorithm that operates within a pre-established virtual address space. Compared to other physical memory managers, it is closer to the definition of a heap manager [34]. Since it provides ideal performance but does not perform actual physical memory management, we consider it a theoretical optimum.
Microbenchmarks for Physical Memory Allocation and Deallocation
We evaluate each buddy system for both single-page and contiguous physical memory allocation and deallocation. The aim is to demonstrate the latency of a buddy system in responding to a memory request from other OS services. We also compare CapBuddy with seL4 Buddy for large-page allocation and deallocation.
Single-Page Evaluation. We measure the latency of single-page allocation and deallocation by allocating and deallocating 4 KB pages (a total amount ranging from 4 MB to 128 MB). Figure 9 (a) and Figure 9 (b) show the results. Overall, Unikraft Buddy exhibits the lowest latency, followed by Linux Buddy. seL4 Buddy performs the worst, while CapBuddy falls between Linux Buddy and seL4 Buddy.
Figure 9. (a)–(b) show the results for single-page physical memory allocation and deallocation; (c)–(d) show the results for contiguous physical memory allocation and deallocation.
The single-page allocation results (Figure 9 (a)) show that all three CapBuddy variants achieve significant performance improvements over seL4 Buddy. seL4 Buddy’s allocation latency reaches 15,111 ~ 23,176 cycles. In contrast, CapBuddy-Standard, CapBuddy-Stripped, and CapBuddy-Linux Style achieve average performance improvements of 8.9 times, 16.8 times, and 20.0 times over seL4 Buddy, respectively.
Among all CapBuddy variants, CapBuddy-Linux Style (860 ~ 870 cycles) performs best, though it is still 40.1% slower than native Linux. This remaining gap mainly comes from the seL4 LibOS compatibility layer used by our prototype, which typically takes 330 cycles. However, when comparing to Unikraft, i.e., the theoretical optimum (164 ~ 188 cycles), both CapBuddy-Linux Style and native Linux are way slower. At their lowest mean allocation latencies of 1,941 and 860 cycles, CapBuddy-Standard and CapBuddy-Linux Style achieve approximately 0.7 and 1.6 million pages/s, respectively.
The single-page deallocation results (Figure 9 (b)) follow a similar trend to allocation. seL4 Buddy’s latency is 6,119 ~ 130,339 cycles, which is significantly higher than that of other systems. CapBuddy-Standard, CapBuddy-Stripped, and CapBuddy-Linux Style achieve average performance improvements of 45.6 times, 54.5 times, and 50.0 times over seL4 Buddy, respectively. Here, CapBuddy-Stripped performs best (760 ~ 765 cycles), slower than Linux Buddy’s average performance (469 ~ 530 cycles) and Unikraft Buddy’s (239 ~ 255 cycles).
Batching Evaluation. We measure allocation and deallocation latency for block sizes ranging from 4 KB to 4 MB. For each size, we allocate a total of 256 MB. We exclude the seL4 Buddy from this evaluation as it does not support batching.
Figure 9 (c) shows the results for batching allocation. CapBuddy-Linux Style outperforms other CapBuddy variants with latencies of 744 ~ 936 cycles. It achieves 78.8% of the Linux Buddy’s average performance (538 ~ 774 cycles) and 48.5% of the Unikraft Buddy’s average performance (164 ~ 1,183 cycles). CapBuddy-Stripped and CapBuddy-Standard exhibit latencies of 838 ~ 1,234 cycles and 1,818 ~ 4,399 cycles, respectively.
Figure 9 (d) shows the results for batching deallocation. CapBuddy outperforms Linux Buddy in this metric. CapBuddy-Stripped (765 ~ 1,641 cycles) performs best among other CapBuddy variants. It outperforms the Linux Buddy by 11.5 times on average but achieves only 32.0% of the Unikraft Buddy’s performance (228 ~ 684 cycles). CapBuddy-Linux Style exhibits high latency variance (808 ~ 23,189 cycles), whereas CapBuddy-Standard maintains latencies between 1,016 and 4,252 cycles.
Large-Page Evaluation. We further measure allocation and deallocation latency for 2 MB pages (a total amount ranging from 4 MB to 128 MB). Figure 10 (a) and Figure 10 (b) show the results. CapBuddy achieves allocation latencies of cycles, whereas seL4 Buddy requires cycles. Deallocation follows a similar trend, with CapBuddy achieving latencies of cycles, lower than seL4 Buddy’s cycles.
Figure 10. (a) shows the results for large-page physical memory allocation; (b) shows the results for large-page physical memory deallocation.
Overall Analysis. In the single-page and batching evaluations, Unikraft Buddy achieves the best performance because it has a minimal code path, as it operates purely as a heap allocator, i.e., not managing physical memory.
In batching deallocation, CapBuddy (Standard/Stripped) outperforms Linux. The reason Linux underperforms is that it iterates over per-page metadata and performs additional checks when freeing contiguous blocks. CapBuddy-Linux Style still retains this property, leading to higher latency. In contrast, the bitmap-based CapBuddy variants (Standard and Stripped) eliminate metadata traversal, resulting in lower latency.
Although most of the CapBuddy variants underperform Linux in single-page evaluations by cycles, such an overhead is solvable with a slimmed compatibility layer.
Back-end Daemon Overhead
Using CapBuddy-Standard, we measure back-end vzone refill and shrink overhead, synchronous fallback latency when the vzone pool has insufficient memory, and the daemon’s scheduling interference with a task on the same core.
Vzone Refill and Shrink. We refill and shrink a total of 512 MB in units of 4 MB vzones, measuring 128 operations each. We measure overall and stage latencies together to identify the main sources of overhead.
Table 3 shows the overall latency and stage breakdown. A few operations spend much longer in the Untyped acquisition and contiguous cslot allocation stage, raising mean refill latency far above the median, while Frame creation dominates most refill operations. Shrink latency is relatively stable, dominated by Frame capability and cslot reclamation. CapBuddy offloads these operations to the back-end, so the front-end allocates and deallocates by updating vblk states without the corresponding capability operations on the fastpath.
| Operation / Stage | Mean | Median | Max |
| Vzone refill (overall) | 6.25M | 91.8k | 315M |
| Untyped acquisition and contiguous cslot allocation | 6.17M | 8.60k | – |
| Frame creation | 72.5k | 73.1k | – |
| vzone initialization and publication | 12.1k | 9.74k | – |
| Other | 310 | 296 | – |
| Vzone shrink (overall) | 445k | 444k | 462k |
| vzone detachment | 2.20k | 2.24k | – |
| Frame capability and cslot reclamation | 434k | 434k | – |
| Untyped return and metadata release | 7.30k | 6.84k | – |
| Other | 1.09k | 1.04k | – |
| Synchronous fallback (overall) | 6.26M | 100k | 315M |
Table 3. Latency of vzone refill, shrink, and synchronous fallback (in CPU cycles; , ).
Synchronous Fallback Path. Starting with an empty vzone pool, we continuously allocate 4 KB pages totaling 512 MB. Each time the pool is exhausted, we measure synchronous fallback latency from the front-end receiving the request to returning the page after synchronous refill. The 128 synchronous fallback operations have a mean latency close to that of refill (Table 3). When the pool cannot satisfy a request, the front-end waits for refill, bringing the back-end’s resource preparation onto the request’s critical path.
CPU Scheduling Interference. We bind CoreMark [15], a compute-intensive benchmark, and the high-priority daemon to CPU 1, with the memory allocation client on CPU 0. To measure interference on the same core, we compare CoreMark throughput with the daemon idle or performing back-end operations. Each measurement lasts 20 seconds. With back-end operations, the pool initially contains one 4 MB vzone. After measurement starts, the client allocates 512 MB in 4 KB page requests, then deallocates the pages; the daemon reclaims the vzones. This triggers multiple vzone refill and shrink operations, reducing CoreMark throughput by 3.1% (Table 4).
| Condition | CoreMark Throughput (iterations/s) |
| Idle daemon | 4,593.4 |
| Daemon performing refill and shrink | 4,452.0 |
Table 4. Daemon interference with CoreMark throughput on the same core. We report the median throughput of 10 runs for each condition.
Burst Requests
We test whether asynchronous refill in CapBuddy-Standard satisfies single-client and multi-client burst requests in time with insufficient initial vzone pool memory. We record P50, P95, P99, and maximum (Max) allocation latencies and pool-miss rate: the percentage of allocation requests unable to obtain a page from the pool (pool misses).
Single-Client Burst Requests. We bind the client to CPU 0 and the daemon to CPU 1. The client continuously allocates 4 KB pages; the burst size is the total memory requested per batch. We vary the burst size from 8 MB to 512 MB with an initial 4 MB vzone pool, then vary the initial pool size from 4 MB to 256 MB with a fixed 512 MB burst.
In both experiments (Figure 11 (a) and (Figure 11b)), P50 remains at 1,913 ∼ 1,916 cycles, P95 at 2,067 ∼ 2,098 cycles, and P99 at 2,175 ∼ 2,324 cycles. With an initial 4 MB pool, the 8 MB and 512 MB bursts cause 0 and 6 pool misses, respectively; all pool-miss rates remain below 0.025%. For a fixed 512 MB burst, larger initial pools reduce pool misses, with none at 128 MB and 256 MB but still high Max. Asynchronous refill thus satisfies most front-end requests in time. Increasing the burst size does not noticeably affect median allocation latency. Max remains high without pool misses because interrupts cause the front-end core to enter seL4’s SMP kernel, which uses a big kernel lock (BKL) to protect shared kernel state [50]. If the kernel on the daemon’s core holds the BKL, the front-end core must wait, delaying allocation.
Figure 11. Results for different (a) burst sizes, (b) initial pool sizes, and (c) client counts. Bars show the pool-miss rate (left axis), with pool-miss counts above. Lines show P50, P95, P99, and Max allocation latencies in CPU cycles (right axis).
Multi-Client Burst Requests. We extend the single-client prototype to multiple client threads sharing one vzone pool and one refill daemon, with pool-level and vzone-level locks protecting concurrent accesses. Clients send no additional refill notifications while a refill request is pending or being processed. On CPUs 0, 2, and 3, 1 to 16 clients concurrently request a total of 512 MB in 4 KB pages from an initial 4 MB pool; the daemon runs on CPU 1.
From 1 to 16 clients (Figure 11 (c)), pool misses increase from 6 to 91, and pool-miss rate rises from 0.0046% to 0.0694%. P50 allocation latency increases from 1,973 to 2,407 cycles, P95 from 2,100 to 28,535 cycles, and P99 from 2,236 to 1.19M cycles. Most requests complete quickly, but more clients cause more frequent pool misses and higher tail latency.
Microbenchmarks for User-Level End-to-End Memory Operation
This section evaluates the end-to-end latency of memory operations from the user-level perspective. In applications, a complete memory request involves the allocation/deallocation of physical memory and the corresponding mapping/unmapping operations. To measure the above requests, we conduct three microbenchmarks: “single-page”, “batching”, and a memory bandwidth evaluation. In the first two benchmarks, Linux uses mmap with MAP_POPULATE (for immediate allocation and mapping) and munmap, while the seL4 LibOS uses the semantically equivalent space_new_pages and vspace_unmap_pages. We exclude Unikraft for these experiments because we did not find similar Unikraft mechanisms to compare against.
Single-Page Evaluation. We measure the end-to-end latency for single-page (4 KB) operations along the memory management path. Table 5 shows that CapBuddy-Standard has the best performance: it outperforms seL4 Buddy by 4.8 times and Linux Buddy by 2.6 times in terms of “allocation + mapping”, while for “deallocation + unmapping”, CapBuddy-Standard outperforms seL4 Buddy by 1.9 times and Linux Buddy by 2.5 times.
| Evaluated System | Alloc + Mmap | Dealloc + Unmap |
| Linux Buddy | 14 810 | 14 389 |
| CapBuddy-Standard | 5716 | 5731 |
| seL4 Buddy | 27 689 | 11 076 |
Table 5. Latency of single-page end-to-end memory operations (in CPU cycles).
Compared with seL4 Buddy, the reduced latency stems primarily from faster single-page allocation and deallocation. Compared to Linux Buddy, the performance gain comes from the shorter and more compact virtual memory management path of the seL4 LibOS.
Batching Evaluation. We measure end-to-end latency of batching “allocation/deallocation + mapping/unmapping” of varying sizes, ranging from 1 MB to 16 MB in powers of two. Figure 12 (a) and Figure 12 (b) show that CapBuddy-Standard achieves the best performance across most operations.
Figure 12. (a) shows the results for batching “allocation + mapping”; (b) shows the results for batching “unmapping + deallocation”; (c) shows the results of the emerging scenario simulation; (d) shows the results of SQLite3 with YCSB workload.
For “allocation + mapping” (i.e., Figure 12 (a)), CapBuddy-Standard exhibits latencies ranging from . On average, it outperforms seL4 Buddy () by 7.1 times and Linux Buddy () by 2.1 times.
For “deallocation + unmapping” (i.e., Figure 12 (b)), CapBuddy-Standard latencies range from . It outperforms seL4 Buddy by 169.9 times on average, but achieves only 49.7% of Linux Buddy’s performance.
CapBuddy-Standard outperforms seL4 Buddy in this benchmark primarily because it supports contiguous memory allocation/deallocation. For allocation + mapping, CapBuddy-Standard surpasses Linux due to its shorter virtual memory management path. However, CapBuddy-Standard underperforms Linux during deallocation + unmapping, which is attributed to mature micro-architectural optimizations in the Linux kernel (e.g., TLB batching), which provide significant advantages in batch reclamation scenarios.
Bandwidth Evaluation. RAMspeed is a benchmark that measures the bandwidth of memory subsystems [27]. We use it to evaluate how different memory managements affect the measured bandwidth. We use six ARM workloads provided by RAMspeed, allocating a total of 256 MB of memory. The motivation is that it helps demonstrate how memory management performs in responding to requests for contiguous memory. The RAMspeed benchmark allocates large, power-of-two chunks, which trigger anonymous mapping and unmapping in musl libc. These operations correspond to the allocation, mapping, deallocation, and unmapping of contiguous physical memory.
Figure 13 shows that CapBuddy-Standard achieves the best performance. Compared to the seL4 Buddy, CapBuddy-Standard improves overall RAMspeed performance by 77.0% on average, with a maximum speedup of 1.9 times. Compared with Linux Buddy, it improves average performance by 5.4%, with a maximum improvement of 11.6%. This advantage primarily stems from the batching mechanism of CapBuddy.
Figure 13. Results of RAMspeed.
ELF Loading
Previous evaluations can help answer how memory management may affect runtime performance (e.g., alloc + mapping), which is critical for long-lived applications. However, a key characteristic of emerging scenarios is the need for thread spawning, which is critical for the performance of short-lived applications (e.g., serverless [61]). Such requirements rely on loading executables on the fly to assemble execution contexts. For the above reasons, we measure the performance of ELF loading, which is crucial for thread spawning, to show how emerging scenarios can benefit from CapBuddy.
For ELF loading, we evaluate segment sizes ranging from 64 KB to 2 MB, comparing the performance of CapBuddy-Standard with seL4 Buddy. Figure 12 (c) shows that CapBuddy improves performance by an average of 32.3% over seL4 Buddy, with a maximum improvement of 39.1%.
Real-world Application
We port SQLite3 [13] to both Linux and seL4 LibOS, along with the log-structured file system (xv6fs [11]) and a RAM Drive acting as a block device to support SQLite3. We use SQLite3 to measure CapBuddy’s impact on database operations. The evaluation over SQLite3 in its default configuration (logging enabled) using the six workloads (A through F) defined by YCSB [14]. Each workload comprises a different mixture of read/write/update/scan operations. To minimize disk I/O, we enabled SQLite3’s in-memory database feature.
We never claim that SQLite3 is optimal, as it relies on the entire OS to deliver good performance. For this reason, we use SQLite3 to assess how well CapBuddy improves overall performance through a memory management boost.
Figure 12 (d) shows that CapBuddy-Standard achieves an average performance improvement of 38.9% over seL4 Buddy, with a maximum improvement of 44.9%. Compared to Linux, CapBuddy-Standard achieves an average of 75.4% of its performance, with a maximum of 81.0%. Regarding the performance gap with Linux, we observe that SQLite3 frequently triggers sbrk to expand the heap during execution. Linux uses demand paging for sbrk, whereas seL4 LibOS relies on proactive mapping, which explains the performance gap.
Related Work
Most of the members of the L4 family employ recursive page mappings for physical memory management [37], which bind physical memory to page mappings. Though effective, this approach introduces an in-kernel mapping database, which consumes a large amount of memory ( of kernel heap). The drawback includes allowing malicious processes to create mappings to DoS attack the kernel heap. Nowadays, some microkernels (e.g., L4Re [24]) choose to stay with recursive page mappings, while seL4 abandoned this approach by replacing it with an Exokernel-like design, i.e., providing capability-protected kernel abstractions that adhere closely to the property of physical memory.
In terms of the user-level memory management over such capability-based resource-controlling microkernels, Elkaduwe et al. [17] evaluated slab, buddy, and hybrid allocators on seL4, finding that buddy allocation incurs high memory overhead (up to 200%) for small kernel objects and recommending slab allocation. Eftime et al. [16] proposed a bitmap-based allocator to reduce metadata and accelerate small memory allocations using bitwise operations.
The buddy system [31], widely adopted for its high performance and low external fragmentation, has inspired several variants, such as Fibonacci buddies [26], generalized Fibonacci buddies [8, 51], weighted buddies [59], and double buddies [46, 66]. Recent research has focused on enhancing performance on multi-core platforms. The lazy iBuddy system [47] optimized single-page allocation and reduced lock contention by using individual page frames and multiple buddy space management. NBBS [43] enabled non-blocking concurrent allocations and releases, avoiding spinlock synchronization. Spring Buddy [40] tackled memory allocation bottlenecks in cloud computing by dynamically adjusting page frame organization based on request patterns.
Conclusion
Capability-based resource-controlling microkernels protect hardware resources with a capability system to securely expose low-level interfaces to the user space, aimed at improving application performance without sacrificing security. However, we find that the cost of the capability system can impose overhead on user-level dynamic memory management. The bottleneck is the long critical path of memory request handling. We propose CapBuddy, a first step towards a dynamic memory management approach for a capability-based resource-controlling microkernel, which offloads time-consuming capability-relevant operations from the critical path. A prototype of CapBuddy on seL4 LibOS improves the performance of dynamic memory management by 20 to 54.5 times, bringing it to the same order of magnitude as the Linux buddy system.
Acknowledgments
This work is supported by the National Natural Science Foundation of China (No.62272458 and No.62372311), and the National Natural Science Foundation of China for Distinguished Young Scholars (No.62125208).
References
Manuscript submitted to ACM
References
- [1]Irfan Ahmad, Ajay Gulati, and Ali Mashtizadeh. 2011. vIC: interrupt coalescing for virtual machine storage device IO. In Proceedings of the 2011 USENIX Conference on USENIX Annual Technical Conference (Portland, OR) (USENIXATC ’11). USENIX Association, USA, 4.
- [2]Nils Asmussen, Marcus Völp, Benedikt Nöthen, Hermann Härtig, and Gerhard Fettweis. 2016. M3: A Hardware/Operating-System Co-Design to Tame Heterogeneous Manycores. In Proceedings of the Twenty-First International Conference on Architectural Support for Programming Languages and Operating Systems (Atlanta, Georgia, USA) (ASPLOS ’16). Association for Computing Machinery, New York, NY, USA, 189–203. doi:10.1145/2872362.2872371DOI
- [3]Andrew Baumann. 2021. Fish in a Barrel: an insider’s retrospective of the SOSP’09 multikernel paper. https://www.sigops.org/2021/fish-in-a-barrel-an-insiders-retrospective-of-the-sosp09-multikernel-paper/.
- [4]Andrew Baumann, Jonathan Appavoo, Oran Krieger, and Timothy Roscoe. 2019. A fork() in the road. In Proceedings of the Workshop on Hot Topics in Operating Systems (Bertinoro, Italy) (HotOS ’19). Association for Computing Machinery, New York, NY, USA, 14–22. doi:10.1145/3317550.3321435DOI
- [5]Andrew Baumann, Paul Barham, Pierre-Evariste Dagand, Tim Harris, Rebecca Isaacs, Simon Peter, Timothy Roscoe, Adrian Schüpbach, and Akhilesh Singhania. 2009. The multikernel: a new OS architecture for scalable multicore systems. In Proceedings of the ACM SIGOPS 22nd Symposium on Operating Systems Principles (SOSP). ACM, 29–44. doi:10.1145/1629575.1629579DOI
- [6]Alan C Bomberger, Norman Hardy, A Peri Frantz, Charles R Landau, William S Frantz, Jonathan S Shapiro, and Ann C Hardy. 1992. The KeyKOS nanokernel architecture. In Proceedings of the USENIX Workshop on Micro-kernels and Other Kernel Architectures. USENIX Association, 95–112.
- [7]Andrew Boyton. 2009. A verified shared capability model. In Proceedings of the 4th International Workshop on Systems Software Verification (SSV). Elsevier, 25–44. doi:10.1016/J.ENTCS.2009.09.058DOI
- [8]Warren Burton. 1976. A buddy system variation for disk storage allocation. Commun. ACM 19, 7 (1976), 416–417. doi:10.1145/360248.360259DOI
- [9]Bryan Cantrill. 2024. Unikernels are unfit for production. https://www.tritondatacenter.com/blog/unikernels-are-unfit-for-production
- [10]Haibo Chen, Xie Miao, Ning Jia, Nan Wang, Yu Li, Nian Liu, Yutao Liu, Fei Wang, Qiang Huang, Kun Li, Hongyang Yang, Hui Wang, Jie Yin, Yu Peng, and Fengwei Xu. 2024. Microkernel goes general: Performance and compatibility in the HongMeng production microkernel. In Proceedings of the 18th USENIX Symposium on Operating Systems Design and Implementation (OSDI). USENIX Association, 465–485.
- [11]Hoagang Chen, Daniel Ziegler, Tej Chajed, Adam Chlipala, M Frans Kaashoek, and Nickolai Zeldovich. 2015. Using Crash Hoare logic for certifying the FSCQ file system. In Proceedings of the 25th Symposium on Operating Systems Principles. ACM, 18–37. doi:10.1145/2815400.2815402DOI
- [12]J Bradley Chen and Brian N Bershad. 1993. The impact of operating system structure on memory system performance. In Proceedings of the 14th ACM Symposium on Operating System Principles (SOSP). ACM, 120–133. doi:10.1145/168619.168629DOI
- [13]SQLite Consortium. 2018. SQLite. https://www.sqlite.org/index.html
- [14]Brian F Cooper, Adam Silberstein, Erwin Tam, Raghu Ramakrishnan, and Russell Sears. 2010. Benchmarking cloud serving systems with YCSB. In Proceedings of the 1st ACM symposium on Cloud computing. ACM, 143–154. doi:10.1145/1807128.1807152
- [15]EEMBC. [n. d.]. CoreMark. Accessed: 2026-10-09. https://www.eembc.org/coremark/
- [16]Petre Efstrime, Lucian Mogosanu, Mihai Carabaș, Răzvan Deaconescu, Laura Gheorghe, and Valentin Gabriel Voiculescu. 2017. Optimizing Memory Usage in L4-Based Microkernel. Computing and Informatics 36, 4 (2017), 925–949. doi:10.4149/cai_2017_4_925
- [17]Dhammika Elkaduwe. 2010. A principled approach to kernel memory management. Ph. D. Dissertation. University of New South Wales, Sydney, Australia. doi:10.26190/UNSWORKS/23083
- [18]Dhammika Elkaduwe, Philip Derrin, and Kevin Elphinstone. 2008. Kernel design for isolation and assurance of physical memory. In Proceedings of the 1st Workshop on Isolation and Integration in Embedded Systems (IIES). ACM, 35–40. doi:10.1145/143548.1435465
- [19]Kevin Elphinstone and Gernot Heiser. 2013. From L3 to seL4 what have we learnt in 20 years of L4 microkernels?. In Proceedings of the 24th ACM Symposium on Operating Systems Principles (SOSP). ACM, 133–150. doi:10.1145/2517349.2522720DOI
- [20]Dawson R Engler, M Frans Kaashoek, and James O’Toole Jr. 1995. Exokernel: An operating system architecture for application-level resource management. In Proceedings of the 15th ACM Symposium on Operating System Principles (SOSP). ACM, 251–266. doi:10.1145/224056.224076DOI
- [21]Lawrence Esswood. 2021. CheriOS: designing an untrusted single-address-space capability operating system utilising capability hardware and a minimal hypervisor. Ph. D. Dissertation. University of Cambridge, United Kingdom.
- [22]Norman Feske. 2015. Genode Foundations. Genode Labs. https://genode.org/documentation/genode-foundations/
- [23]Per Brinch Hansen. 1970. The nucleus of a multiprogramming system. Commun. ACM 13, 4 (1970), 238–241. doi:10.1145/362258.362278
- [24]Hermann Härtig, Michael Hohmuth, Jochen Liedtke, Sebastian Schönberg, and Jean Wolter. 1997. The performance of μ-kernel-based systems. Proceedings of the 16th ACM Symposium on Operating System Principles (SOSP) (1997), 66–77. doi:10.1145/268998.266660
- [25]Gernot Heiser, Ivan Velickovic, Peter Chubb, Alwin Joshy, Anuraag Ganesh, Bill Nguyen, Cheng Li, Courtney Darville, Guangtao Zhu, James Archer, Jingyao Zhou, Krishnan Winter, Lucy Parker, Szymon Duchniewicz, and Tianyi Bai. 2025. Fast, Secure, Adaptable: LionsOS Design, Implementation and Performance. CoRR abs/2501.06234 (2025). arXiv:2501.06234 doi:10.48550/arxiv.2501.06234DOI
- [26]Daniel S Hirschberg. 1973. A class of dynamic memory allocation algorithms. Commun. ACM 16, 10 (1973), 615–618. doi:10.1145/362375.362392DOI
- [27]Rhett M Hollander and Paul V Bolotoff. 2002. RAMspeed benchmark. http://alasir.com/software/ramspeed.
- [28]M Frans Kaashoek, Dawson R Engler, Gregory R Ganger, Héctor M Briceño, Russell Hunt, David Mazières, Thomas Pinckney, Robert Grimm, John Jannotti, and Kenneth Mackenzie. 1997. Application performance and flexibility on exokernel systems. In Proceedings of the 16th ACM Symposium on Operating System Principles (SOSP). ACM, 52–65. doi:10.1145/268998.266644DOI
- [29]Gerwin Klein, June Andronick, Kevin Elphinstone, Toby Murray, Thomas Sewell, Rafal Kolanski, and Gernot Heiser. 2014. Comprehensive formal verification of an OS microkernel. ACM Transactions on Computer Systems (TOCS) 32, 1 (2014), 2:1–2:70. doi:10.1145/2560537DOI
- [30]Gerwin Klein, Kevin Elphinstone, Gernot Heiser, June Andronick, David Cock, Philip Derrin, Dhammika Elkaduwe, Kai Engelhardt, Rafal Kolanski, Michael Norrish, Thomas Sewell, Harvey Tuch, and Simon Winwood. 2009. seL4: Formal verification of an OS kernel. In Proceedings of the ACM SIGOPS 22nd Symposium on Operating Systems Principles (SOSP). ACM, 207–220. doi:10.1145/1629575.1629596DOI
- [31]Kenneth C Knowlton. 1965. A fast storage allocator. Commun. ACM 8, 10 (1965), 623–624. doi:10.1145/365628.365655
- [32]Donald E Knuth. 1997. The Art of Computer Programming: Volume 1: Fundamental Algorithms (3rd ed.). Addison-Wesley.
- [33]John Alistair Kressel, Hugo Lefevre, and Pierre Olivier. 2025. μFork: Supporting POSIX fork Within a Single-Address-Space OS. In Proceedings of the ACM SIGOPS 31st Symposium on Operating Systems Principles (SOSP). ACM, 18–35. doi:10.1145/3731569.3764809
- [34]Simon Kuenzer, Vlad-Andrei Bădoiu, Hugo Lefevre, Sharan Santhanam, Alexander Jung, Gaulthier Gain, Cyril Soldani, Costin Lupu, Ștefan Teodorescu, Costi Rădăcanu, Cristian Banu, Laurent Mathy, Răzvan Deaconescu, Costin Raiciu, and Felipe Huici. 2021. Unikraft: fast, specialized unikernels the easy way. In Proceedings of the 16th European Conference on Computer Systems (EuroSys). ACM, 376–394. doi:10.1145/3447786.3456248DOI
- [35]Adam Larczynski and Alexander Warg. 2009. Taming subsystems: capabilities as universal resource access control in L4. In Proceedings of the 2nd Workshop on Isolation and Integration in Embedded Systems (IIES). ACM, 25–30. doi:10.1145/1591310.1591315
- [36]Butler W. Lampson. 1971. Protection. In Proceedings of the 5th Princeton Symposium on Information Sciences and Systems. 437–443. Reprinted in Operating Systems Review, 8(1):18–24, 1974.
- [37]Jochen Liedtke. 1995. On micro-kernel construction. In Proceedings of the 15th ACM Symposium on Operating Systems Principles (SOSP). ACM, 237–250. doi:10.1145/224056.224075DOI
- [38]Jochen Liedtke. 1996. Toward real microkernels. Commun. ACM 39, 9 (1996), 70–77.DOI
- [39]Linux Kernel Community. [n. d.]. HugeTLB Pages. https://docs.kernel.org/admin-guide/mm/hugetlbpage.html.
- [40]Yihui Lu, Weidong Liu, Chentao Wu, Jia Wang, Xiaoming Gao, Jie Li, and Minyi Guo. 2021. Spring Buddy: A Self-Adaptive Elastic Memory Management Scheme for Efficient Concurrent Allocation/Deallocation in Cloud Computing Systems. In Proceedings of the IEEE 27th International Conference on Parallel and Distributed Systems (ICPADS). IEEE, 402–409. doi:10.1109/ICPADS53394.2021.00056DOI
- [41]Anna Lyons, Kent McLeod, Hesham Almatary, and Gernot Heiser. 2018. Scheduling-Context Capabilities: A Principled, Light-Weight Operating-System Mechanism for Managing Time. In Proceedings of the Thirteenth EuroSys Conference (Porto, Portugal) (EuroSys ’18). Association for Computing Machinery, New York, NY, USA, 1–16. doi:10.1145/3190508.3190539DOI
- [42]Anil Madhavapeddy, Richard Mortier, Charalampos Rotsos, David Scott, Balraj Singh, Thomas Gazagnaire, Steven Smith, Steven Hand, and Jon Crowcroft. 2013. Unikernels: Library operating systems for the cloud. In Proceedings of the 18th International Conference on Architectural Support for Programming Languages and Operating Systems (ASPLOS). ACM, 461–472. doi:10.1145/2451116.2451167DOI
- [43]Romolo Marotta, Mauro Ianni, Alessandro Pellegrini, and Francesco Quaglia. 2022. NBBS: A non-blocking buddy system for multi-core machines. IEEE Trans. Comput. 71, 3 (2022), 599–612. doi:10.1109/TC.2021.3060393DOI
- [44]Till Miemietz, Viktor Reusch, Matthias Hille, Lars Wenger, Jana Eisoldt, Jan Klötzke, Max Kurze, Adam Lackorzynski, Michael Roitzsch, and Hermann Härtig. 2025. MettEagle: Costs and Benefits of Implementing Containers on Microkernels. In Proceedings of the 19th USENIX Symposium on Operating Systems Design and Implementation (OSDI). USENIX Association, 979–996.DOI
- [45]Luke Nelson, Helgi Sigurbjarnarson, Kaiyuan Zhang, Dylan Johnson, James Bornholt, Emina Torlak, and Xi Wang. 2017. Hyperkernel: Push-button verification of an OS kernel. In Proceedings of the 26th Symposium on Operating Systems Principles (SOSP). ACM, 252–269. doi:10.1145/3132747.3132748DOI
- [46]Ivor P Page and Jeff Hagins. 1986. Improving the performance of buddy systems. IEEE Trans. Comput. 35, 5 (1986), 441–447. doi:10.1109/TC.1986.1676786DOI
- [47]Heekwon Park, Jongmoo Choi, Donghee Lee, and Sam H Noh. 2015. iBuddy: Inverse buddy for enhancing memory allocation/deallocation performance on multi-core systems. IEEE Trans. Comput. 64, 3 (2015), 720–732. doi:10.1109/TC.2013.2296049DOI
- [48]Yuke Peng, Hongliang Tian, Zhang Junyang, Ruihan Li, Chengjun Chen, Jianfeng Jiang, Jinyi Xian, Xiaolin Wang, Chenren Xu, Diyu Zhou, Yingwei Luo, Shoumeng Yan, and Yinqian Zhang. 2025. ASTERINAS: A Linux ABI-Compatible, Rust-Based Framework for Microkernels. In Proceedings of the 2025 USENIX Annual Technical Conference (USENIX ATC). USENIX Association, 307–323.
- [49]Michael Peter, Matthias Petschick, Julian Vetter, Jan Nordholz, Janis Daniszevskis, and Jean-Pierre Seifert. 2015. Undermining isolation through covert channels in the Fiasco.OC microkernel. In Proceedings of the 30th International Symposium on Computer and Information Sciences (ISCIS). Springer, 147–156. doi:10.1007/978-3-319-22635-4_13
- [50]Sean Peters, Adrian Danis, Kevin Elphinstone, and Gernot Heiser. 2015. For a Microkernel, a Big Lock Is Fine. In Proceedings of the 6th Asia-Pacific Workshop on Systems (APSys). ACM, 7 pages. doi:10.1145/2797022.2797042
- [51]James L Peterson and Theodore A Norman. 1977. Buddy systems. Commun. ACM 20, 6 (1977), 421–431. doi:10.1145/359605.359626DOI
- [52]Ali Raza, Thomas Unger, Matthew Boyd, Eric B Munson, Parul Sohal, Ulrich Drepper, Richard Jones, Daniel Bristot De Oliveira, Larry Woodman, Renato Mancuso, Jonathan Appavoo, and Orran Krieger. 2023. Unikernel Linux (UKL). In Proceedings of the Eighteenth European Conference on Computer Systems. ACM, 590–605. doi:10.1145/3552326.3587458DOI
- [53]Dan Schatzberg, James Cadden, Han Dong, Orran Krieger, and Jonathan Appavoo. 2016. EbbRT: A Framework for Building Per-Application Library Operating Systems. In Proceedings of the 12th USENIX Symposium on Operating Systems Design and Implementation (OSDI). USENIX Association, 671–688.
- [54]seL4 Foundation. 2025. The seL4 Microkit. https://docs.sel4.systems/projects/microkit/.
- [55]seL4 Foundation. 2025. seL4 Reference Manual. Available at https://docs.sel4.systems/.
- [56]seL4 Foundation. 2025. seL4_libs: No-assurance Libraries for Rapid-prototyping of seL4 Applications. https://github.com/seL4/seL4_libs.
- [57]seL4 Foundation. 2025. Supported platforms of the seL4 microkernel. https://docs.sel4.systems/Hardware.
- [58]Jonathan S Shapiro, Jonathan M Smith, and David J Farber. 1999. EROS: a fast capability system. In Proceedings of the 17th ACM Symposium on Operating Systems Principles (SOSP). ACM, 170–185. doi:10.1145/319151.319163DOI
- [59]Kenneth K Shen and James L Peterson. 1974. A weighted buddy method for dynamic storage allocation. Commun. ACM 17, 10 (1974), 558–562. doi:10.1145/355620.361164DOI
- [60]Jiacheng Shi, Jinyu Gu, Yubin Xia, and Haibo Chen. 2025. Serverless functions made confidential and efficient with split containers. In Proceedings of the 34th USENIX Security Symposium (USENIX Security). USENIX Association, 1091–1110.
- [61]Ariel Szekely, Adam Belay, Robert Morris, and M Frans Kaashoek. 2024. Unifying serverless and microservice workloads with SigmaOS. In Proceedings of the ACM SIGOPS 30th Symposium on Operating Systems Principles (SOSP). ACM, 385–402. doi:10.1145/3699471.3695947DOI
- [62]June Tate-Gans, Sam Leffler, and Kai Yick. 2023. CantripOS: An OS for Ambient ML Applications. https://sel4.systems/Foundation/Summit/2023/slides/day2-01-leffler.pdf. Keynote at the seL4 Summit 2023.
- [63]Unikraft Project. 2025. Multiprocess support on Unikraft. https://unikraft.org/blog/2025-05-15-multiprocess.
- [64]Carl A. Waldspurger. 2002. Memory resource management in VMware ESX server. In Proceedings of the 5th Symposium on Operating Systems Design and Implementation (Boston, Massachusetts) (OSDI ’02). USENIX Association, USA, 181–194.
- [65]Andreas Weigand. 2004. Generalized-Mapping IPC for L4. Master’s thesis. Technische Universität Dresden, Germany.
- [66]Paul R Wilson, Mark S Johnstone, David Boles, and Michael Neely. 1995. Memory Allocation Policies Reconsidered: Methodological Problems and Empirical Realities. Technical Report. Department of Computer Sciences, University of Texas at Austin.
- [67]Lars Wrenger, Florian Rommel, Alexander Halbuer, Christian Dietrich, and Daniel Lohmann. 2023. LLFree: Scalable and Optionally-Persistent Page-Frame Allocation. In Proceedings of the 2023 USENIX Annual Technical Conference (USENIX ATC). 897–914.
- [68]Michael Young, Avadis Tevanian, Richard Rashid, David Golub, Jeffrey Eppinger, Jonathan Chew, William Bolosky, David Black, and Robert Baron. 1987. The duality of memory and communication in the implementation of a multiprocessor operating system. In Proceedings of the 11th ACM Symposium on Operating System Principles (SOSP). ACM, 63–76. doi:10.1145/1414457.37507
- [69]Junyang Zhang, Xiangcan Xu, Yonghao Zou, Zhe Tang, Xinyi Wan, Kang Hu, Siyuan Wang, Wenbo Xu, Di Wang, Hao Chen, Lin Huang, Shoumeng Yan, Yuval Tamir, Yingwei Luo, Xiaolin Wang, Huashan Wang, Xu Zhenlin Wang, Hongliang Tian, and Diyu Zhou. 2025. CortenMM: Efficient Memory Management with Strong Correctness Guarantees. In Proceedings of the ACM SIGOPS 31st Symposium on Operating Systems Principles (Lotte Hotel World, Seoul, Republic of Korea) (SOSP ’25). Association for Computing Machinery, New York, NY, USA, 1082–1098. doi:10.1145/3731569.3764836







