一个Token的昇腾之旅——从模型输入到硬件执行的完整链路-平芜编程栈

前言

当你在昇腾设备上运行大语言模型，输入「昇腾CANN生态很强大」这8个字符时，这些字符会先被拆成多个Token（每个Token对应一个语义单元，比如「昇」「腾」「CANN」等），每个Token就像等待运输的快递包裹，即将开启一段从软件层到硬件层的完整旅程。这段旅程跨越了昇腾异构计算架构（CANN）的多个层级，每一步都有专门的「工作人员」负责，最终在硬件中完成计算，再把结果原路送回你面前。

Step 1：AscendCL——快递打包员，给包裹贴统一面单

当你把输入文本发给模型时，第一步要做的就是把这些零散的Token（快递包裹）整理成昇腾硬件能识别的标准格式，这一步由统一编程接口AscendCL完成，它就像快递打包员，负责把用户的物品（输入数据）装进标准的快递盒，贴上统一的面单，方便后续所有环节的处理。

AscendCL的核心作用是提供统一的编程接口，屏蔽不同模型框架（TensorFlow、PyTorch等）和不同硬件型号的差异，让上层应用不用关心底层细节，只要调用AscendCL的接口就能完成数据的准备和模型的加载。对于我们的Token包裹来说，AscendCL要做的事情就是：把主机内存中的输入数据（Token对应的embedding向量）拷贝到昇腾设备的内存中，并封装成标准的aclmdlDataset数据结构，相当于给每个快递包裹贴上统一的面单，注明收件人（目标硬件）、物品类型（数据类型）、重量（数据大小）等信息。

下面是一段AscendCL准备输入数据的代码示例（C++接口），每一行都对应打包员的具体操作：

// 1. 包含AscendCL头文件，引入所有接口定义#include"acl/acl.h"// 2. 初始化AscendCL资源，相当于打包员上岗，准备工具aclError ret=aclInit(nullptr);if(ret!=ACL_SUCCESS){printf("Init AscendCL failed\n");return-1;}// 3. 创建输入数据集对象，相当于准备一个快递托盘，用来放所有包裹aclmdlDataset*inputDataset=aclmdlCreateDataset();if(inputDataset==nullptr){printf("Create input dataset failed\n");return-1;}// 4. 创建单个Tensor对象，对应一个Token包裹，设置数据地址、大小、数据类型aclTensor*inputTensor=aclCreateTensor({1,128},// Tensor形状：1个Token，embedding长度128ACL_FLOAT16,// 数据类型：半精度浮点，适配昇腾硬件devInputPtr,// 设备端数据地址128*sizeof(aclFloat16)// 数据大小：128个半精度浮点数);if(inputTensor==nullptr){printf("Create input tensor failed\n");return-1;}// 5. 把单个Tensor加入输入数据集，相当于把包裹放到托盘上ret=aclmdlAddDatasetTensor(inputDataset,inputTensor);if(ret!=ACL_SUCCESS){printf("Add tensor to dataset failed\n");return-1;}// 6. 把主机内存中的输入数据拷贝到设备内存，相当于把包裹里的物品装进标准快递盒ret=aclrtMemcpy(devInputPtr,// 设备端目标地址128*sizeof(aclFloat16),// 拷贝大小hostInputPtr,// 主机端源地址128*sizeof(aclFloat16),// 拷贝大小ACL_MEMCPY_HOST_TO_DEVICE// 拷贝方向：主机到设备);if(ret!=ACL_SUCCESS){printf("Memcpy host to device failed\n");return-1;}

逐行解释：

第 1 行：引入AscendCL的所有接口定义，打包员拿到工作手册，明确操作规范。
第 2 行：初始化AscendCL运行环境，检查硬件资源是否可用，打包员上岗前核验工具完整性。
第 3 行：创建输入数据集对象，用来存放所有输入Token，准备统一的快递托盘，所有包裹都要放在上面流转。
第 4 行：创建单个Tensor对象，对应一个Token的数据，设置形状、数据类型、地址和大小，给每个包裹贴标签。
第 5 行：把Tensor加入输入数据集，把包裹放到托盘上，完成打包前的归集。
第 6 行：把主机内存的输入数据拷贝到设备内存，因为昇腾硬件只能访问自身设备内存，相当于把包裹物品装进标准快递盒。

