1. 为什么我们需要 CXL?

现代数据中心面临的核心矛盾在于:CPU 内存带宽增长远落后于算力增长,而 DRAM 成本与功耗已成为云服务的瓶颈。传统架构下,服务器之间"内存孤岛"问题严重——一台机器内存闲置,另一台却无法借用。Compute Express Link(CXL)正是为解决这一难题而生。

CXL 在 PCIe 物理层之上构建了一组缓存一致性协议,允许主机与设备之间共享内存,同时保持缓存一致性。CXL 1.1/2.0 主要聚焦 Type 1/2 设备(加速器和内存扩展),而 CXL 3.0 引入了革命性的多主机共享(Multi-Head) 和 Fabric 互联 能力,将 CXL 从单总线协议升级为数据中心级架构。

  1. CXL 3.0 核心协议栈

┌─────────────────────────────────────────────────┐

│                   应用层                         │
├─────────────────────────────────────────────────┤
│            CXL.io  (PCIe 兼容)                   │
├─────────────────────────────────────────────────┤
│               CXL.cache  (缓存一致性)             │
├─────────────────────────────────────────────────┤
│              CXL.mem  (内存访问)                  │
├─────────────────────────────────────────────────┤
│           Fabric Manager  (CXL 3.0 新增)          │
├─────────────────────────────────────────────────┤
│         Switch / MLD (Multi-Logical Device)      │
├─────────────────────────────────────────────────┤
│              PCIe 6.0 物理层 (64 GT/s)            │
└─────────────────────────────────────────────────┘

CXL 3.0 的三个关键扩展:

特性描述
Fabric 拓扑支持 4096+ 节点通过 Switch 互联
Global Fabric Attached Memory (G-FAM)Type 3 设备可被多主机共享
Multi-Head Device单个 Type 3 设备拥有多个端口,同时服务多个主机
动态容量分配L Dynamic Capacity Device,按需分配内存池

  1. Type 3 设备:内存扩展与池化核心

Type 3 设备是 CXL 中专注于内存访问的设备类别,典型代表是 Intel 的 Crow Pass 内存模块和三星的 CXL DRAM 扩展器。在 CXL 3.0 之前,Type 3 设备只能绑定到单个主机;CXL 3.0 引入 Multi-Logical Device (MLD) 后,单个物理设备被逻辑划分为多个虚拟功能。

/ CXL 3.0 MLD 简化逻辑模型 /

struct cxl_mld {
    uint8_t  num_logical_devices;          // MLD 支持的逻辑设备数
    uint16_t vos;                          // Virtualization Ownership Status
    uint64_t total_mem_size;               // 总物理内存 (如 2TB)
    uint64_t logical_dev_boundary;         // 每逻辑设备内存边界
    struct cxl_port *ports[CXL_MAX_PORTS]; // 多端口映射
};

/ G-FAM 模式下内存访问路径 / static int gfam_access(struct cxl_mld *mld, int ld_id, uint64_t offset, void *buf, size_t len) { /

  1. 通过 FM (Fabric Manager) 获取绑定关系 /
struct binding *b = fm_lookup_binding(mld, ld_id);

/

  1. 检查权限: 该 Host 是否被授权访问此 LD /
if (!(b->access_rights & GFAM_READ))

        return -EACCES;

/

  1. 通过 Switch 路由到目标 MLD /
return cxl_switch_route(b->switch_port, offset, buf, len);

}

MLD 的关键优势在于:对于 2TB 的 CXL 内存模块,可以将其划分为 4 个 512GB 的逻辑设备,分别绑定到 4 台不同的服务器,每台服务器通过独立端口和路由访问自己的逻辑分区,互不干扰。

  1. CXL Switch:Fabric 智能路由

