异构计算调度：CPU/GPU/NPU调度

可视化演示

展示CPU/GPU/NPU异构调度：任务按设备特性调度、负载占比分配、异构加速对比单核性能，通过交互理解异构计算资源的调度机制。

异构计算概览

工坊刚开张时，你可能觉得“谁的活儿谁干就行”。可真拿到订单你会发现，一张“给一万个圆珠打磨抛光”的订单，让全能手艺人老C干三天三夜也赶不完；而一张“精雕一只花纹复杂的椅子腿”的订单，让流水线老G来做，他会摆摆手说做不了。硬件生而不同，这就是“异构”的由来。

在计算世界里，CPU 是全能型选手：核心少、主频高、擅长处理分支和复杂控制逻辑；GPU 是众核并行狂魔：成百上千个核心，适合做数据高度并行的矩阵运算；NPU 则是 AI 专用加速器：把卷积、矩阵乘、激活函数这些深度学习基本操作固化成计算引擎，精度要求放宽但极快极省电。三者共存一台机器，就构成了“异构计算系统”。

异构计算系统要高效运转，关键在“调度”：任务分给谁、什么时候分、数据怎么搬、谁先谁后，这些决策都发生在 AI Runtime 系统里。调度得好，工坊产能翻倍；调度不好，设备闲置、搬运拥堵、总时间翻倍。延迟、吞吐、能耗都是调度的核心指标。为了量化一次任务的整体代价，我们常用下面这个时间模型：

认识了工坊里的三位师傅，你才不会把打磨订单错派给木匠。接下来，我们推门走进“调度室”，看看总调度手边的排单系统和工具台长什么样。

调度器架构

工坊开工后，你这个总调度不可能一直站在门口发号施令。你需要一间“调度室”：前台接单（任务提交）、排期看板（任务队列）、师傅档案簿（设备资源表）、以及发号指令的传令台（执行引擎）。整个调度室，就是 Runtime 调度器的缩影。

AI Runtime 系统是连接上层框架（PyTorch / TensorFlow）和底层硬件的桥梁。用户编写模型代码时并不关心设备，框架把计算表示成一张计算图，图里的每个节点就是一个“算子及其参数”。Runtime 调度器拿到计算图后，把它们封装成一个个“任务”（也常被称为 kernel / 算子实例），放进任务队列等待派发。

调度器的核心模块包括：任务队列（FIFO 或优先级队列）、设备池（记录每个设备的算力、显存、状态）、调度策略模块（决定下一个任务给谁）和执行引擎（真正把 kernel 提交到设备驱动、管理 Stream 和事件同步）。当一个任务被派给 GPU，执行引擎会调用 CUDA / OpenCL 等驱动 API 将 kernel launch 到设备上，这个过程涉及上下文切换和内核启动开销，调度器必须精打细算。一次调度的完整开销可表示为：

调度室搭好了，接单、看板、设备档案、传令台一应俱全。可总调度每天还得面对同一个灵魂拷问：到底按什么规则派单？这正是下一节的“调度策略”。

调度策略

同样是派单，有的总调度喜欢“前一天晚上就把明天的活排好”，有的则“现场看谁闲着就派给谁”。前者是静态调度，后者是动态调度。选择哪种风格，直接决定了工坊应对突发订单的能力。

静态调度（Static Scheduling）在编译期或启动前完成：遍历计算图，测量每个算子在目标设备上的预估耗时、内存占用，然后一次性排定执行顺序。它的优点是运行开销小、确定性强；缺点是一旦运行时的输入 shape、设备负载与预估不符，排好的计划就可能不再最优，甚至引发显存不足。

动态调度（Dynamic Scheduling）在运行期实时决策：每个算子在执行前根据当前设备的空闲率、数据所在位置、优先级等进行判断，选择最快的路径。这天然适合在线推理、多租户等负载波动大的场景。负载均衡策略是动态调度的核心——但请注意，负载均衡不等于任务数量均分，而要权衡设备算力（FLOPS）、带宽、内存、能耗，通常用带权重的贪心选择或最小负载优先算法。设备利用率这个指标常用来衡量负载均衡的好坏：

派单规则定了，原料运送也不能掉链子。订单派给了流水线大师老G，可料还在仓库没搬过去，老G也只能干瞪眼。下一节我们看总调度如何打通“原料运输线”。

数据搬运优化

工坊里最让师傅们头疼的，往往不是活难，而是“料没到”。CPU 的“原料仓库”是主存（DDR），GPU 和 NPU 的仓库是各自的显存（HBM），中间只靠一条细细的 PCIe 总线连接。料在仓库搬一趟的时间，可能比师傅干活的时间还长。

异构计算中，数据搬运开销是性能的头号杀手。一个数据搬运周期的耗时可近似为数据量除以总线带宽。以 PCIe 4.0 x16 为例，理论带宽约 32GB/s，而 GPU 内部 HBM 带宽可达 TB/s 级，相差数十倍。如果每次 kernel 执行都先把数据从主存拷入显存、算完再传回，整体吞吐会被严重拉低。

优化手段可归为三大类：第一，减少搬运次数——算子融合（fusing），把多个算子合成一个 kernel，中间结果留在显存里不再回主存；第二，零拷贝 / 统一寻址——通过统一虚拟地址（UVM）、设备直传（P2P）、GPUDirect RDMA 等技术让数据在设备间直通，不经过 CPU 内存中转；第三，计算与通信重叠——用多流（Streaming）将数据预取和计算放到不同流水线上并发执行，使总耗时从加法关系变成取最大值：

原料运输线打通了，工坊速度快了不少。但订单千变万化——有些订单是“先雕花、再打磨、再组装”的连环工序，总调度得把一整条流程拆成一个个算子，动态编排给合适的师傅。这就是“算子调度实践”。

