从单机侵入式 LRU 到大模型分布式 KV 记忆池:C++ 缓存内核与 AI 时代的架构演进

把下面两个看似相隔甚远的工程事故放在一起对照,会发现它们撞上的是同一堵物理墙:

第一个现场在单机 C++ 核心服务里。工程师照着算法教科书的满分模板,用 std::unordered_map<uint64_t, ListIter> 搭配 std::list<std::pair<uint64_t, uint64_t>> 写了一个内存淘汰缓存。上线后一算账:明明每条业务数据只有 8B Key + 8B Value = 16 字节,装进一亿条记录后进程物理内存竟然飙到了 10 GB 以上;更糟的是,明明时间复杂度是严格的理论 \(O(1)\),放到 64 核服务器上跑纯读压测,吞吐不仅上不去,反而比单线程裸跑还要慢。

第二个现场在千卡大模型推理集群里。一个执行代码库重构任务的智能体(Agent)带着 128K 历史上下文发起第 20 轮工具调用,单次会话在 70B 模型各层产生的注意力键值张量(KV Cache)高达数十 GB。团队最初想当然地试图拿传统缓存协议去存这份中间状态:SET session:9527 <tensor_bytes>。结果上线即雪崩——每轮对话末尾只要多拼上几十个新输出 Token,整串输入的哈希键就彻底改变,精确键查找命中率直接归零;哪怕强行切块命中,走内核 TCP 协议栈加主机堆内存反序列化拉回几 GB 张量的耗时,比让 GPU Tensor Core 从头把十万个 Token 重新算一遍(Prefill)还要慢得多。

这两个现场暴露出同一个底层盲区:把内存与网络当成代价为零的抽象符号,忽视了指针解引用(Pointer Chasing)、分配器元数据、多核缓存一致性协议以及跨总线 DMA 拓扑的真实物理开销。

顺着这条硬件约束链条,我们先在单机尺度拆开生产级 C++ 缓存如何把每一个字节和缓存行压榨到极限,再看当缓存载荷从百字节 JSON 跃迁为 GB 级注意力张量时,以阿里云 Tair KVCache、Mooncake、SGLang HiCache 与 NVIDIA Dynamo 为代表的新一代基础设施是如何重塑整个缓存栈的。


一、解剖教科书式 LRU 的四笔硬件烂账

在算法面试题(如 LeetCode 146)里,std::unordered_map + std::list 之所以无懈可击,是因为复杂度分析只数“操作步数”,却从不数每一步背后跨越了多少个 64B 缓存行和 4KB 虚拟内存页。

把这套标准库组合放进 64 位 Linux(以常见 libstdc++ 实现为准)的内存显微镜下,存一条 Key = uint64_t (8B)、Value = uint64_t (8B) 记录的四笔隐性税单会立刻现形:

1.1 超过 6 倍的元数据内存膨胀

标准库的 std::unordered_map 为了满足 C++ 标准对“插入删除不使迭代器与引用失效”的硬性承诺,被迫采用拉链法(桶数组指向一个个独立堆分配的链表节点):

  • 哈希表侧开销(约 60 B):桶指针数组按默认负载因子折算,每个元素分摊约 12 B;堆上单独 new 出来的 _Hash_node 包含桶内后继指针 next* (8B)、Key (8B) 以及指向双向链表的迭代器 _List_iterator (8B),共 24 B,外加通用堆分配器(ptmalloc / jemalloc)的块头与对齐开销约 16–24 B。
  • 双向链表侧开销(约 48 B):std::list 同样在堆上单独 new 出 _List_node,内部包含 prev* (8B)、next* (8B)、Value (8B),以及为了在容量满淘汰队尾时能回头删掉哈希表对应项而被迫冗余存第二遍的 Key (8B),加上堆分配器头部对齐又是约 48 B。

两相叠加,为了存放区区 16 字节 的有效键值,系统实打实消耗了 100 字节 左右的物理内存——超过 80% 的内存预算全交给了指针、重复键与分配器元数据。

1.2 单次 get() 命中触发 4–5 次串行 LLC Cache Miss