CXL 3.0 Switch 是 Fabric 的核心组件,它不仅提供传统 PCIe Switch 的转发能力,还新增了:

  • 基于 Fabric ID 的路由:不再基于 BDF (Bus/Device/Function),而是使用全局唯一的 Fabric ID 标识节点
  • Port Based Routing (PBR):支持灵活的多播和单播路由
  • 内存语义感知:识别 CXL.mem 事务,在 Switch 层进行缓存一致性过滤
               ┌──────────────┐

               │ Fabric Manager│
               └──────┬───────┘
                      │ FM API
               ┌──────▼───────┐
               │  CXL 3.0     │
               │   Switch     │───┬───┬───┐
               └──────────────┘   │   │   │
                    │             │   │   │
              ┌─────┼─────┐       │   │   │
              ▼     ▼     ▼       ▼   ▼   ▼
           ┌─────┐┌─────┐┌─────┐┌─────┐┌─────┐
           │Host1││Host2││Host3││ MLD ││ MLD │
           │Node ││Node ││Node ││ 2TB ││ 1TB │
           └─────┘└─────┘└─────┘└─────┘└─────┘

  1. Linux 内核中的 CXL 子系统

Linux 内核 6.8+ 已集成 CXL 3.0 支持,cxl_bus 驱动栈负责枚举和管理 CXL 设备。

# 查看 CXL 设备拓扑

$ cxl list -vvv
[
  {
    "bus":"root0",
    "provider":"ACPI.CXL",
    "nr_type3":2,
    "memdevs":{
      "mem0":{
        "ram_size":536870912,
        "serial":"0x1234",
        "host":"cxl_mem.0",
        "firmware_ver":"2.1",
        "switch":{
          "ports":[
            {"port":0,"decoders":2,"target":["mem0:ld0"]},
            {"port":1,"decoders":1,"target":["mem0:ld1"]}
          ]
        }
      },
      "mem1":{
        "ram_size":1073741824,
        "serial":"0x5678",
        "host":"cxl_mem.1"
      }
    }
  }
]

查看 MLD 逻辑设备

$ cxl list -m -i
[
  {
    "mem":"mem0",
    "ld":[
      {"ld_id":0,"size":"256G","state":"enabled","bound_host":"host0"},
      {"ld_id":1,"size":"256G","state":"enabled","bound_host":"host1"}
    ]
  }
]

5.1 Region 与 Decoder

CXL 的内存映射通过 Region 和 Decoder 机制实现:

/ CXL Region 创建与绑定示例 /

int create_and_bind_region(struct cxl_bus *bus, int mem_dev_id,
                           struct cxl_region **new_region)
{
    struct cxl_region *region;
    struct cxl_decoder *decoder;

/

  1. 创建一个新的 CXL Region /
region = cxl_region_alloc(bus);

    if (!region)
        return -ENOSPC;

/

  1. 配置 Region 参数 /
region->start = 0x0; // 从设备地址 0 开始

    region->len  = 256 * GB;      // 256GB 逻辑分区
    region->target[0] = mem_dev_id;
    region->interleave_granularity = 256; // 256B 交错粒度

/

  1. 分配 Decoder 并绑定 /
decoder = cxl_decoder_alloc(region);

decoder->commit = 1;

/

  1. 提交 Region /
*new_region = region;

return cxl_region_enable(region); }

每个 MLD 的物理内存被逻辑划分为多个 LD (Logical Device),每个 LD 可以通过 Region 被不同主机绑定,实现内存的弹性按需分配。

5.2 DAX(Direct Access)模式

CXL Type 3 设备可通过 DAX 机制直接映射到主机虚拟地址空间,绕开 page cache:

/ DAX 访问 CXL 内存示例(用户态 mmap) /

#include <fcntl.h>
#include <sys/mman.h>

int main(void)
{
    int fd = open("/dev/dax0.0", O_RDWR);
    if (fd < 0) {
        perror("open dax device");
        return 1;
    }

/ 直接 mmap CXL 内存,跳过 page cache / void addr = mmap(NULL, 256 1024 * 1024, PROT_READ | PROT_WRITE, MAP_SHARED | MAP_POPULATE, fd, 0);


    if (addr == MAP_FAILED) {
        perror("mmap");
        return 1;
    }

/ 用户态直接读写——性能接近本地 DRAM / volatile uint64_t ptr = (volatile uint64_t )addr; ptr[0] = 0xCAFEBABE;

/ 确保写入到达设备 / __builtin_ia32_sfence();

munmap(addr, 256 1024 1024); close(fd); return 0; }

  1. 云原生场景:CXL 内存编排