AscendCL的价值正是这种统一封装能力：不同模型框架的输出格式、数据存放位置差异极大，AscendCL作为统一编程接口屏蔽了所有上层差异，让后续环节只需处理标准格式的数据——相当于快递打包员不管用户寄什么物品，都用标准盒封装、贴统一面单，大幅提升整个物流系统的流转效率。

Step 2：GE 图引擎——零散包裹拼整车，优化运输效率

当AscendCL把所有Token包裹打包成标准的aclmdlDataset之后，这些包裹并不会直接被送走，而是要先经过GE（图引擎）的处理，GE就像物流中心的拼车调度员，负责把零散的包裹（多个小算子）拼成一整车（优化后的模型图），减少运输次数，提升效率。

GE图引擎的核心作用是做图编译优化，它接收AscendCL输出的模型图（由多个算子节点和边组成），然后执行一系列优化操作：算子融合（把多个相邻小算子合并成一个大算子，减少Kernel启动次数）、内存复用（不同算子的内存块共享，减少内存分配开销）、常量折叠（提前计算模型中的常量结果，避免重复计算）。这些优化就像把零散快递包裹拼成一整车，减少运输频次、降低物流成本。

// 1. 包含GE图引擎头文件，引入所有接口定义#include"ge/ge_api.h"// 2. 创建GEGraph对象，相当于准备一辆空的货车，用来装所有包裹ge::GEGraphgraph("llm_inference_model");// 3. 添加算子节点到图中，相当于把零散包裹放到货车上ge::OperatormatmulOp("matmul_0","MatMulV2");matmulOp.SetInput("x",inputTensor);matmulOp.SetInput("w",weightTensor);matmulOp.SetOutput("y",outputTensor);graph.AddOp(matmulOp);ge::OperatorreluOp("relu_0","ReLU");reluOp.SetInput("x",outputTensor);reluOp.SetOutput("y",finalOutputTensor);graph.AddOp(reluOp);// 4. 设置图优化选项，相当于调度员规划拼车策略std::map<std::string,std::string>options;options["ge.exec.enableFusion"]="1";// 开启算子融合options["ge.exec.enableMemoryReuse"]="1";// 开启内存复用options["ge.exec.fusionSwitch"]="all";// 开启全量融合策略ge::GraphManager::GetInstance().SetOptions(options);// 5. 编译图，生成优化后的离线模型，相当于把包裹装车、固定位置、规划路线ge::ModelBufferData modelBuffer;ge::GraphManager::GetInstance().CompileGraph(graph,modelBuffer);// 6. 保存离线模型到文件，相当于把装满包裹的货车停到待发区ge::GraphManager::GetInstance().SaveModel(modelBuffer,"/path/to/optimized_model.om");

逐行解释：

第 2 行：创建GEGraph对象，对应整个模型的计算图，准备一辆空的货车。
第 3 行：添加MatMul和ReLU两个算子节点到计算图中，设置输入输出依赖关系，把零散包裹放到货车上，明确运输顺序。
第 4 行：设置图优化选项，开启算子融合和内存复用，调度员规划拼车策略。
第 5 行：编译计算图，GE根据优化策略对图做等价变换，把MatMul+ReLU融合成一个算子。
第 6 行：保存优化后的离线模型到文件，把装满包裹的货车停到待发区，等待物流调度中心分配路线。

GE的图优化价值非常明确：原始模型图中存在大量小算子，每个算子都需要单独启动Kernel、单独搬运数据，开销极高。GE的算子融合可以减少30%以上的Kernel启动次数，内存复用可以减少20%以上的内存占用——相当于把零散包裹拼成整车，只启动一次货车、只搬运一次，效率提升显著。

Step 3：Runtime——物流调度中心，分配最优路线

当GE把优化后的离线模型准备好之后，接下来要做的就是把这个模型加载到昇腾设备上、分配计算资源，这一步由Runtime完成，它就像物流调度中心，负责根据当前硬件资源情况，给每个包裹分配最优路线，保证运输效率。