当缓存总容量达到数 GB、远远超出 CPU 末级缓存(L3 / LLC,通常数十 MB)时,随机堆节点的每一次指针跳转几乎都意味着一次穿透到主存 DRAM 的 LLC Cache Miss(单次延迟约 70–100 ns)。追踪一次最普通的 get(key) 命中全过程:

  1. 计算哈希值,访问 unordered_map 的桶指针数组槽位 \(\rightarrow\) 第 1 次 LLC Miss;
  2. 顺着桶指针解引用堆上的 _Hash_node,核对 Key 并读取链表迭代器 \(\rightarrow\) 第 2 次 LLC Miss;
  3. 顺着迭代器跳往堆上另一块完全不相邻的内存读取 _List_node 里的 Value \(\rightarrow\) 第 3 次 LLC Miss;
  4. 执行 LRU 提升(splice 挪到链表头):把当前节点从原位置摘除必须改写 node->prev->next 和 node->next->prev,CPU 被迫再去加载前后两个毫无空间局部性的邻居节点 \(\rightarrow\) 第 4、第 5 次 LLC Miss!

由于后一步的内存地址严格依赖前一步指针读出的结果,CPU 引以为傲的乱序执行窗口与内存级并行度(MLP)在这里被彻底锁死为 1。一次号称 \(O(1)\) 的内存查询,硬生生在原地空等了 350–500 ns(上千个时钟周期)。

1.3 双倍分配器争用与页表缓存(dTLB)碎片

每次缓存未命中写入新项,底层要连续触发 2 次 operator new;每次驱逐旧项又要触发 2 次 operator delete。成百上千万个几十字节的微型节点随机散落在海量 4 KB 虚拟页帧上,很快就会击穿 CPU 的数据页表缓存(dTLB),使上述每一次指针追逐还要额外叠加上百周期的多级页表遍历(Page Walk)惩罚。

1.4 多核吞吐倒挂:“每一次纯读都是一次互斥写”

严格 LRU 规定每次读命中都必须把节点搬到链表头(改写 4 到 6 个指针)。这意味着即便线上是 100% 的纯只读流量,每一次 get() 在底层都是一次结构修改写操作,必须抢占互斥锁(Mutex)。在 64 核机器上,几十个线程排队争抢同一把锁,并通过多核 MESI 协议疯狂将其他核心缓存里的链表头指针 head_ 置为失效(Coherency Miss),最终演变成核数越多、吞吐越低的负扩展灾难。

教科书式标准库 LRU 与生产级 C++ 侵入式无锁缓存的物理布局对比


二、生产级 C++ 缓存的五重极致演进

审视工业界久经考验的 C++ 缓存底座——无论是存储引擎内的 RocksDB(LRUCache 与 HyperClockCache)、支撑社交图谱与 CDN 的 Meta CacheLib,还是替代 Redis 的新一代内存存储 Dragonfly——它们之所以能把单机吞吐推高一个数量级并省下一半内存,靠的是以下五重层层递进的手术。

2.1 侵入式容器合一(Intrusive Containers):一次分配,零冗余键

第一刀直接砍向标准库容器的“外部包装节点”。所谓侵入式设计(与前文 向量化引擎的 C++ 内存底座 中剖析的 intrusive_ptr 一脉相承),就是把哈希冲突链钩子、LRU 前后驱钩子、引用计数与业务键值全部熔铸进同一个紧凑连续的结构体里:

 1// 生产级单块紧凑缓存条目(RocksDB LRUHandle / Meta CacheLib Item 思路)
 2struct alignas(8) CacheEntry {
 3    uint32_t lru_prev_idx{0};       // 4B 槽位下标代替 8B 裸指针!
 4    uint32_t lru_next_idx{0};
 5    uint32_t hash{0};               // 缓存预计算哈希值,加速探测与扩容
 6    std::atomic<uint16_t> refs{1};  // 侵入式引用计数:外部正读取时严禁被驱逐覆写
 7    std::atomic<uint8_t> clock_bit{0}; // 无锁近似淘汰标记位
 8    uint8_t  flags{0};
 9    uint16_t key_len{0};
10    uint32_t val_len{0};
11    char kv_inline_data[];          // C99/C++ 柔性数组尾部:Key 与 Value 紧挨头部连续存放
12};

这一改动立刻兑现了三项红利:Key 在全内存只存唯一一份;头部控制字与内联的 Key/Value 紧挨着落在同一个 64B 缓存行内;插入条目时只需向内存池申请一次连续空间,拿到条目地址的同时也就拿到了淘汰链表节点本身,彻底消灭跨堆跳转。

2.2 SIMD 开放寻址扁平表(SwissTable / Dash)与 32 位下标压缩

