异构计算调度：并行执行

可视化演示

展示计算图DAG并行调度、三种并行策略对比与异构设备负载均衡，支持负载比例调节。

并行执行基础

餐厅里每位师傅都有独门绝技：切菜师傅刀工快，炒锅师傅火候准，烤箱师傅温度稳。异构计算系统和这间厨房如出一辙——CPU 擅长复杂逻辑控制，GPU 擅长海量并行计算，NPU 则专为神经网络算子做了硬件加速。这些“各有所长”的设备凑在一起，就构成了现代 AI 推理系统的算力底座。并行执行要回答的第一个问题便是：如何让这些不同类型的设备在同一段时间内各显神通？

在串行模式下，所有计算任务排成一列，逐个执行，就像客人的三道菜由同一位师傅依次完成。而并行执行，则是把无依赖关系的任务分配到不同设备同时运行。这里的“依赖”指的是任务之间必须遵循的先后顺序——某个操作需要等待另一个操作产出的张量才能开始。AI 模型的推理过程通常被建模为一张计算图：节点是算子（卷积、矩阵乘法、激活函数），边是张量的流向，整张图就是一份“数字化菜谱”。

切菜师傅备料的同时烤箱师傅预热面包，两道菜并行推进，总出菜时间从“三道菜时长之和”缩短为“最慢一道菜的时长”——这就是并行执行的本质收益。

依赖关系分析

想安排多位师傅同时开工，主厨必须先搞清每道菜的工序关系：必须先切完葱才能下锅爆香，必须先烤好面包胚才能抹奶油。这类“前置条件”在计算图里叫数据依赖，即操作 B 需要操作 A 的输出张量作为输入。除此之外还有控制依赖：B 是否执行取决于 A 的执行结果（比如条件分支），以及资源依赖——两个操作争抢同一块显存或同一条总线，本质上也不能真正同时运行。

识别依赖关系后，调度器就能从计算图中“抠”出互不相干的子图：没有直接或间接数据访问关系的子图是天然的并行单元。就像炖红烧肉的同时完全可以让烤面包师傅开工，两者既不共享食材也不共享灶台。一个关键指标是关键路径——计算图中从入口到出口的最长依赖链，它决定了并行执行的理论最短时间。

主厨扫一眼菜谱就能指出哪条工序链最磨人——那条必经之路就是关键路径，其他工序都可以围着它做并行安排。

子图切分策略

找到无依赖子图后，下一步是把计算图“切”成适合分发的小块，就像把整本菜谱拆成一张张工序卡。切分的核心矛盾在于粒度：切得太粗，一个子图里混杂多种类型的算子，难以匹配设备特长；切得太细，任务碎片化导致调度次数激增，设备间来回搬运数据的通信开销甚至会淹没并行收益。

好的切分策略强调设备匹配：把矩阵乘法这类计算密集算子派给 GPU，把循环、指针操作派给 CPU，把卷积激活这类固定模式算子派给 NPU。同时还要照顾负载均衡——如果一块 GPU 忙得冒烟、另一块却闲着看报，并行效率就会大打折扣。假设切分后第 i 个子图需要跨设备搬运数据量为 D_i 的中间结果，通信开销为：

主厨把工序卡分给各师傅时，既要让每个人干自己最擅长的活，又得避免为传一盘菜等太久——切图的分寸，就是并行调度的艺术。

调度执行机制

工序卡发下去了，接下来主厨要决定什么时候让谁开工。静态调度在运行前就排好所有任务的时间表——主厨凭经验在开工前就写好每张卡片的执行时刻。这种方式零运行时开销、可预测性强，适合形状固定、反复执行的推理模型。动态调度则在运行中按设备空闲情况实时派活——哪个师傅手头空了就递上下一张工序卡，灵活抗波动，但每次派活都有额外决策成本。

调度器还会给任务排优先级：关键路径上的任务优先派发，因为它们决定了整体延迟。多个设备执行完各自的子图后需要同步——就像各师傅做完自己的菜后要一起交给传菜员，用栅栏同步（Barrier）确保所有依赖数据就绪后再进入下一阶段。整个过程的资源利用效率可以表示为：

主厨时而按预案推进、时而随机应变，但始终盯着每个灶台的火——好调度器就是既会排计划、又会救火的资深主厨。

收益开销权衡

并行执行并非“师傅越多越快”。每多请一位师傅，就要多一张嘴吃饭：任务启动有开销（分配设备、初始化上下文），设备通信有延迟（搬运中间张量），同步等待浪费时间。当并行带来的收益被这些开销抵消时，盲目增加并行度反而会拖慢整体速度。这正是阿姆达尔定律揭示的道理——程序的加速比受限于其中必须串行的部分。

