Resource Partitioning for Predictable Multicore Execution

35 concepts29 papers1 proposal

As hardware architectures scale to many-core designs to bypass physical power limits, software systems face a fundamental challenge: shared resource contention. In a single-core system, execution time is relatively easy to predict. But in a multicore environment, cores share critical infrastructure like last-level caches (LLCs), translation lookaside buffers (TLBs), and memory buses.

As Luca Benini highlights in Predictability vs. Efficiency in the Multicore Era: Fight of Titans or Happy Ever after?, this sharing introduces non-deterministic execution delays. A high-priority, safety-critical task running on one core can have its data evicted or its memory requests delayed by an unrelated, memory-intensive background task on another core. To bridge this predictability gap, researchers have developed techniques to partition hardware resources, transforming shared, chaotic environments into isolated, deterministic channels.

Software-Defined Cache Partitioning via Cache Coloring

One of the most elegant ways to isolate workloads without modifying underlying hardware is software-defined cache partitioning, commonly known as cache coloring.

To understand why this works, consider how a set-associative cache operates. When a core requests data from physical memory, the cache uses specific index bits within the physical address to determine which cache set (or row) the data must reside in. If two concurrent tasks map their data to the same cache sets, they will continuously evict each other's lines, causing severe latency spikes.

Cache coloring solves this at the operating system or hypervisor level by manipulating the virtual-to-physical memory mappings via the Memory Management Unit (MMU). As explained by Ashutosh Pradhan et al. in Arm DynamIQ Shared Unit and Real-Time: An Empirical Evaluation, software can allocate physical memory pages such that different workloads are assigned non-overlapping cache sets. By "coloring" the pages, Core A only allocates "red" sets, while Core B only allocates "blue" sets.

Ayoosh Bansal et al. demonstrate in Evaluating memory subsystem of configurable heterogeneous MPSoC that implementing this hypervisor-based cache partitioning stabilizes memory access latency by completely preventing cross-core cache evictions. To push isolation even further on heterogeneous chips, Tomasz Kloda et al. in Lazy Load Scheduling for Mixed-criticality Applications in Heterogeneous MPSoCs combine hypervisor-level cache coloring with dedicated hardware scratchpad memories instantiated in programmable logic. This multi-layer approach ensures that critical tasks not only have isolated cache space but can also bypass the main system bus entirely during heavy traffic.

Hardware-Enforced Cache and Buffer Isolation

While cache coloring partitions a cache horizontally by sets, hardware-level mechanisms allow for vertical partitioning across cache ways. In a set-associative cache, each set contains multiple slots, or ways, where data can be stored.

Gang Chen et al. demonstrate in Resource Management in Real-time Multicore Embedded Systems: Performance and Energy Perspectives that by assigning specific cache ways exclusively to individual tasks, the hardware eliminates inter-core interference. This way-based partitioning ensures that a core can never evict data belonging to a protected way, providing the strict isolation required for reliable worst-case execution time (WCET) analysis.

Modern systems-on-chip (SoCs) extend this hardware-enforced isolation beyond the cache hierarchy to other shared structures like TLBs and interconnects. For example, Christopher Reinwardt et al. introduce modular hardware extensions in CVA6-VMRT: A Modular Approach Towards Time-Predictable Virtual Memory in a 64-bit Application Class RISC-V Processor that partition the TLB and lock entries, reducing execution time variability by up to 94%. Furthermore, Angelo Garofalo et al. show in A Reliable, Time-Predictable Heterogeneous SoC for AI-Enhanced Mixed-Criticality Edge Applications that combining cache isolation with hardware-enforced traffic shaping prevents high-throughput AI workloads from degrading the deterministic latency required by safety-critical control tasks.

Spatial Isolation via Core Pinning and Thread Mapping

Resource isolation also operates at the compute level by managing how tasks are mapped to physical processing units. If a critical task frequently migrates between cores, or shares a core with a noisy neighbor, it suffers from context-switching overhead and local cache invalidation.