第二刀换掉拉链法哈希桶。现代高性能内核普遍采用开放寻址加一字节控制元数据的扁平哈希表(如 Google absl::flat_hash_map、boost::unordered_flat_map 或 Dragonfly 自研的分段 Dash Table):

  • 将每个槽位哈希值的低 7 位指纹(H2 Tag)密集排成 16 字节 一组的控制数组,查找时先用一条 SSE2 / AVX2 指令(_mm_cmpeq_epi8)在单个时钟周期内并行比对 16 个槽位,几乎在 1 次缓存行加载内就能锁定目标。
  • 指针位宽腰斩:只要单个缓存分片的条目总数不超过 \(2^{32}\)(约 42 亿条),前驱后继钩子就完全没必要存 8 字节 的 64 位虚拟地址,直接改存 4 字节 的 uint32_t 池内数组下标(Slot Index),白白省出一半指针空间。

2.3 2MB 大页 Slab 内存池与原地覆写复用

第三刀接管底层内存分配。仿照 Meta CacheLib 的 Slab Allocator,引擎在启动时直接申请按 **2 MB HugePages(大页)**对齐的大块连续虚拟内存——单此一步就把 CPU TLB 的地址覆盖半径扩大了 512 倍,将大内存随机查找下的 dTLB Miss 压近于零。

大页内部按固定规格梯度(如 64B, 96B, 128B, 256B ...)切分为 Slab Class。当某个规格池满载需要淘汰旧条目时,根本不调用任何释放函数,而是直接摘下该规格队尾的冷槽位,把新写入的键值原地 memcpy 覆盖进去,全生命周期外部内存碎片率严格为零。

2.4 分片隔离与无锁 Clock 位标记:让 99% 的读重回纯只读

第四刀专门解开“读请求抢写锁改链表”的多核死结,工业界通常打出两套组合拳:

  1. 分片去中心化乃至 Shared-Nothing 绑核:RocksDB 默认按哈希高位将缓存切为 64 个独立分片(ShardedLRUCache),每个分片的锁结构严格按 alignas(64) 对齐隔离伪共享;Dragonfly 则走得更彻底,采用线程绑核的 Shared-Nothing 架构,每个物理线程独占自己的 Dash 分片,将跨线程锁竞争直接归零。
  2. 用原子 clock_bit(Test-and-Set)取代每次读拆装链表:这正是 RocksDB 新一代 HyperClockCache 在高并发压测下大幅击败传统 LRUCache 的核心机密。在近似 LRU(Clock / Sieve / 二次机会算法)下,缓存槽位排成静态环,读命中时完全不加锁、绝不触碰任何前后驱指针,只做一行极克制的标记更新:
1// 读路径热代码:先普通读判断是否为 0,仅在为 0 时发起原子写(Test-and-Set)
2if (entry->clock_bit.load(std::memory_order_relaxed) == 0) {
3    entry->clock_bit.store(1, std::memory_order_relaxed);
4}

注意这行 先读后写(Test-and-Set) 的微妙之处:如果一个超级热点键每秒被 64 个核并发读取一千万次,在第一次置为 1 之后,后续 9,999,999 次读取全都是纯粹的共享态缓存行读取(MESI Shared State),不会向总线发出任何缓存行失效广播!只有当容量见底触发后台淘汰游标顺时针扫过时,才把沿途的 1 清零放过、遇到 0 原地回收。至此,读路径彻底摆脱了锁与写放大。

(第 2.5 重进化——如何支持树状前缀依赖淘汰,我们留到文末与大模型 KV Cache 合龙揭晓。)


三、当载荷变成大模型张量:阿里云 Tair 的三级演进与架构重构

把单机 C++ 引擎打磨到极致之后,时代迎来了大模型推理浪潮。当缓存在系统里承载的对象从 Web 时代的短小 JSON 变成 Transformer 的 KV Cache(历史上下文各层注意力 Key/Value 张量) 时,缓存系统的设计前提发生了四处根本性断裂:

架构约束维度传统在线键值缓存(Redis / Valkey / Memcached)大模型推理 KV Cache 记忆池
单对象物理尺度100 B ~ 数 KB(序列化业务字段)单个块 数百 KB ~ 数 MB,单次长会话可达 数 GB ~ 数十 GB
有效收益生死线1 ~ 5 ms 响应即可大幅减轻后端数据库压力亚毫秒至数毫秒级(拉取耗时一旦慢于 GPU Tensor Core 重算 Prefill,缓存即成负优化)
检索与命中语义精确全键哈希匹配(GET user:1001)Token 序列最长公共前缀匹配(Prefix / Radix Tree) + 滑动窗口 / 混合注意力匹配
硬件传输通路远端 DRAM -> 内核 TCP -> 客户端 CPU 堆内存远端内存/NVMe 池 --(RDMA / GPUDirect RDMA)--> 目标 GPU HBM 显存(绕过主机 CPU)

