The Architecture of Resource Disaggregation

164 concepts110 papers1 proposal

For decades, data centers have been built out of monolithic servers. A typical server box contains a fixed ratio of CPU cores, RAM, and storage drives. While this "pizza box" design is simple to deploy, it introduces a fundamental inefficiency in cloud environments: resource stranding.

If a workload requires massive amounts of memory but very little computing power, it will exhaust a server's RAM while leaving its CPU cores sitting idle. Conversely, a compute-heavy task might starve for CPU cycles while its allocated storage goes unused. As argued by Ruihong Wang et al. in The Case for Distributed Shared-Memory Databases with RDMA-Enabled Memory Disaggregation, this tight coupling leads to severe resource fragmentation and inflated operational costs.

Resource disaggregation solves this problem by breaking open the server box. Instead of self-contained servers, a disaggregated data center organizes hardware into independent, specialized pools of compute, memory, and storage connected by an ultra-fast network fabric.


The Core Mechanism: Breaking the Box

In a disaggregated architecture, resources scale independently. If your application experiences a sudden spike in data volume but not in query complexity, you can provision more storage nodes without paying for unneeded CPU cores.

Monolithic Architecture:
[ CPU + RAM + Storage ] x 100 Servers  --> Fixed Ratios, High Stranding

Disaggregated Architecture:
[ Compute Pool ] <=======> [ Memory Pool ] <=======> [ Storage Pool ]
       (Dynamically allocated via high-speed interconnects)

To understand why this works, we must look at the interconnect. Historically, separating a CPU from its memory was unthinkable because the network was orders of magnitude slower than a local motherboard bus. However, the rise of ultra-fast technologies like Remote Direct Memory Access (RDMA) and advanced optical networking has flipped this assumption. RDMA allows a compute node to read or write directly to a remote memory pool with sub-microsecond latency, bypassing the remote operating system entirely.

By eliminating the network software stack overhead, disaggregation achieves the elasticity of the cloud with the performance of local hardware. As Chenyuan Wu et al. demonstrate in FlexChain: An Elastic Disaggregated Blockchain, physically separating these layers challenges the long-held intuition that network latency is an insurmountable bottleneck, proving highly feasible even for throughput-sensitive workloads like smart contracts.


Why It Works: Zero-Migration Elasticity

In traditional distributed systems, scaling a cluster requires "resharding" or migrating data. If a database node runs out of space, you must spin up a new server and copy gigabytes of data over the network—a process that can take minutes or hours and degrades performance.

Disaggregation changes the cost of scaling from a heavy data-copying operation to a simple pointer reassignment. For example, Jiacheng Shen et al. explore this advantage in Ditto: An Elastic and Adaptive Memory-Disaggregated Caching System. Because the compute layer is stateless and the memory layer is a shared pool, a caching system can adapt to traffic bursts or reallocate memory near-instantly. There are no multi-minute delays or throughput drops because no data actually moves; the system merely adjusts which compute nodes are mapped to which memory addresses.


Rethinking Software for Disaggregated Hardware

While disaggregation offers massive infrastructure benefits, it breaks traditional software assumptions. For forty years, database engines were designed under the assumption that local memory is fast and remote access is slow.

In Understanding the Effect of Data Center Resource Disaggregation on Production DBMSs, Qizhen Zhang et al. point out that classic database internal strategies—such as buffer pool management and traditional join algorithms—become inefficient in disaggregated environments. When memory is remote, a database can no longer rely on standard caching policies designed for local RAM. Instead, software must be co-designed with the hardware substrate to minimize network round-trips.

This architectural shift is pushing systems to disaggregate not just physical hardware, but logical services as well. In Concurrency Control as a Service, Weixing Zhou et al. show that transaction management requires entirely different scaling logic than query execution or storage. By pulling concurrency control out into its own independent, sharded service layer, modern cloud-native databases can avoid over-provisioning and achieve significantly higher throughput.

Ultimately, resource disaggregation succeeds because it aligns hardware deployment with the fluid reality of cloud workloads. By turning rigid physical servers into fluid, software-defined pools of capacity, it maximizes utilization and unlocks a level of elasticity that monolithic architectures simply cannot match.

History & citationVersion 2 · 2026-10-04

Current · Permanent link

  1. Version 2 (latest) · 2026-10-04 · 107 papers
  2. Version 1 · 2026-10-04 · 138 papers
Cite this direction

Latest version (a living page):

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

This exact version (version 2, frozen text):

@misc{lacuna_resource_disaggregation_96dc13c5_v2,
  title = {resource disaggregation},
  author = {{Lacuna}},
  howpublished = {Lacuna research direction},
  year = {2026},
  url = {https://lacuna.tiptreesystems.com/direction/resource-disaggregation/rdr_96dc13c593e8481faa2ab919d3729712/v/2},
  note = {Version 2, frozen 2026-10-04. Accessed 2026-11-19},
}
About

These directions overlap with this one through shared papers.

See something wrong? Report a mistake