Runtime的核心作用是负责昇腾设备的资源管理、内存管理、任务调度。对于我们的Token包裹来说，Runtime要做的事情就是：把优化后的离线模型加载到昇腾设备内存中，分配空闲的AICore计算资源，把输入数据拷贝到设备内存，然后提交任务到执行队列，等待计算完成。

// 1. 包含Runtime头文件，引入所有接口定义#include"runtime/rt.h"// 2. 分配设备内存，存储输入数据和模型数据，相当于调度中心准备高带宽仓库void*devInputPtr=nullptr;rtError_t ret=rtMalloc(&devInputPtr,// 设备内存地址指针128*sizeof(aclFloat16),// 分配大小：1个Token的embeddingRT_MEMORY_HBM// 内存类型：高带宽内存);if(ret!=RT_ERROR_NONE){printf("Malloc device memory failed\n");return-1;}// 3. 拷贝输入数据从主机内存到设备内存ret=rtMemcpy(devInputPtr,// 设备端目标地址128*sizeof(aclFloat16),// 拷贝大小hostInputPtr,// 主机端源地址128*sizeof(aclFloat16),// 拷贝大小RT_MEMCPY_HOST_TO_DEVICE// 拷贝方向：主机到设备);if(ret!=RT_ERROR_NONE){printf("Memcpy host to device failed\n");return-1;}// 4. 加载优化后的离线模型到设备内存uint32_tmodelId=0;ret=rtModelLoad("/path/to/optimized_model.om",// 离线模型路径&modelId// 输出的模型ID);if(ret!=RT_ERROR_NONE){printf("Load model failed\n");return-1;}// 5. 创建任务描述符，设置算子输入输出rtTaskDesc taskDesc;memset(&taskDesc,0,sizeof(rtTaskDesc));taskDesc.modelId=modelId;// 绑定的模型IDtaskDesc.inputData=devInputPtr;// 输入数据地址taskDesc.outputData=devOutputPtr;// 输出数据地址// 6. 提交任务到执行队列，等待执行完成ret=rtTaskSubmit(&taskDesc,sizeof(taskDesc),nullptr,nullptr);if(ret!=RT_ERROR_NONE){printf("Submit task failed\n");return-1;}ret=rtTaskWait(nullptr);if(ret!=RT_ERROR_NONE){printf("Wait task failed\n");return-1;}

逐行解释：

第 2 行：分配设备高带宽内存（HBM），HBM的带宽是普通DDR的10倍以上，准备高带宽仓库提升包裹装卸效率。
第 3 行：把主机内存的输入数据拷贝到设备HBM，把包裹从集散中心（主机内存）运到调度中心仓库（设备HBM）。
第 4 行：加载优化后的离线模型到设备内存，把装满包裹的货车运到调度中心停车场。
第 5 行：创建任务描述符，设置模型ID、输入输出地址和大小，调度中心给货车分配路线。
第 6 行：提交任务到执行队列，Runtime自动把任务分配到空闲的AICore上执行，调度中心给货车发出发指令。

Runtime的核心价值是统一资源调度：昇腾设备包含多个AICore（比如Ascend 910包含32个AICore），如果让上层应用自行分配资源，极易出现资源冲突。Runtime作为统一调度中心，会动态感知硬件资源状态，避免冲突、提升资源利用率——相当于物流调度中心统一分配路线，避免堵车，保证所有货车按时到达。

Step 4：ops-nn 算子——卡车司机，完成实际运输任务

当Runtime把任务分配到AICore之后，接下来要做的就是真正执行计算，这一步由ops-nn算子库完成，它就像卡车司机，负责把货物（数据）从出发地运到目的地，完成实际的计算任务。

ops-nn是昇腾官方算子库，提供了所有常用神经网络算子的实现，比如MatMul、ReLU、Softmax等，这些算子都是用Ascend C编程语言编写的。Ascend C是专门为昇腾达芬奇架构设计的算子编程语言，可以充分发挥硬件的计算能力。