以阿里云瑶池旗下的 Tair 为样本(以下严格依据阿里云官方公开技术文档与 GitHub 开源仓库 alibaba/tair-kvcache 披露架构),能清晰看到一套商业级缓存系统如何顺应这场硬件与负载剧变完成三级跃迁。

3.1 第一级(云原生多模与持久内存底座):Tair-PMem 与 C++ 原生引擎

在传统高并发时期,标准开源 Redis 有两块难啃的硬骨头:一是纯 DRAM 实例在大容量场景下硬件采购成本高昂;二是依赖 fork() 子进程做 RDB 快照持久化时,页表复制与写时复制(Copy-on-Write)经常引发百毫秒级的请求毛刺。

Tair 在 C++ 高性能内核之上引入了软硬协同的 持久内存实例(Tair-PMem / SCM 字节可寻址存储级内存),不再依赖后台 fork 全量转储,而是直接在主节点内存总线上完成命令级持久化落盘,在消除快照抖动的同时将大容量内存存储成本压降约 30%;并在完全兼容 Redis / Valkey 协议的基础上,用 C++ 原生扩展了 TairHash、TairZset 等服务端复杂算子,免去客户端把大对象拉回本地反序列化的带宽浪费。

3.2 第二级(GenAI 问答短路层):内置 TairVector 与语义缓存

进入生成式 AI 早期,最直接的降本手段是拦截高频重复或同义提问。Tair 将基于 HNSW 等近似最近邻(ANN)算法的向量索引原生做进内存引擎(TairVector):业务网关先将用户提问编码为稠密向量,在毫秒内检索缓存池中的历史高相似语义条目;一旦余弦相似度跨过阈值,直接返回缓存结果,将整条昂贵的大模型推理链路前置短路。

3.3 第三级(Agent 与长文本深水区):存算分离 Tair KVCache 与开源 KVCM

然而,进入百万上下文阅读、代码库级理解与多轮工具调用的 Agentic AI 阶段后,每次交互都在既有上下文尾部追加新观察结果,整句语义缓存不再奏效;与此同时,单卡 80 GB HBM 显存除去模型权重后所剩无几,跨请求、跨实例的公共前缀与多轮历史 KV 块因为装不下而被反复丢弃重算,把首字延迟(TTFT)拖慢至数十秒。

为此,Tair 推出了面向大模型推理的分布式动态分级缓存体系 Tair KVCache(其核心控制面 Tair KVCache Manager,简称 KVCM 及高保真仿真器 HiSim 已在 alibaba/tair-kvcache 开源)。这套架构抓住了四个核心工程支点:

  1. 开辟“G3.5 层”存算分离高速池: 单机本地盘空间有限且与计算容器强绑定,而传统远端对象存储延迟太高。Tair KVCache 构建了 GPU HBM (G1) <-> 主机锁页 DRAM (G2) <-> 本地 NVMe (G3) <-> 远端 RDMA 高速分布式缓存池 (G3.5,对接分布式内存池/NVMe 池/3FS/Mooncake 等) <-> 温冷对象存储 (G4) 的多级梯度,底层借助 RDMA 绕过操作系统内核协议栈,并针对高并发小块随机读做了精细流控调优,使远端池化层跑出逼近本地 NVMe 的传输效率,将长上下文 TTFT 最高缩短近 90%。
  2. 控制面与数据面彻底剥离(C++ 中心化管家 KVCM): 如果让几百个 vLLM / SGLang 推理容器彼此网状直连同步块状态,连接数与一致性信令会瞬间失控。KVCM 作为纯 C++ 编写的轻量级全局元数据中枢,不触碰沉重的张量字节流,专门统一管控全集群 KV 块的 Location(物理层级坐标)、State(可用状态) 与 Capacity(配额水位),通过 Instance Group 支持水平扩展,并由推理侧 Connector 借助增量 ReportEvent 实时上报本地缓存变动。
  3. 深度对齐现代注意力变体的匹配引擎: 除了标准 Transformer 的最长公共前缀匹配(Prefix Matching),KVCM 原生支持反向滚动滑动窗口匹配,以及针对 Mamba(状态空间模型)+ SWA(Sliding Window Attention) 等新型混合架构的多 LocationSpec 异构块组织,避免模型结构一换缓存层就失效。
  4. 两阶段写入协议(Two-Phase Writes)与无阻塞多租户回收: 当多台 Prefill 实例同时处理带有相同前缀的并发请求时,为防止读到写了一半的残缺张量,KVCM 强制执行 Reserve(预留槽位)→ Write & Confirm(数据落定确认后才向全局读请求开放可见性) 的两阶段状态机;在多租户混部治理上,则按 Instance Group 实施配额隔离,由后台线程按 Group LRU 或用量比例执行异步驱逐与冷热降级,确保前台推理关键路径零阻塞(配套开源的 HiSim 还能在普通 CPU 上以低于 5% 的误差仿真预测不同分层配置下的端到端时延与成本最优解)。