假设某推理流程中可并行部分占比为 P，不可并行的串行部分占比为 1-P，使用 N 台设备并行后理论加速比为：

如果一道菜的流程里 80% 都可以并行，哪怕请一百个师傅，提速也超不过 5 倍——主厨心里得有这笔账，才能决定到底安排几个人同时开工。

应用实践落地

高档餐厅把这套统筹学落到了实处。AI Runtime 系统（如 NVIDIA TensorRT、华为 Ascend Runtime）在部署大模型推理服务时，会先将模型计算图做依赖分析，把互不干扰的子图分发到多张 GPU 或 CPU+NPU 的异构组合上。例如用流水线并行让不同 GPU 分别处理 Transformer 的不同层，层间虽有依赖，但不同请求（batch）的数据可以在各层间像流水线一样错峰并行。

实践中，工程师会先以串行方式跑通模型并记录基线延迟，再逐步开启并行并监控各设备利用率与通信耗时。最终用加速比验证收益——拿串行总耗时除以并行总耗时，确认没有“越并越慢”。这种“先分析依赖、再切图、再调度、最后验证”的流程，已经成为高性能推理服务部署的标准化动作。

主厨翻开出品记录对比翻台率——加速比就是 AI Runtime 工程师的“翻台率”。用数据说话，才知道这套并行体系到底值不值得。

AI 应用场景

Python 演示

"""异构并行执行调度模拟器：对比串行与双设备并行延迟""" from collections import deque  class Task:    """计算图中的一个算子节点"""    def __init__(self, name, duration):        self.name = name        self.duration = duration        self.deps = []        self.children = []     def __repr__(self):        return "{}[{}]".format(self.name, self.duration)  class Scheduler:    """多设备并行调度器：每时间单位调度一次就绪任务"""    def __init__(self, tasks, num_devices):        self.tasks = tasks        self.num_devices = num_devices        self.ser_time = sum(t.duration for t in tasks)     def add_dependency(self, pre, post):        pre.children.append(post)        post.deps.append(pre)     def schedule(self):        deps_left = {t.name: len(t.deps) for t in self.tasks}        ready = deque(t for t in self.tasks if not t.deps)        dev_times = [0] * self.num_devices        dev_tasks = [None] * self.num_devices        done = set()        elapsed = 0        while len(done) < len(self.tasks):            for i in range(self.num_devices):                if dev_times[i] == 0 and ready:                    t = ready.popleft()                    dev_times[i] = t.duration                    dev_tasks[i] = t            elapsed += 1            for i in range(self.num_devices):                if dev_times[i] > 0:                    dev_times[i] -= 1                    if dev_times[i] == 0:                        t = dev_tasks[i]                        done.add(t.name)                        for c in t.children:                            deps_left[c.name] -= 1                            if deps_left[c.name] == 0:                                ready.append(c)                        dev_tasks[i] = None            if elapsed > 1000:                break        return elapsed  def build_model():    """构造计算图: A[2] -> B[3]; A[2] -> D[1]; C[3] -> D[1], 其中 C 与 A/B 无依赖"""    a = Task("A", 2)    b = Task("B", 3)    c = Task("C", 3)    d = Task("D", 1)    sched = Scheduler([a, b, c, d], 2)    sched.add_dependency(a, b)    sched.add_dependency(a, d)    sched.add_dependency(c, d)    return sched  def main():    sched = build_model()    serial_time = sched.ser_time    parallel_time = sched.schedule()    print("计算图: A[2] -> B[3], C[3], A/C 均汇入 D[1]")    print("串行总延迟: {}".format(serial_time))    print("双设备并行延迟: {}".format(parallel_time))    print("加速比: {:.2f}x".format(serial_time / parallel_time))  if __name__ == "__main__":    main()

1. self.ser_time = sum(t.duration for t in tasks)串行基线时间就是所有任务时长之和。
2. ready = deque(t for t in self.tasks if not t.deps)初始就绪队列只放入没有任何依赖的任务。
3. if dev_times[i] == 0 and ready:每轮先找空闲设备，从就绪队列取出任务派发。
4. dev_times[i] = t.duration设备进入忙碌状态，倒计时执行该任务。
5. for c in t.children:任务完成后解锁所有依赖它的后继任务。
6. ready.append(c)依赖清零的后继任务进入就绪队列，等待被派发。
7. if len(done) < len(self.tasks):循环继续条件：只要还有任务未完成就推进时间片。
8. elapsed > 1000防御性判断，防止死循环拖垮演示。

常见误区

面试题