To counter this, designers use spatial isolation—pinning specific software processes to dedicated physical cores. Miguel Alcon et al. demonstrate this in Dynamic and execution views to improve validation, testing, and optimization of autonomous driving software, showing that pinning critical autonomous driving processes to specific cores prevents background applications from competing for local cache resources. Similarly, in high-performance computing, Sarp Oral et al. show in End-to-end I/O portfolio for the summit supercomputing ecosystem that dedicating specific CPU cores exclusively to background I/O operations eliminates execution jitter for primary computational tasks.

In virtualized and multi-processor environments, this deterministic resource mapping is vital. Ashish Tapdiya notes in Performance Variations in Profiling Mysql Server on the Xen Platform: Is It Xen or Mysql? that pinning virtual processing units to physical cores eliminates hypervisor scheduling jitter. Taking this further, Song Wu et al. propose a framework in A Real-Time Scheduling Framework Based on Multi-core Dynamic Partitioning in Virtualized Environment that dynamically partitions physical processors into dedicated real-time and non-real-time pools to guarantee deadlines. For parallel workloads, Binqi Sun demonstrates in Strict Partitioning for Sporadic Rigid Gang Tasks that dividing a multi-processor system into disjoint partitions for parallel "gang tasks" eliminates inter-partition interference, allowing for exact mathematical schedulability tests.

Even on highly parallel commodity hardware like GPUs, spatial isolation can be enforced via software. Nikolaos Andriotis et al. show in A Software-Only Approach to Enable Diverse Redundancy on Intel GPUs for Safety-Related Kernels that by using hardware-specific intrinsics to identify execution units at runtime, software can map redundant computations to distinct physical thread clusters. This creates a software-defined lockstep mechanism that ensures redundant tasks never share local hardware resources like instruction caches or local schedulers.

Mitigating Interconnect and Bus Contention

Even when cores and caches are perfectly isolated, tasks can still collide at the memory bus bottleneck. If multiple cores attempt to access main memory simultaneously, the shared command and data lines become congested, introducing variable delays.

To eliminate this channel contention, Javier Jalle et al. propose a space-sharing approach in Data Bus Slicing for Contention-Free Multicore Real-Time Memory Systems. By slicing a wide, shared memory data bus into narrower, private data channels dedicated to each core, their architecture enables time-composable memory access, tightening worst-case execution time estimates by up to 51%.

When hardware bus slicing is unavailable, systems must rely on temporal isolation or kernel-level blocking policies. As surveyed by Qingling Zhao in A State-of-the-Art Survey on Real-Time Issues in Embedded Systems Virtualization, temporal isolation is frequently enforced via strict Time-Division Multiple Access (TDMA) scheduling, which assigns fixed, non-overlapping execution windows to each virtual machine. Finally, to protect real-time schedules from sophisticated timing-based side-channel attacks, Jiyang Chen et al. introduce SchedGuard: Protecting against Schedule Leaks Using Linux Containers, which uses kernel-level resource grouping to selectively apply blocking policies to untrusted containers while allowing trusted tasks to proceed without interference.

Key Foundational Work

Predictability vs. Efficiency in the Multicore Era: Fight of Titans or Happy Ever after? (2009) — contributed 1 concept elements to this direction.
A programming model for deterministic task parallelism (2011) — contributed 1 concept elements to this direction.
History & citationVersion 1 · 2026-10-04

Current · Permanent link

View frozen version 1

Cite this direction

Latest version (a living page):

@misc{lacuna_cache_coloring_b9a35e01,
  title = {cache coloring},
  author = {{Lacuna}},
  howpublished = {Lacuna research direction},
  year = {2026},
  url = {https://lacuna.tiptreesystems.com/direction/cache-coloring/rdr_b9a35e016e2e41f99c674396c3e36550},
  note = {Latest version of a living research direction; cite a version for a fixed text. Accessed 2026-11-19},
}

This exact version (version 1, frozen text):

@misc{lacuna_cache_coloring_b9a35e01_v1,
  title = {cache coloring},
  author = {{Lacuna}},
  howpublished = {Lacuna research direction},
  year = {2026},
  url = {https://lacuna.tiptreesystems.com/direction/cache-coloring/rdr_b9a35e016e2e41f99c674396c3e36550/v/1},
  note = {Version 1, frozen 2026-10-04. Accessed 2026-11-19},
}
About

These directions overlap with this one through shared papers.

See something wrong? Report a mistake