内存优化：内存规划

可视化演示

展示Groq LPU三维度：TSP张量流处理器架构（数据流驱动执行模型功能单元MEM/VC/MM/SF/MX流水线230MB片上SRAM确定性执行每token延迟一致）、性能对比（LPU推理700+token/s单卡超越H100 8卡约7倍优势确定性延迟P99约等于平均延迟GPU因缓存未命中P99大于平均）、多芯片扩展（多LPU通过高速SerDes互联形成逻辑大容量SRAM池4芯片920MB统一SRAM支持更大模型保持确定性推理）,三模式切换理解Groq LPU推理加速架构。

规划概述：前台手中的行程表

林静的酒店开业第一天，她收到一份特殊的时间表：上面不是客人姓名，而是一串「入住—退房」记录，每一条对应旅行团中的一位成员。如果她不提前规划，就只能等客人到了再临时找房，结果往往是房间不够——多出来的客人只能挤在一起，或者干脆住不下。

在 AI 编译器的世界里，这份「行程表」就是模型的计算图。一个深度学习模型可以看成由许多算子组成的流水线：每个算子读取输入、产生输出，中间结果就是张量。张量和酒店客人一样，有自己的生命周期：在某个算子的输出位置诞生（创建），在最后一个用到它的算子执行完毕后消亡（不再需要）。

为什么需要规划？因为 GPU 显存是稀缺资源。一块高端消费级显卡只有十几 GB 显存，而稍大一点的模型，权重和激活值就可能占满好几个 GB。如果每个张量都「从一而终」地独占一块内存，整个模型根本跑不起来。这就像林静如果不看行程表就给每个人都开一间房，她至少需要六间房，而手里只有三间。

内存规划因此要回答三个问题：每个张量什么时候出生、什么时候死亡；哪些张量可以共享同一块内存；如何安排让模型运行期间的「峰值内存」（任意时刻占用内存的最大值）尽量小。这三个问题，正是林静的故事接下来要展开的核心。

张量生命周期：客人的入住与退房

林静的排房技巧只依赖两件事：客人什么时候到、什么时候走。只要把这两条信息搞准确，后面的安排都很自然。AI 编译器同样如此：计算每个张量的「入住时间」和「退房时间」，这一步通常叫「活跃区间分析」或「生命周期分析」。

先说「入住时间」。张量总是由某个算子产生的，比如卷积层输出的张量，在卷积算子执行完的那一刻就诞生了。它的「生日」就是定义它的算子在执行序列中的位置。这个位置越靠前，它占内存的时间就开始得越早。

再说「退房时间」。张量一旦被后续某个算子读取，就算「被使用」。有的张量只被用一次，用完就再也没人碰；有的会被多个算子接力使用。生命周期终点不是「被释放的那刻」（编译器通常没有显式 free），而是「最后一次被使用的时刻」。这就像酒店的退房时间，是客人最后一次出现在房间的截止点。

如果一个张量的定义点很靠前、最后一次使用点很靠后，它的生命周期就长，意味着它长时间占着内存。反之，那些「用一次就扔」的临时结果，生命周期很短，是内存复用的最佳候选。

回到酒店的例子：张量的活跃区间画在时间轴上就是一根横条。林静把这些横条并排贴在前台墙上，一眼就能看出什么时候最拥挤。AI 编译器同样会把每个张量的区间记录下来，作为下一步内存复用的输入数据。

内存复用：让不相遇的客人共享房间

林静发现了一个省钱秘诀：既然客人 A 上午退房、客人 B 下午才到，那他们可以住同一间房。只要两段时间不交叠，房间就能「一房两用」。在内存规划里，这个秘诀叫「内存复用」：只要两个张量的生命周期没有交集，它们就可以被分配到同一个内存地址。

怎么判断有没有交集呢？两个区间，要么一个在左、一个在右完全不相接，要么互相穿插。判断规则很简单：如果张量 \(i\) 的终点还没到，张量 \(j\) 的起点就已经来了（即 \(i\) 的死期早于 \(j\) 的出生），二者就能复用；反之，只要有哪怕一瞬间的重叠，就必须各占一块。