// 1. 包含Ascend C算子头文件，引入所有算子接口定义#include"kernel_operator.h"// 2. 定义向量加法算子类，封装算子的初始化和执行逻辑classAddKernel{public:__aicore__inlineAddKernel(){pipe.InitBuffer(inQueueT,1,inputSize*sizeof(float));pipe.InitBuffer(outQueueT,1,outputSize*sizeof(float));}__aicore__inlinevoidInit(uint32_tsize){this->inputSize=size;this->outputSize=size;inQueueT.Init(inQueueBuf,inputSize);outQueueT.Init(outQueueBuf,outputSize);}__aicore__inlinevoidProcess(){autoinputLocal=inQueueT.AllocTensor<float>();inQueueT.PopTensor(inputLocal);autooutputLocal=outQueueT.AllocTensor<float>();// 向量加法：output[i] = input[i] + input[i+N/2]for(uint32_ti=0;i<inputSize/2;++i){outputLocal.SetValue(i,inputLocal.GetValue(i)+inputLocal.GetValue(i+inputSize/2));}outQueueT.PushTensor(outputLocal);}private:TPipe pipe;TQue<tQuePosition::VECIN,1>inQueueT;TQue<tQuePosition::VECOUT,1>outQueueT;};

逐行解释：

第 2 行：定义向量加法算子类AddKernel，封装算子的初始化和执行逻辑。所有Ascend C算子都以类的形式组织。
第 3 行：构造函数初始化输入输出队列的缓冲区。pipe.InitBuffer分配SRAM上的内存，队列用来管理输入输出数据的流转。
第 7 行：Init方法设置输入输出大小，初始化输入输出队列。
第 10 行：Process方法是算子的核心计算逻辑，AllocTensor从队列分配SRAM上的局部张量。
第 12 行：inQueueT.PopTensor从输入队列取数据，数据从HBM搬到SRAM。
第 13-15 行：在SRAM上执行向量加法计算，这是真正消耗计算资源的地方。
第 16 行：outQueueT.PushTensor把计算结果从SRAM推送到输出队列，数据写回HBM。

ops-nn算子的精妙之处在于它完全基于Ascend C编程，充分利用达芬奇架构的硬件特性：SRAM片上高速缓存、AI Core矩阵计算单元（Cube Unit）、向量化指令等。每个算子的实现都是对硬件能力的直接映射，没有抽象层、没有虚拟化开销——这就是为什么昇腾算子的执行效率极高。

Step 5：Driver——公路规则，让卡车能上达芬奇高速

当ops-nn算子在AICore上完成计算后，计算结果需要写回HBM内存，然后通过PCIe返回给主机。这个过程中，Driver（驱动层）扮演的角色就像公路规则——它定义了卡车（算子计算结果）如何驶上达芬奇高速（昇腾达芬奇架构），以及高速上的交通规则（内存访问协议、数据传输机制）。

Driver层负责管理昇腾设备和主机之间的通信，包括PCIe总线的配置与数据传输、DMA（直接内存访问）引擎的控制、HBM内存的地址空间管理等。对于Token包裹来说，Driver要做的事情就是：确保计算结果能正确地从昇腾设备（HBM）传输回主机内存，同时处理设备中断、错误恢复等底层事务。

// 1. 包含Driver头文件，引入驱动层接口定义#include"driver/drv.h"// 2. 初始化驱动，检测并配置昇腾设备drvError_t drvRet=drvInit();if(drvRet!=DRV_SUCCESS){printf("Init driver failed\n");return-1;}// 3. 获取昇腾设备句柄，用于后续操作drvDevice_t*device=nullptr;drvRet=drvGetDevice(0,&device);if(drvRet!=DRV_SUCCESS){printf("Get device failed\n");return-1;}// 4. 配置PCIe DMA传输，从设备HBM传输数据到主机内存drvDmaDesc dmaDesc;drvDmaDescInit(&dmaDesc,device);drvDmaDescSetSrc(&dmaDesc,devOutputPtr);// 源地址：设备HBMdrvDmaDescSetDst(&dmaDesc,hostOutputPtr);// 目标地址：主机内存drvDmaDescSetSize(&dmaDesc,128*sizeof(aclFloat16));// 传输大小drvDmaDescSetDir(&dmaDesc,DRV_DMA_DIR_DEVICE_TO_HOST);// 传输方向// 5. 启动DMA传输，等待完成drvRet=drvDmaSubmit(&dmaDesc);if(drvRet!=DRV_SUCCESS){printf("Submit DMA failed\n");return-1;}drvRet=drvDmaWait(&dmaDesc,nullptr);if(drvRet!=DRV_SUCCESS){printf("Wait DMA failed\n");return-1;}