大模型推理分层 KV Cache 池化与控制面/数据面解耦架构


四、全球视野:开源与商业 KV Cache 基础设施的四大技术流派

放眼整个 2025–2026 年的 AI Infra 社区,围绕“以存代算(Storage-for-Compute)”解决显存墙与 Prefill 算力税,国内外顶尖团队已经演化出四股相互交融的代表性力量:

代表系统主导团队 / 出处架构切入点与核心机制最擅长的战场与权衡边界
Mooncake月之暗面 (Kimi) + 清华大学 (FAST 2025 Best Paper,开源)以 KVCache 为中心的 P/D 分离架构:Mooncake Store 将 GPU 服务器上闲置的 CPU DRAM 与本地 SSD 聚拢成全局内容寻址池;Transfer Engine 实现拓扑感知多网卡 RDMA / GPUDirect RDMA 并行直传,并配早期过载预测拒绝机制超长上下文与高吞吐 Prefill/Decode 物理分离集群;依赖高速 RoCEv2 / InfiniBand RDMA 网络底座发挥满血实力
SGLang RadixAttention & HiCacheLMSYS 社区 (开源)引擎内生基数树分页管理:在 GPU 内直接用显式 Radix Tree 组织分页 KV 块;HiCache 扩展出三层异步预取与回写管线,后端可无缝挂载 Mooncake 或 DeepSeek 3FS 高吞吐文件系统多轮 Agent 对话、Few-shot 批量共享及树状并发采样(Tree-of-Thought),引擎与缓存协同紧密度最高
LMCache (+ CacheGen)芝加哥大学 / vLLM 生产栈生态 (开源)可插拔跨实例共享与张量流压缩:不仅支持严格句首前缀,还探索跨位置模块化文本块 KV 复用;内置 CacheGen 根据不同 Transformer 层的敏感度做定制量化与算术编码压缩跨云主机、普通以太网带宽受限或容器频繁扩缩容的 vLLM 集群,用轻量 GPU 解压算力换取 3–4 倍网络传输提速
NVIDIA Dynamo + NIXLNVIDIA 官方推理编排栈 (开源)全局缓存感知路由 + 统一传输抽象:前端 KV-Aware Router 综合评估各节点 HBM/DRAM/远端池前缀重合度与搬运代价做精准派单;底层 NIXL 统一封装跨 HBM/DRAM/NVMe/RDMA 的异步零拷贝原语异构多机多卡商业推理底座,解决传统盲目轮询负载均衡导致跨节点缓存命中率暴跌的痛点

把这四套系统与 Tair KVCache 放在一起审视,会发现行业共识已经高度收敛:单机孤立显存时代已经终结。未来的标准大模型推理栈必然由三层咬合而成——顶层是知晓全局块分布的 KV 感知路由器与元数据控制面(如 KVCM / Dynamo Router),中层是推理引擎内建的 分层基数树页表(如 HiCache / LMCache),底层则是跑在 200/400 GbE RDMA 与 NVMe 阵列之上的 零拷贝分布式块传输与池化引擎(如 Mooncake Transfer Engine / NIXL / 3FS)。


五、首尾合龙:当 C++ 侵入式淘汰遇上大模型前缀基数树

文章的最后,让我们把第三、四节的分布式大模型前缀池,重新拉回到第二节的 C++ 单机侵入式数据结构上,完成最后一块拼图。

在 SGLang 的 RadixAttention、Mooncake 本地节点或 Tair KVCM 的内存索引里,如果我们直接照搬第二节的普通扁平 LRU / Clock 去淘汰大模型 KV 块,会发生什么事故?