当把「复用关系」画成图——每个张量是一个点，如果两个张量不能复用就在它们之间连一条线——我们就得到了区间图。给这些点染色（每种颜色代表一块内存），要求相邻的点颜色不同，最少的颜色数就是最小内存块数。这恰好是经典的「区间图着色」问题。一般图的着色是 NP 难问题，但区间图有个漂亮性质：按左端点排序后贪心着色，颜色数恰好等于任意时刻最大重叠深度。

林静在排房表上做标记：把能共享房间的客人名字写在同一个格子里。内存规划器做的事几乎一模一样——它并不真的为每个张量分配显存，而是在逻辑上决定「谁和谁住同一个地址」，等到运行时再把地址映射到物理显存上。

内存池机制：预置的酒店楼层

如果每次有客人入住，林静都临时去装修一个新房间，那效率太低了。现实的做法是：酒店本来就有固定的楼层和房间，前台只要在楼层平面图上做标记，告诉保洁阿姨哪间房免费、哪间房有人。AI 编译器里的「内存池」（arena）就扮演这个楼层平面图的角色。

通常的做法是向 GPU 驱动申请一块很大的显存（比如 1GB），这块显存叫作「内存池」。之后所有张量都在这块池子里切分，而不是频繁调用底层分配接口。为什么这样好？底层显存分配每次都要经过驱动、可能触发同步，非常昂贵；而且大量小块的频繁申请容易造成显存碎片。内存池相当于一次批发、长期零售，既快又整齐。

内存池内部由「块」（block）组成。规划器维护一个空闲块列表：当一个张量死亡，它占的块归还到空闲列表；当一个新张量诞生，优先从空闲列表里找一块足够大的块分给它，找不到才从池子尾部开辟新块。最常见的策略是「首次适配」（first-fit）：从头到尾扫一遍空闲列表，遇到第一块装得下的就用。

这正好回答了前面埋下的伏笔——生命周期分析算出「谁什么时候空闲」，内存池则负责「空闲块怎么高效周转」。两件事合起来，才构成完整的内存规划方案。林静的房间从不浪费，正是因为她的楼层平面图上永远标注着每个房间的当前状态：有人、空闲、或即将空闲。

峰值内存优化：三间房住六位客人

林静的最终目标很明确：把「任意时刻被占用的房间数」尽量压下来。这个最大值，就是酒店运营中的「峰值房量」。对应到内存规划里，就是峰值内存（peak memory）。降低峰值，意味着可以用更小的显存跑更大的模型。

先给峰值一个严格定义：在模型执行的每一个时刻，把当前所有活跃张量的大小加起来，取所有时刻的最大值。注意，不是把所有张量加起来——因为复用让很多张量错开了时间。林静手里三间房能住六个客人，正是因为「同时活跃的客人」从来没超过三个。

峰值优化有三大常见武器。一是「重计算」：有些中间张量先不用内存保存，等要用了再重新算一遍。这是典型的「用时间换空间」，适合那些计算快但占地方大的结果。二是「算子融合」：把连续的几个算子合成一个，让中间结果只在片内传递、不落显存。三是「层间交换」：把暂时用不到的张量从 GPU 显存搬到 CPU 内存，用到时再搬回来，相当于把酒店的行李房变成临时卧房。

林静看着最终排房表满意地点点头：六个客人、三间房，每个时刻房间里最多住着三个人。峰值优化不是魔法，而是把「重叠」这个敌人一个个拆掉——把重叠的区间错开、把高峰期的张量换走、把反复使用的中间值重算。内存规划的艺术，就是让大楼永远不拥挤。

规划算法：一张排房表的诞生

最后，让我们看看林静（或者说 AI 编译器里的规划器）到底是怎么一步步做出这张排房表的。整个过程遵循一个朴素的贪心思路：按时间顺序一遍过，能复用就复用。

第一步是「整理行程表」。规划器拿到计算图后，按照拓扑序为算子排序。严格来说，算子本身有先后依赖，这个执行顺序就是张量创建的大致顺序。在这一步，每个张量的生命周期区间被全部算出来。