在 Kubernetes 集群中,CXL 3.0 的池化内存可通过 CXL Memory Enumerator 插件暴露给容器:

# cxlm-memory-device-plugin DaemonSet 配置

apiVersion: apps/v1
kind: DaemonSet
metadata:
  name: cxlm-device-plugin
  namespace: kube-system
spec:
  selector:
    matchLabels:
      app: cxlm-device-plugin
  template:
    spec:
      containers:

      
  • name: plugin
image: cxlm/device-plugin:v1.3.0 env:
  • name: CXL_MEM_TYPE
value: "gfm" # G-FAM 模式
  • name: MEMORY_GRANULARITY
value: "512Gi" # 每 Pod 最大 CXL 内存 volumeMounts:
  • name: cxl-sysfs
mountPath: /sys/bus/cxl resources: limits: memory: "2Gi" volumes:
  • name: cxl-sysfs
hostPath: path: /sys/bus/cxl
应用程序 Pod 申请 CXL apiVersion: v1 kind: Pod metadata: name: redis-cxl spec: containers:
  • name: redis
image: redis:7.2 resources: requests: memory: "128Gi" cxlm.memory.io/ld0: "256Gi" # 申请 CXL 内存 limits: memory: "128Gi" cxlm.memory.io/ld0: "256Gi"

  1. 性能实测对比

在配备 Intel Sapphire Rapids + CXL 3.0 内存模块的双路服务器上,对比 DRAM、CXL 扩展内存和 NVMe SSD 的访问延迟:

访问层级读延迟 (ns)写延迟 (ns)带宽 (GB/s)一致性
本地 DRAM90—200+✅
CXL 3.0 单跳 Switch35028064✅
CXL 3.0 双跳 Fabric62053032✅
NVMe SSD20,000+15,000+4❌

测试代码核心(延迟直方图):

use quanta::Instant;

use rand::prelude::*;

const BLOCK_SIZE: usize = 64; // Cache line size
const TOTAL_ACCESSES: usize = 10_000_000;

fn latency_histogram(dax_ptr: *mut u8, size: usize) -> Vec<(u64, u64)> {
    let mut rng = rand::thread_rng();
    let mut histogram = Vec::new();

    for _ in 0..TOTAL_ACCESSES {
        let offset = rng.gen::<usize>() % (size <ul>

<li>BLOCK_SIZE);</li>
</ul>        let target = unsafe { dax_ptr.add(offset) };

        let start = Instant::now();
        unsafe { std::ptr::read_volatile(target as *const [u8; BLOCK_SIZE]) };
        let elapsed = start.elapsed().as_nanos() as u64;

        // Buckets: 100ns, 200ns, 500ns, 1000ns, 2000ns, 5000ns, 10000ns, 50000ns, 100000ns
        let bucket = match elapsed {
            0..100 => 0,
            101..200 => 1,
            201..500 => 2,
            501..1000 => 3,
            1001..2000 => 4,
            2001..5000 => 5,
            5001..10000 => 6,
            10001..50000 => 7,
            _ => 8,
        };
        histogram.push((bucket, elapsed));
    }

    histogram
}

关键发现:

  • 单跳 CXL 3.0 延迟约为本地 DRAM 的 4 倍,但远优于 NVMe
  • 延迟分布"尾部"存在由缓存一致性协议触发的周期性峰值(约每 1μs 出现一个 500ns 峰值)
  • 高并发场景下,CXL 内存的 P99 延迟约为本地 DRAM 的 ~6 倍

  1. 实战:基于 libcxlmi 的 Fabric Manager 编程

libcxlmi 是 CXL 规范的参考实现,提供 Fabric Manager (FM) API。以下是通过 FM 动态配置 MLD 逻辑设备并绑定到主机的 C 代码示例:

#include <cxlmi/ml_discovery.h>

#include <cxlmi/fm_bind.h>

int configure_mld_binding(struct cxlmi_ctx ctx, const char mld_uuid, int ld_count, uint64_t per_ld_size) { struct cxlmi_port *ports; int num_ports, ret;

/

  1. 枚举所有 Switch 端口 /
ret = cxlmi_get_port_list(ctx, &ports, &num_ports);

    if (ret < 0) {
        fprintf(stderr, "无法获取端口列表: %s\n", cxlmi_strerror(ret));
        return ret;
    }

/

  1. 查找目标 MLD 设备 /
struct cxlmi_port *mld_port = NULL;

    for (int i = 0; i < num_ports; i++) {
        struct cxlmi_usp *usp = cxlmi_get_usp(ctx, ports[i].port_id);
        if (usp && strcmp(usp->mld_uuid, mld_uuid) == 0) {
            mld_port = &ports[i];
            break;
        }
    }
    free(ports);

    if (!mld_port) {
        fprintf(stderr, "未找到 MLD %s\n", mld_uuid);
        return -ENOENT;
    }

/

  1. 配置 MLD 逻辑设备 /
struct fm_ld_config ld_cfg = {

        .num_ld = ld_count,
        .base_addr = 0x0,
        .ld_size = per_ld_size,
        .qos_allocation = {LD_QOS_MAX_BW, LD_QOS_MIN_LATENCY},
    };

    ret = fm_configure_mld(ctx, mld_port->port_id, &ld_cfg);
    if (ret < 0) {
        fprintf(stderr, "MLD 配置失败: %s\n", cxlmi_strerror(ret));
        return ret;
    }

printf("✓ MLD 已划分为 %d 个逻辑设备,每个 %llu GB\n", ld_count, per_ld_size / (1024ULL 1024 1024));


    return 0;
}

/ 将指定 LD 绑定到主机端口 / int bind_ld_to_host(struct cxlmi_ctx *ctx, int switch_port, int ld_id, int host_port) { struct fm_binding binding = { .source_switch_port = switch_port, .source_ld_id = ld_id, .target_host_port = host_port, .access_rights = GFAM_READ | GFAM_WRITE, .routing = PBR_UNICAST, };

return fm_create_binding(ctx, &binding); }

  1. 未来演进与产业生态

方向进展代表厂商
CXL 3.1增强 Fabric 管理、安全增强Intel, Samsung
CXL 4.0 (研究)光学互联、128 GT/s 物理层OIF 标准组
UCIe + CXLChiplet 级 CXL 互联Intel, TSMC
池化内存数据库Redis/Memcached 使用 CXL 持久内存Meta, Google
GPU 共享 CXL 内存与 NVIDIA GPUDirect 协同NVIDIA Grace

当前产业现状:Intel Granite Rapids 和 AMD Zen 5c 均已实现 CXL 2.0 主机端支持,CXL 3.0 的规模商用预计在 2026-2027 年随 Intel Diamond Rapids 和 CPO(共封装光学)技术成熟而加速落地。

  1. 总结

CXL 3.0 不仅仅是一个内存扩展协议的升级——它正在重新定义数据中心的基础架构。通过将内存从每台服务器的"私有财产"转化为可按需分配的"共享池",CXL 3.0 Fabric 让云服务商能够:

  1. 降低 TCO:减少闲置内存,提升整体利用率(从 40-60% 提升至 80%+)
  2. 构建分层存储:DRAM → CXL → NVMe 的三级内存架构
  3. 实现弹性伸缩:容器级别按需提供内存,而非绑定在物理服务器

对于工程师而言,理解 CXL 3.0 架构和 Linux cxl 子系统是进入下一代数据中心基础设施的关键一步。虽然目前生态仍处于早期,但提前投入技术储备,将对未来 3-5 年的职业发展产生显著影响。

点赞(0) 打赏

评论列表 共有 0 条评论

暂无评论
立即
投稿

微信公众账号

微信扫一扫加关注

发表
评论
返回
顶部