设想一棵共享前缀树:树根存放着全公司 Agent 共享的 8,000 Token 系统提示词(System Prompt),树根下面分叉挂着 500 个正在活跃对话的用户子分支。如果在某几个毫秒里刚好没有新请求去摸根节点,一个不懂树形拓扑的普通淘汰队列很可能会把根节点判定为“较早访问”而一把驱逐——瞬间导致下面 500 个子分支的前缀上下文链条断裂,或者引发灾难性的悬挂引用!

因此,在 AI 原生缓存的 C++ 内核里,侵入式节点迎来了它的第五重形态——拓扑感知的“纯叶子侵入式驱逐队列(Leaf-Only Intrusive Eviction Queue)”:

 1struct RadixKVNode {
 2    // 1. 前缀基数树拓扑指针
 3    RadixKVNode* parent{nullptr};
 4    uint32_t children_count{0};          // 当前依赖此块存活的子分支数量
 5
 6    // 2. 活跃推理固定计数(Pin Count)
 7    std::atomic<uint32_t> active_refs{0}; // 正在跑 Prefill/Decode 的请求引用数
 8
 9    // 3. 侵入式淘汰链表 / 最小堆钩子(零额外堆分配!)
10    uint32_t evict_prev_idx{kInvalidIdx};
11    uint32_t evict_next_idx{kInvalidIdx};
12    uint64_t last_access_tick{0};
13
14    // 物理张量页句柄(指向 G1 HBM / G2 Pinned DRAM 或 G3.5 远端 LocationSpec)
15    TensorPageSlice kv_slice;
16};

这套状态机只守一条极其优雅的不变量:整棵树中,唯有同时满足 active_refs == 0(没有任何在途 GPU Kernel 正在读写它)且 children_count == 0(没有任何下游后缀块依赖它)的纯叶子节点,才有资格通过体内的侵入式钩子挂入可驱逐队列。

  • 一旦某个新请求命中并沿着前缀路径向下匹配,沿途节点的 active_refs 自增,若原本在可驱逐链表中的叶子节点被重新激活,直接用 \(O(1)\) 侵入式摘除将其移出淘汰池(Pin 锁定);
  • 当显存或主机锁页内存池触及高水位需要腾出空间时,后台回收器只需从侵入式驱逐队列队头摘下最冷的叶子块释放;
  • 释放该叶子块后,顺着 parent 指针将其父节点的 children_count 减一——倘若父节点的 children_count 恰好归零且 active_refs == 0,这个父节点便自然退化成了新的空闲叶子,顺手通过它自己体内的 evict_prev_idx / evict_next_idx 挂入驱逐队列尾部!

从砍掉 std::list 两次堆分配与 5 次串行缓存缺失的 64 字节侵入式结构体,一直到横跨千卡集群、用 GPUDirect RDMA 吞吐数十 GB 注意力张量的分级基数树记忆池——无论上层负载形态如何翻天覆地,顶尖系统内核的演化逻辑始终如一:顺应存储层级与网络的真实延迟梯度,把元数据压进最紧凑的缓存行,把昂贵的数据留在原地零拷贝直通。


参考资料与公开信息基线

  • 阿里云 Tair 与 Tair KVCache 公开资料:GitHub 开源仓库 alibaba/tair-kvcache(包含全局元数据管理服务 Tair KVCache Manager / KVCM 两阶段写入协议、注意力前缀/滑窗/混合模型匹配、多租户 Instance Group 回收设计文档及 HiSim 推理仿真系统)· 阿里云官方文档(云数据库 Tair 持久内存型 tair.scm 架构、TairVector 向量检索与语义缓存实践、Tair KVCache 分级存储介绍)。
  • 大模型 KV Cache 开源与学术生态:Qin et al., Mooncake: A KVCache-centric Disaggregated Architecture for LLM Serving (FAST 2025 Best Paper, kvcache-ai/Mooncake) · Zheng et al., SGLang: Efficient Execution of Structured Language Model Programs (RadixAttention & HiCache 分层缓存设计) · Liu et al., CacheGen & LMCache (LMCache/LMCache) · NVIDIA Dynamo & NIXL (NVIDIA Inference Xfer Library) 开源技术文档。
  • 高性能 C++ 缓存内核设计:Berg et al., The CacheLib Caching Engine: Design and Experiences at Scale (OSDI 2020, Meta facebook/CacheLib) · RocksDB ShardedLRUCache 与无锁 HyperClockCache 源码(cache/clock_cache.cc)· Dragonfly (dragonflydb/dragonfly) Shared-Nothing 架构与 Dash Table 设计论文。