逐行解释：

第 2 行：初始化驱动，检测并配置昇腾设备，相当于公路管理员检查高速入口是否正常开放。
第 3 行：获取昇腾设备句柄，后续所有设备操作都需要这个句柄。
第 4 行：配置PCIe DMA传输描述符，设置源地址（HBM）、目标地址（主机内存）、传输大小。DMA引擎可以在不占用CPU的情况下直接搬运数据，是高速数据传输的关键。
第 5 行：提交DMA传输请求，驱动会启动PCIe总线的数据传输。
第 6 行：等待DMA传输完成，确保数据安全到达主机内存。

Driver层的核心价值在于它定义了昇腾设备与主机之间的物理传输规则。无论是AscendCL、GE还是Runtime，它们的数据传输最终都要落实到Driver层的PCIe DMA操作上。没有Driver层，软件的计算结果就永远无法返回给用户——相当于高速公路没有建成，所有卡车都上不了路。

Step 6：达芬奇架构——高速公路和计算工厂

经历了上述五个步骤，Token包裹终于到达了旅程的最后一站——昇腾达芬奇架构。达芬奇架构是昇腾芯片的计算核心，它就像一条超级高速公路和一座巨型计算工厂的结合体，包含了大量的AICore（AI Core，计算核心）、缓存系统和总线互联结构。

达芬奇架构的核心组件是AICore，每个AICore包含三大计算单元：

Cube Unit（矩阵计算单元）：专门用于大矩阵乘法，性能是普通向量单元的16倍以上，是Transformer模型计算的核心引擎。
Vector Unit（向量计算单元）：执行逐元素操作（ReLU、Softmax等），处理Cube Unit无法处理的其他计算。
Scalar Unit（标量计算单元）：控制流、地址计算、循环控制等，相当于工厂的管理系统。

对于Token包裹来说，达芬奇架构的AICore是最终的目的地——算子（如MatMul、LayerNorm）的计算指令被下发给AICore，在Cube Unit中完成矩阵乘法，在Vector Unit中完成归一化，在Scalar Unit中完成数据地址的计算，最终结果写回到HBM的指定位置。

达芬奇架构的计算流水线： 主机内存 ──PCIe──> HBM高带宽内存 ──> SRAM片上缓存 ──> AICore Cube Unit ▲ │ │ ▼ 结果写回 计算输出 ▲ │ │ ▼ └────── SRAM片上缓存 ──> HBM ──PCIe──> 主机内存

整个数据流的关键在于SRAM是AICore的"速记纸"：每次计算时，数据从HBM（慢速但容量大）加载到SRAM（快速但容量小），在AICore上完成计算，结果写回HBM。这个过程不断循环，直到整个模型的计算全部完成。达芬奇架构的设计哲学正是"让数据在靠近计算单元的地方快速访问"，通过层层缓存减少对慢速HBM的访问次数，从而提升整体性能。

旅程终点站：Token 完成计算，原路返回

当Token经过AscendCL打包、GE图引擎拼车、Runtime调度、ops-nn算子执行、Driver公路规则，最终在达芬奇架构的AICore中完成计算后，计算结果会原路返回：

计算结果从AICore写回HBM
Driver的DMA引擎通过PCIe将结果传输回主机内存
Runtime通知上层任务完成
AscendCL将结果封装成标准的aclmdlDataset，返回给用户

整个旅程的每一层都各司其职：AscendCL负责统一打包，GE负责图优化，Runtime负责资源调度，ops-nn负责算子执行，Driver负责物理传输，达芬奇架构负责最终的计算。这种分层设计的好处是每层都可以独立演进——比如新的算子只需要在ops-nn层实现，无需改动AscendCL或Runtime；新的硬件只需要更新Driver层，上层软件无需感知。

这种优雅的架构设计，正是昇腾CANN生态能够在国际竞争中保持技术领先的底层逻辑之一。