第二步是「按序处理」：按照张量的创建时间逐一遍历。每遇到一个新张量，先检查有没有「已经死掉的张量」留下了空闲块——如果有，把这些块放入空闲池；然后从空闲池里挑一块分配给新张量。如果空闲池是空的，就新开一块内存。

第三步是「记录与验证」：规划完成后，编译器把所有分配结果（地址、偏移、大小）记录成一张内存布局表，并做一次模拟执行，核对每个时刻的峰值内存是否符合预期。这一步相当于把排房表拿给保洁阿姨核对：每间房在任意时刻最多只有一组住客。

为什么贪心在这里有效？因为「排序后从前到后」的处理方式天然契合区间着色的规则——区间图着色问题按左端点排序后贪心即为最优。这也是区间图最可爱的地方：复杂的问题，在正确的顺序下变得简单。

林静合上排房表，六位客人的行程被安排得井井有条。AI 编译器里的内存规划器，做的正是这样一件事：把乱糟糟的中间结果，变成一张优雅的内存地图。

AI 应用场景

Python 演示

# -*- coding: utf-8 -*-"""简化版内存规划器: 给定张量生命周期, 用贪心复用策略分配内存块""" import heapq  class Tensor:    def __init__(self, name, size, start, end):        self.name = name        self.size = size        self.start = start        self.end = end  def first_fit(free_list, size):    """找到第一块能装下 size 的空闲块下标, 找不到返回 -1"""    for i, (_, block_size) in enumerate(free_list):        if block_size >= size:            return i    return -1  def plan_memory(tensors):    """按创建时刻处理: 先回收已结束的张量, 再优先复用空闲块"""    by_start = sorted(tensors, key=lambda t: t.start)    by_end = [(t.end, t) for t in tensors]    heapq.heapify(by_end)     free_blocks = []  # (地址, 大小) 空闲块池    alive = {}        # 张量名 -> (地址, 大小) 当前占用    next_addr = 0    peak = 0     for t in by_start:        # 1. 把所有在 t.start 之前就结束的张量释放        while by_end and by_end[0][0] <= t.start:            _, dead = heapq.heappop(by_end)            if dead.name in alive:                addr, size = alive.pop(dead.name)                free_blocks.append((addr, size))         # 2. 优先复用空闲块, 否则开辟新块        idx = first_fit(free_blocks, t.size)        if idx == -1:            addr = next_addr            next_addr += t.size        else:            addr, block_size = free_blocks.pop(idx)            if block_size > t.size:                free_blocks.append((addr + t.size, block_size - t.size))         alive[t.name] = (addr, t.size)        cur_mem = sum(s for _, s in alive.values())        peak = max(peak, cur_mem)     return alive, peak  if __name__ == "__main__":    tensors = [        Tensor("w1", 512, 0, 3),        Tensor("a1", 128, 0, 1),        Tensor("w2", 256, 1, 4),        Tensor("a2", 128, 2, 3),        Tensor("out", 64, 3, 4),    ]    layout, peak = plan_memory(tensors)    for name, (addr, size) in layout.items():        print("{}: 地址 {} 大小 {}".format(name, addr, size))    print("峰值内存: {}".format(peak))

1. by_end = [(t.end, t) for t in tensors]把所有张量按结束时刻组织成最小堆，方便快速找出「已死」的张量
2. heapq.heapify(by_end)将普通列表转换为最小堆，堆顶永远是最早结束的张量
3. while by_end and by_end[0][0] <= t.start:先处理到期张量，把它们占用的内存块归还到空闲池
4. addr, size = alive.pop(dead.name)从活跃表中移除已死亡的张量，取出它占用的地址和大小
5. free_blocks.append((addr, size))把回收的块放进空闲列表，供后续张量复用
6. idx = first_fit(free_blocks, t.size)尝试从空闲池中找一块足够大的内存块
7. addr = next_addr当没有可复用块时，在池子末尾开辟新块
8. addr, block_size = free_blocks.pop(idx)从空闲池中取出命中的块分配给当前张量
9. free_blocks.append((addr + t.size, block_size - t.size))若空闲块比需求大，把剩余部分放回池中
10. cur_mem = sum(s for _, s in alive.values())统计当前所有活跃张量的总占用，用于更新峰值

常见误区

面试题