算子调度实践

现实中的订单往往不是孤立的活，而是整条流水线：比如一张“AI 雕塑”订单，要经历“切料→粗磨→雕刻→精修→上色”五道工序。对应到计算世界，一个深度学习模型就是一张计算图，图中每个节点（Conv、MatMul、ReLU、Softmax）都是一个算子。

算子调度的第一步是“算子映射”：Runtime 为每个算子选择目标设备上可执行的 kernel 实现。例如矩阵乘在 GPU 上可调用 cuBLAS 库，在 NPU 上可调用 CANN 的 MatMul 算子；某些算子在某设备上没有实现，就需要“回退”到 CPU 执行，或用其他算子组合代替。第二步是“图优化”：在算子执行前，调度器会对计算图做改造——算子融合（如 Conv+BN+ReLU 合并成一个 kernel）、常量折叠（把固定的计算提前算好）、内存复用规划（显存池）等。

第三步是“多流执行”：把没有依赖关系的算子放入不同 Stream，利用设备的多队列并发执行。最终执行时间取决于“关键路径”——即最慢的那条流。硬件适配则要求 Runtime 对不同厂商的 AI 芯片提供统一算子接口，屏蔽底层差异。多流执行的整体耗时可以写作：

掌握了算子级调度，你已经是位经验丰富的总调度了。不过要让工坊营收真正翻倍，还得学会“体检”——找出到底哪个环节在偷懒、哪个环节在堵车。这就是性能调优。

性能调优实战

总觉得工坊产能不对劲，但说不清是哪个师傅慢、哪条运输线堵，还是派单规则有漏洞。跟经营工坊一样，异构系统的性能调优第一步永远是“先测量、后动手”，而不是盲目改参数。

常用的性能分析方法包括：借助 profiling 工具（NVIDIA Nsight、昇腾 Profiler、Perf）记录每个 kernel 的执行时间、搬移时间、空闲等待时间；通过时间线（timeline）视图，可以直观找出 GPU 利用率的“空洞”在哪里。定位瓶颈的常用手法是分类讨论：计算密集型问题（设备利用率高但耗时仍长）→ 增大并行度或优化算法；搬运密集型问题（大量时间花在数据传输上）→ 算子融合和流水线重叠；调度开销问题（kernel 很小但数量很多）→ 合并小 kernel、减少启动次数。

系统性调优手段可归纳为：提高并行度（增大 batch、多卡并行）、提高数据局部性（缓存友好、减少跨设备访问）、异步化（异步推理、流水线并行）。Amdahl 定律告诉我们，即使把可并行部分做到极致，整体加速比仍然受串行部分瓶颈制约——所以不要忽略调度器本身的开销和同步等待。加速比公式如下：

从认识三位工匠，到搭起调度室，再到练就整套派单、运输、编排、体检的本领——你这家异构工坊终于开始高效运转。剩下要做的，就是把理论搬到真实战场，用代码和工具打磨成工程利器。

AI 应用场景

Python 演示

"""异构计算调度模拟器模拟标量/矩阵/神经网络三类任务在 CPU/GPU/NPU 上的调度与执行。"""  class Task:    def __init__(self, tid, kind, workload):        self.tid = tid        self.kind = kind        self.workload = workload        self.device = None        self.remain = workload  class Device:    def __init__(self, name, speed, kinds):        self.name = name        self.speed = speed        self.kinds = kinds        self.running = None     def can_run(self, kind):        return kind in self.kinds     def start(self, task):        self.running = task        task.device = self.name     def tick(self, dt):        if self.running:            self.running.remain -= self.speed * dt            if self.running.remain <= 0:                self.running.remain = 0                self.running = None     def idle(self):        return self.running is None  class Scheduler:    def __init__(self, devices):        self.devices = devices        self.queue = []     def submit(self, task):        self.queue.append(task)     def dispatch(self):        for task in list(self.queue):            for device in self.devices:                if device.can_run(task.kind) and device.idle():                    device.start(task)                    self.queue.remove(task)                    break     def run(self, dt=0.1):        t = 0.0        while self.queue or any(not d.idle() for d in self.devices):            self.dispatch()            for device in self.devices:                device.tick(dt)            t += dt        return t  def main():    cpu = Device("CPU", 1.0, {"scalar"})    gpu = Device("GPU", 8.0, {"matrix", "scalar"})    npu = Device("NPU", 16.0, {"neural", "matrix"})    scheduler = Scheduler([cpu, gpu, npu])     tasks = [        Task(0, "scalar", 4.0),        Task(1, "matrix", 40.0),        Task(2, "neural", 32.0),        Task(3, "matrix", 24.0),        Task(4, "scalar", 2.0),        Task(5, "neural", 8.0),    ]    for task in tasks:        scheduler.submit(task)     total = scheduler.run()    print(f"总耗时: {total:.1f} 秒")    for task in tasks:        print(f"任务{task.tid}({task.kind}) -> {task.device}")  if __name__ == "__main__":    main()

1. cpu = Device("CPU", 1.0, {"scalar"})定义设备算力和支持的任务类型，CPU 只跑标量任务。
2. if device.can_run(task.kind) and device.idle():调度核心判断：设备既支持该类型又空闲才派活。
3. task.remain -= self.speed * dt每个模拟步按设备算力扣减任务剩余量，算力越快完成越快。
4. device.start(task)把任务分配给设备，并记录任务落在了哪个设备上。
5. while self.queue or any(not d.idle() for d in self.devices):只要队列非空或有设备还在忙，调度就继续推进。
6. total = scheduler.run()启动整个调度模拟，返回所有任务完成的总时间。

常见误区

面试题