Have you ever been frustrated by running out of computer memory but unable to add more as easily as plugging in a USB drive? CXL technology was born to solve this problem. It works like an “external expansion system” for memory, allowing servers or workstations to flexibly add large amounts of external memory via dedicated cables and expansion cards, and even let multiple machines share a common memory pool. With CXL technology, 1TB of system memory – once achievable only on expensive mainframes – is becoming increasingly common in high‑performance computing and artificial intelligence.
Why Did CXL Emerge?
We can think of traditional server memory as a large apartment building with individual storage lockers: each room (each server) has its own storage space, but the size of that space is fixed when you move in, and even if your neighbor’s locker is empty, you cannot borrow it. With the growth of artificial intelligence, cloud computing, and big data, this model has begun to show three serious problems.
When the physical slots run out, you cannot add more memory. The number of memory slots on each server motherboard is limited, typically eight, twelve, or sixteen. Even if you fill every slot with the largest capacity memory modules available on the market, the total capacity still hits a ceiling. When your application needs more memory than that ceiling, the only solution is to buy a more expensive, higher‑end server rather than simply adding more memory to the existing machine.
Memory resources cannot be shared, which creates huge waste. In large data centers, different servers often peak at different times. But under traditional architecture, these idle memory resources cannot be “borrowed” by the servers that need them. Industry statistics show that memory utilization in data centers is often below fifty percent, meaning nearly half of the hardware investment sits idle.
To handle sudden demand, companies are forced to over‑invest. When a project occasionally needs twice its normal memory capacity, the traditional solution is to buy hardware that meets the peak demand. That money is spent on capacity that sits unused most of the time. And once those hardware modules are installed, they cannot be flexibly reallocated between different projects or easily expanded as the business grows.
It was to solve all three problems at once – limited physical capacity, inability to share resources, and poor investment efficiency – that engineers designed CXL technology. It fundamentally changes the way memory connects to computing units, turning memory into a resource that can be connected on demand and allocated dynamically.
What Is CXL and How Does It Work?
CXL is an open communication protocol based on the standard PCIe physical interface. Its full name is Compute Express Link, and you can think of it as a set of “language rules” that enable high‑speed, coherent, low‑latency communication between the CPU and external memory devices. What makes CXL unique is that it allows the CPU to treat external memory as if it were part of its own body, rather than as a peripheral that requires a detour to access.
Cache Coherence
Imagine a scenario: you and a colleague are editing the same online document. If each of you saves a local copy and then makes changes, you will run into conflicts when merging – whose changes win? Computer memory faces the same problem. Inside the CPU there is a very fast, small storage area called the “cache” that holds copies of data recently used from main memory. When the CPU accesses memory, it reads from the cache first, which is much faster. But if both the local DDR memory and the external CXL memory hold copies of the same data, and one copy is modified, the other copy must be updated accordingly. Otherwise the CPU could read incorrect data. This problem is called “cache coherence.” CXL includes a dedicated sub‑protocol to handle this, constantly “communicating” between the CPU and the external memory to ensure that all copies stay consistent.
Memory Pooling and Flexible Allocation
Under the traditional approach, each server can only use the memory in its own slots. CXL introduces the concept of “pooling”: you can connect several CXL memory devices to a CXL switch, forming a single large‑capacity memory pool, and then let multiple servers “draw” memory from this pool as needed. It is like an office building replacing individual water coolers in each office with a central water station in the hallway, where everyone takes water on demand. The total capacity of the water station can be smaller than the sum of ten individual coolers, yet it still meets everyone’s needs because their peak usage times do not coincide. Similarly, a CXL memory pool allows data center managers to dynamically allocate memory based on each server’s real‑time load – giving more when busy and reclaiming it when idle – thus supporting more computing tasks with less total hardware.
What Does CXL Technology Include?
CXL is a complete memory solution that encompasses everything from physical hardware to software configuration. You can think of this system as a highway: the road itself (the physical connection) is only the foundation; you also need traffic rules (the communication protocol) to keep vehicles moving in an orderly fashion, and you need a traffic management system (the software configuration) to direct vehicles where to go and which lane to use. Missing any of these layers, the highway cannot truly operate.
Hardware Layer: The Visible Components
The physical part of CXL technology includes various types of devices, which together form the infrastructure for memory expansion. The most common hardware is the CXL memory expansion card, which looks similar to a graphics card and can be plugged directly into an existing PCIe slot on a server motherboard. This card has memory chips soldered on or slots for memory modules. Once inserted, the system recognizes the additional memory capacity. Another hardware form factor is the CXL memory module, which is smaller – like a compact solid‑state drive – and can be installed in dedicated server drive bays, making it suitable for high‑density deployments.
When you need to connect multiple servers or multiple memory devices, a CXL switch comes into play. It resembles a network switch, but instead of switching network packets, it switches memory access requests. Through a CXL switch, administrators can connect several CXL memory cards together to form a unified large‑capacity memory pool, then allow multiple servers to share the resources of that pool simultaneously. For longer distances, dedicated CXL cables can maintain high‑speed transmission over distances of several meters or even tens of meters, allowing memory devices to be placed in different racks from the servers.
Protocol Layer: The Language Rules for Communication
If hardware is the skeleton, the protocol is the soul that makes everything work. The CXL protocol includes three parallel sub‑protocols, each responsible for a different task. They can work simultaneously without interfering with each other.
- The first sub‑protocol is called CXL.io, and its job is device discovery and initialization. When you insert a CXL memory card into a server, CXL.io is responsible for letting the CPU recognize the device, read its basic information (such as capacity and supported modes), and allocate address space for it. This process is very similar to plugging in a graphics card or a network card.
- The second sub‑protocol is called CXL.cache, which is one of the core features of CXL. CXL.cache maintains data consistency between the CPU’s cache and the external memory. As described earlier, when the CPU modifies a piece of data, CXL.cache ensures that the corresponding copy in the external memory is also updated, and vice versa.
- The third sub‑protocol is called CXL.mem, which handles the actual data reads and writes. When the CPU needs to read a piece of data from CXL memory, CXL.mem transmits the request and returns the data; when the CPU needs to write data to CXL memory, CXL.mem similarly performs the transfer.
Software Layer: Configuration and Management to Make Everything Work
Software configuration makes it possible for the operating system and applications to actually use this new memory. In the BIOS, the administrator needs to enable CXL functionality and allocate resources. At the operating system level, taking Linux as an example, CXL memory is recognized as a separate NUMA node, and the administrator can use commands to specify whether a program should prefer local memory or CXL memory. Modern operating systems also support memory tiering, which automatically keeps the most active data in fast local DDR and migrates less active data to CXL memory. The vast majority of applications do not need any code modification to use CXL memory, because the operating system manages it just like regular memory.
CXL vs. Traditional Memory Solutions
| Aspect | Traditional DDR Solution | CXL Solution |
|---|---|---|
| Capacity ceiling | Limited by motherboard memory slots and maximum module capacity; cannot expand further once the ceiling is reached | Can continue adding memory via CXL expansion cards or switches without replacing the motherboard |
| Resource flexibility | Each server’s memory is fixed; cannot be reallocated between servers | Supports memory pooling; multiple servers can share a common memory pool on demand |
| Cost efficiency | Buying large amounts of memory to meet peak demand; daily utilization often below 50% | Supports the same workload with less total memory; utilization can exceed 80% |
| Expansion operation | Requires shutdown, physical insertion/removal of memory modules; may involve hardware replacement | Supports hot‑plug and dynamic allocation; can add or remove memory resources online |
| Suitable scenarios | Small‑scale deployments with extreme performance requirements and stable workloads | Large‑scale data centers, AI training, cloud computing, and other scenarios requiring elastic resources |
As the table shows, the traditional DDR solution still has advantages in extreme performance and simple deployment, but at the cost of high expense and rigid resource management. In contrast, the CXL solution sacrifices a small amount of access speed in exchange for huge benefits: expandable capacity, sharable resources, and better cost efficiency. In real‑world data center operations, this trade‑off is often very worthwhile, because idle memory waste is far more painful than a small speed difference.
Use Cases for CXL
CXL is not meant to replace traditional memory; it is meant to solve specific scenarios that traditional memory struggles with. The three areas below are where CXL has the most mature deployments and delivers the clearest value.
Artificial Intelligence and Large Model Training
Training a large language model with hundreds of billions of parameters requires loading the entire model parameters, training data, and intermediate calculation results into memory at the same time. When the model size exceeds the memory capacity of a single server, CXL allows one server to directly attach several terabytes of CXL memory, holding all data within a single node – greatly simplifying the programming model and improving training efficiency. For mid‑sized teams working on large models, CXL offers a more economical path than buying expensive mainframes.
Data Center Memory Pooling
In large cloud data centers, the peak loads of different tenants and applications often occur at different times. By deploying CXL switches and a CXL memory pool, the data center can gather all idle memory into a shared pool and dynamically allocate it according to each server’s real‑time needs. Industry estimates suggest this approach can raise memory utilization from the typical forty to fifty percent to above eighty percent – meaning the same hardware investment can support nearly twice the computing workload.
Cloud Computing and Virtual Machine Density
Cloud service providers want to run as many virtual machines (VMs) as possible on a single physical server to increase revenue. But each VM must be allocated a fixed amount of memory, and even if that memory is not actually used much, it cannot be occupied by other VMs. As a result, servers often run out of memory long before their CPU resources are exhausted, limiting the number of VMs that can be created. A CXL memory pool allows the cloud platform to treat memory as an elastic resource for oversubscription or dynamic adjustment: when a VM is using less memory than allocated, the surplus can be reclaimed and given to other VMs. This technology lets cloud providers host more tenants on the same physical servers, lowering operating costs.
Beyond these three main use cases, CXL is also used in large‑scale simulations in high‑performance computing, capacity expansion for in‑memory databases (such as SAP HANA), and acceleration of real‑time big data analytics engines (such as Apache Spark). What these applications share is a very high demand for memory capacity combined with a certain tolerance for latency – exactly the range where CXL excels.
Current State and Future Outlook for CXL
CXL has moved from the lab into real deployment. On the hardware side, Intel’s 4th Gen Xeon Scalable and AMD’s 4th Gen EPYC processors natively support CXL 1.1 or 2.0. Major server vendors like Dell, HPE, Inspur, and Supermicro offer CXL memory options in their high‑end lines. Samsung and Micron now mass‑produce CXL memory modules ranging from 128GB to 512GB, some with hot‑plug support. On the software side, the Linux kernel has supported CXL natively since version 5.18, and major cloud operating systems are gradually improving CXL memory pooling.
Looking ahead, CXL is evolving along two main tracks. The first is protocol upgrades. CXL 2.0 introduced memory pooling and switch support, already being trialed. CXL 3.0 increases bandwidth to 64 GB/s and adds multi‑level switching, expected to spread after 2026. CXL 4.0, based on PCIe 7.0, is planned to roughly double bandwidth again. The second track is deployment evolution. In the short term, CXL acts as a “second tier” memory complementing local DDR. In the medium term, memory pooling will become standard in large data centers, making memory dynamically allocatable like compute and storage. In the long term, CXL and DDR will likely coexist: DDR for latency‑sensitive core workloads, CXL for large‑capacity, sharable expansion memory.
CXL technology emerged as an answer to a question that has long troubled the computing industry: why can’t memory be flexibly expanded and shared like storage? CXL technology, through an elegant protocol design, builds key capabilities such as cache coherence and memory pooling on top of the existing PCIe infrastructure. From hardware to software, from single‑machine expansion to data‑center‑wide resource sharing, CXL is gradually changing how we think about memory. Of course, this technology is still in its early stages; protocol maturity, ecosystem completeness, and cost reduction will all take time. But what is certain is that as AI models continue to grow and data sizes keep breaking physical boundaries, CXL – which frees memory from fixed slots – will become an increasingly essential piece of infrastructure in the world of high‑performance computing.
