目录

一、引言

二、CANN核心价值概览

三、ACL接口：高效资源调度与简化开发

四、ACLNN算子库：极致性能优化与两段式调用

五、自定义算子开发：Ascend C编程语言与生态开放

六、图引擎与框架适配：全场景兼容与自动优化

七、实战案例：基于CANN的图像分类应用开发

八、快速上手指南：从环境搭建到第一个CANN程序

九、性能优化最佳实践：释放CANN极致性能

十、性能优化工具：Ascend Profiler助力瓶颈定位

十一、结语

---

一、引言

随着人工智能技术的飞速发展，AI模型规模和算力需求呈指数级增长。为应对这一挑战，华为推出了面向AI场景的异构计算架构——CANN（Compute Architecture for Neural Networks）。CANN作为连接上层AI框架与底层昇腾AI处理器的核心软件栈，承担着承上启下的关键作用。它不仅向上支持多种主流AI框架，向下服务AI处理器与编程，更是提升昇腾AI处理器计算效率的关键平台。本文将深入评测CANN的核心价值，重点分析其在简化AI开发、提升计算效率方面的优势，并剖析ACL接口的资源调度机制、ACLNN算子库的性能优化策略，以及自定义算子的开发路径，帮助开发者全面了解CANN如何赋能AI应用开发。

二、CANN核心价值概览

CANN作为华为昇腾AI计算的核心软件平台，其核心价值主要体现在以下几个方面：

核心价值

• 端云一致的异构计算架构：CANN构建了从云端到边缘的全场景AI计算能力，实现了端侧与云侧的统一编程模型和开发体验。开发者可以基于同一套CANN接口，在云端服务器、边缘设备乃至终端上进行模型部署和推理，无需为不同平台重复开发，大幅降低了开发和维护成本。

• 软硬自研开源开放：华为正推动CANN走向全面开源开放，计划于2025年底完成A2版本的开源。这意味着CANN的核心组件将逐步对社区开放，开发者可以参与共建，共享生态成果。开源策略将加速CANN的迭代创新，降低技术门槛，助力AI算力基座的繁荣。

• 极致性能与高效调度：CANN通过深度的软硬件协同优化，充分发挥昇腾AI处理器的算力潜能。其内置的高性能算子库、自动图引擎优化以及智能资源调度机制，能够显著提升模型训练和推理的效率。例如，在大模型训练场景下，CANN通过大颗粒算子融合、Kernel调度策略优化、通信并发流水等技术手段，有效解决了算力、内存和通信三大核心问题，使能大模型性能的深度优化。

• 极简易用的开发体验：CANN致力于降低AI开发的门槛，提供统一的编程接口和丰富的开发工具链。开发者无需深入底层硬件细节，即可通过ACL（Ascend Computing Language）等接口快速构建AI应用。同时，CANN配套了从模型转换、算子开发到性能调优的全流程工具，如MindStudio集成开发环境、Ascend Profiler性能分析工具等，帮助开发者高效完成从模型迁移到性能优化的全流程工作。

三、ACL接口：高效资源调度与简化开发

ACL（Ascend Computing Language）是CANN提供的面向应用开发者的核心编程接口，它将复杂的底层硬件操作封装为简洁易用的API，极大简化了AI应用的开发流程。开发者无需关心昇腾设备的具体细节，如设备选择、内存分配等，这些繁琐工作都由ACL自动处理。通过ACL，开发者可以专注于上层业务逻辑，快速构建高性能的AI应用。

ACL接口不仅降低了开发门槛，还提供了强大的资源调度能力，确保应用在昇腾硬件上高效运行。其关键特性包括：

• 自动化的内存管理：ACL内置了智能的内存管理机制，能够自动完成设备内存的分配、复用和释放。开发者无需手动管理复杂的内存生命周期，ACL会根据模型需求自动申请和回收内存，避免内存泄漏和浪费。这种自动化内存管理大幅提升了开发效率，同时保证了内存使用的高效性。

• 设备与上下文管理：ACL提供了对昇腾设备、上下文（Context）和流（Stream）的细粒度控制能力。开发者可以通过ACL接口选择特定的NPU设备，创建和管理多个上下文，实现多任务并行调度。通过流机制，开发者可以控制任务的并发执行顺序，优化任务调度时序，从而在多卡、多进程/线程场景下提升吞吐和降低延迟。

• 模型加载与执行：ACL封装了模型加载、数据预处理、推理执行和结果获取的完整流程。开发者只需几行代码即可完成模型的加载和推理。例如，通过ACL的acl.mdl.load_from_file接口加载模型文件，acl.mdl.execute接口执行推理，ACL会自动处理输入数据的格式转换、内存拷贝以及输出数据的获取，极大简化了推理流程。

• 多框架适配与兼容性：ACL作为CANN的统一编程接口，天然支持多种AI框架的模型。无论是PyTorch、TensorFlow还是MindSpore等框架训练的模型，都可以通过CANN的模型转换工具转换为适配昇腾的离线模型（OM模型），然后由ACL加载执行。这种多框架适配能力，使开发者能够无缝迁移现有模型到昇腾平台，保护已有投资。

通过ACL接口，开发者可以体验到前所未有的开发便捷性。下面是一个使用ACL进行模型推理的简化示例代码，展示了ACL如何将复杂的底层操作封装为简洁的API调用：

#include "acl/acl.h"

// 初始化ACL运行时
aclInit(nullptr);

// 加载模型文件
model_id = acl.mdl.load_from_file(model_path);

// 创建输入数据集并添加输入数据
input_dataset = acl.mdl.create_dataset();
acl.mdl.dataset_add_input(input_dataset, input_data);

// 执行模型推理
output_dataset = acl.mdl.create_dataset();
acl.mdl.execute(model_id, input_dataset, output_dataset);

// 获取推理结果
result = acl.mdl.dataset_get_output(output_dataset, 0);

上述代码中，开发者无需关心底层设备初始化、内存分配等细节，ACL接口自动完成了这些工作。这种高度抽象的接口设计，使得AI应用的开发变得如同调用普通函数般简单，极大地降低了开发难度和时间成本。

四、ACLNN算子库：极致性能优化与两段式调用

为了进一步简化开发并提升性能，CANN提供了ACLNN（Ascend Operator Library）算子库，这是一系列深度优化的高性能算子API集合。ACLNN库中的算子接口采用“两段式”设计，将算子的执行过程分为两个阶段：获取工作空间大小和执行计算。这种设计赋予开发者对内存分配和算子执行的精细控制，有助于实现极致的性能优化。

两段式接口的典型调用流程如下：

1. 第一段接口：获取工作空间大小。开发者首先调用算子的GetWorkspaceSize接口，传入输入张量等参数，该接口会计算出本次算子执行所需的临时内存（workspace）大小，并返回一个执行器（executor）对象。开发者根据返回的大小申请设备内存，为后续计算做好准备。

2. 第二段接口：执行计算。在获得足够的workspace内存后，开发者调用算子的执行接口，传入输入数据、输出数据、workspace内存以及执行器对象，完成实际的计算。执行完成后，开发者可以获取输出结果。

这种两段式设计的优势在于：内存分配与计算执行解耦。开发者可以在运行前一次性分配好所有需要的内存，避免在每次算子调用时频繁申请/释放内存带来的开销。此外，通过预先获取workspace大小，开发者可以更灵活地进行内存复用和优化，例如在多个算子之间共享workspace，从而减少内存占用。

ACLNN算子库的另一个显著优势是极致的性能优化。CANN团队对算子库中的每个算子都进行了深度优化，包括算法层面的优化和针对昇腾硬件的微架构优化。这些优化使得ACLNN算子在昇腾AI处理器上的执行效率达到业界领先水平。例如，对于高频的矩阵乘算子，CANN通过合理的Tiling数据切分、数据流水并行以及Cube与Vector算子融合等技术，充分利用了昇腾AI处理器的L1/L2缓存和Cube大算力，显著提升了算子的Cube利用率，实现了卓越的计算性能。

此外，ACLNN算子库还提供了丰富的融合算子。融合算子是将多个连续的计算步骤合并为一个算子，以减少中间结果的内存访问和调度开销。例如，在大模型推理中，常见的“矩阵乘+激活函数”组合可以被融合为一个算子，直接输出激活后的结果，避免了中间结果的存储和再次加载，从而大幅提升整体性能。CANN持续扩充其融合算子库，新增了80多个融合算子，覆盖了Transformer、MoE等大模型常见计算模式，为开发者提供即插即用的高性能算子。

下面以一个简单的加法算子aclnnAdd为例，演示ACLNN两段式接口的使用方法：

#include "acl/acl.h"
#include "aclnnop/aclnn_add.h"

// 初始化ACL运行时
aclInit(nullptr);

// 创建输入输出张量（此处省略具体数据准备过程）
aclTensor* x = ...;  // 输入张量x
aclTensor* y = ...;  // 输入张量y
aclTensor* out = ...; // 输出张量z

// 第一段接口：获取workspace大小
uint64_t workspaceSize = 0;
aclOpExecutor* executor = nullptr;
aclnnAddGetWorkspaceSize(x, y, alpha, out, &workspaceSize, &executor);

// 根据返回的大小申请设备内存
void* workspace = nullptr;
if (workspaceSize > 0) {
    aclrtMalloc(&workspace, workspaceSize, ACL_MEM_MALLOC_HUGE_FIRST);
}

// 第二段接口：执行加法计算
aclnnAdd(workspace, workspaceSize, executor, stream);

// 同步等待计算完成
aclrtSynchronizeStream(stream);

在上述代码中，开发者首先调用aclnnAddGetWorkspaceSize获取执行加法所需的临时内存大小，然后申请相应大小的内存，最后调用aclnnAdd完成实际的加法计算。通过这种两段式调用，开发者对内存分配和算子执行有了完全的控制，可以针对具体场景进行优化，例如预先分配一大块内存供多个算子复用，从而减少内存碎片和分配开销。

总的来说，ACLNN算子库通过两段式接口和深度性能优化，为开发者提供了既易用又高效的算子调用方案。开发者无需关心底层实现细节，只需按照接口规范调用，即可在昇腾硬件上获得极致的计算性能。

五、自定义算子开发：Ascend C编程语言与生态开放

尽管CANN提供了丰富的内置算子库，但在实际开发中，开发者可能遇到特定需求，例如需要实现某种特殊的数学运算，或者发现现有算子在特定场景下性能不足。此时，自定义算子开发就成为释放昇腾硬件潜能的关键途径。CANN为开发者提供了完备的自定义算子开发链路，其中核心是Ascend C编程语言。

Ascend C是CANN针对算子开发场景推出的编程语言，它原生支持C/C++标准规范，最大化匹配了广大开发者的开发习惯。通过Ascend C，开发者可以基于昇腾AI硬件，高效地实现自定义的创新算法。Ascend C通过多层接口抽象、自动并行计算、孪生调试等关键技术，极大提高了算子开发效率，助力AI开发者低成本完成算子开发和模型调优部署。

Ascend C的编程模型具有以下特点：

• 结构化核函数编程：Ascend C提供了一种结构化的编程范式，将算子的实现分解为“搬入、计算、搬出”三段式结构。开发者只需聚焦于算子的核心计算逻辑，而数据在全局内存与本地内存之间的搬运、并行任务的调度等工作都由框架自动完成。这种范式极大降低了并行编程的难度，使开发者能够像编写串行程序一样编写高性能的并行算子。

• 自动并行调度：Ascend C支持多核并行和流水线并行。开发者编写的核函数将自动在昇腾AI处理器的多个AI Core上并行执行，实现数据级的并行处理。同时，通过流水线技术，数据搬运和计算可以重叠进行，提高硬件资源的利用率。开发者无需手动管理线程或同步，Ascend C会自动完成并行调度，以获取最优的执行性能。

• 丰富的算子库支持：Ascend C不仅提供基础API（如标量、向量、矩阵计算接口），还封装了高阶API（如Matmul、Softmax等常用算法对象）。开发者可以基于这些API快速构建算子，而无需从零开始编写复杂的算法逻辑。这种分层设计兼顾了灵活性和开发效率，基础API保证了底层功能的完备性，高阶API则大幅提升了开发效率。

• CPU/NPU孪生调试：Ascend C支持在CPU域和NPU域进行孪生调试。开发者可以先在CPU上使用标准调试工具（如GDB）对算子逻辑进行调试和验证，然后再将代码编译到NPU上运行，进行性能验证。这种调试方式极大降低了算子开发的难度，提高了开发效率，因为CPU调试更加方便快捷，而NPU调试则用于最终的性能验证。

通过Ascend C，开发者可以编写出高性能的自定义算子，并将其无缝集成到AI模型中。CANN还提供了完善的算子开发工具链，包括算子原型定义、信息库、适配插件等组件，帮助开发者完成从算子实现到框架适配的全流程工作。此外，CANN的算子开发社区非常活跃，官方提供了丰富的样例代码和文档，如算子开发指南、最佳实践等，帮助开发者快速上手。

值得一提的是，CANN的自定义算子开发生态正朝着更加开放的方向发展。华为已宣布将全面开源CANN，包括Ascend C编程语言和相关的算子库。这意味着开发者将能够参与Ascend C的演进，贡献自己的算子实现，并与全球开发者共同完善昇腾AI计算生态。开源策略将加速新算子的创新和共享，降低开发门槛，推动AI算力基座的繁荣。

六、图引擎与框架适配：全场景兼容与自动优化

CANN的图引擎（Graph Engine）是其另一个核心组件，它在AI模型从训练到部署的整个生命周期中扮演着“优化中枢”的角色。图引擎负责将AI框架的计算图转换为适配昇腾硬件的高效执行图，并进行一系列优化，以提升模型的运行效率和稳定性。

图引擎的主要功能包括：

• 模型转换与图编译：当开发者使用PyTorch、TensorFlow等框架训练好模型后，需要将其转换为适配昇腾的离线模型（OM模型）才能在昇腾硬件上运行。CANN的图引擎通过ATC（Ascend Tensor Compiler）工具，将原始框架的计算图解析、优化并编译为OM模型。在这个过程中，图引擎会进行算子融合、常量折叠、内存优化等编译优化，生成在昇腾硬件上高效执行的模型。

• 图模式与下沉调度：在推理场景下，图引擎支持将模型以“图模式”下发到设备执行，相比传统的“单算子模式”可以显著提升调度性能。在单算子模式下，Host需要逐个下发算子到Device执行，如果Device执行速度很快，Host可能成为瓶颈，导致Device出现空闲等待（Host Bound现象）。而图模式会将整个模型一次性下发到Device，Device上的调度器负责依次执行模型中的所有算子，无需Host频繁干预，从而减少了Host-Device交互的开销。对于静态shape模型，图引擎甚至支持“下沉调度”，将模型加载到Device后，只需在Host侧触发一个模型执行Task，Device即可自动完成整个模型的执行，进一步提升了调度性能。

• 动态Shape支持：针对输入shape动态变化的场景，图引擎也提供了相应的优化方案。传统上，昇腾更适合静态shape模型，但通过图引擎的动态Shape调度技术，CANN能够对动态shape模型进行有效的调度优化，避免因shape变化导致的性能下降。图引擎会根据shape变化动态调整内存分配和算子调度策略，确保模型在动态shape场景下依然保持高效运行。

• 框架适配与兼容性：CANN的图引擎通过适配插件与主流AI框架无缝对接。无论是PyTorch、TensorFlow还是MindSpore，CANN都提供了相应的适配层，将框架的算子映射为CANN支持的算子，并处理框架特有的数据类型和格式转换。这种框架适配能力保证了开发者可以平滑地将现有模型迁移到昇腾平台，无需修改模型结构或训练代码，即可享受昇腾硬件带来的性能提升。

通过图引擎的优化，CANN能够充分发挥昇腾硬件的性能，并简化开发者的部署工作。开发者无需关心底层硬件的调度细节，只需使用熟悉的框架训练模型，然后通过CANN的工具链一键部署，即可在昇腾AI处理器上获得卓越的运行效率。

七、实战案例：基于CANN的图像分类应用开发

为了更直观地展示CANN在简化AI开发和提升效率方面的优势，下面我们通过一个实战案例——基于CANN的图像分类Web应用，来解析CANN在实际开发中的应用方式。该案例采用前后端分离架构，后端基于CANN的ACL接口实现图像推理服务，前端提供用户友好的界面，支持拖拽上传图片并实时展示分类结果。

项目架构：该Web应用的后端使用Python Flask框架，通过调用CANN的ACL接口加载预训练的ResNet50模型，并对用户上传的图像进行推理。前端采用HTML5和JavaScript，实现了图片拖拽上传、实时预览和结果展示等功能，为用户提供流畅的交互体验。

后端开发流程：

1. 模型加载：后端首先调用ACL接口加载模型文件。开发者只需提供模型路径，ACL会自动完成设备选择、内存分配等底层工作，返回模型ID和模型描述信息。这一过程非常简洁，开发者无需关心模型如何在昇腾硬件上初始化，ACL已经封装了所有必要的步骤。

2. 图像预处理：用户上传的图像首先需要进行预处理，包括尺寸调整、归一化等，以符合模型输入要求。这些预处理步骤在Host端完成，与CANN无关。开发者可以使用OpenCV等库在CPU上完成图像的解码和预处理。

3. 推理执行：预处理后的图像数据被封装为ACL的输入数据集，然后调用acl.mdl.execute接口执行模型推理。ACL会自动将输入数据从Host内存拷贝到Device内存，启动模型计算，并将结果从Device拷贝回Host。开发者无需编写任何数据搬运或并行调度的代码，ACL接口已经完成了这些工作。

4. 结果获取与返回：推理完成后，开发者通过acl.mdl.dataset_get_output接口获取模型的输出结果。输出结果通常是一个包含各类别概率的张量。后端解析该张量，找出概率最高的类别及其置信度，然后将结果以JSON格式返回给前端。

前端开发流程：前端使用标准的Web技术实现，与CANN无关。它通过拖拽上传的方式接收用户图片，使用FileReader API在浏览器端预览图片，然后通过AJAX请求将图片发送给后端进行推理。收到后端返回的JSON结果后，前端动态生成HTML元素，展示分类类别和置信度，并通过进度条动画直观地呈现置信度大小。

部署与性能：该应用可以部署在配备昇腾AI处理器的服务器上。由于使用了CANN的ACL接口，后端推理服务能够充分利用昇腾硬件的加速能力，实现高并发、低延迟的图像分类。在实际测试中，该应用在单张图片推理上表现出色，推理速度远超基于CPU的方案，能够满足实时交互的需求。

通过这个案例，我们可以清晰地看到CANN在AI应用开发中的价值：简化了模型部署流程（开发者无需深入底层即可加载模型和执行推理），提升了应用性能（利用昇腾硬件加速实现高效推理），以及降低了开发门槛（开发者可以使用熟悉的框架和语言进行开发，通过CANN接口无缝对接昇腾硬件）。这充分验证了CANN作为端云一致异构计算架构的实用性和优越性。

八、快速上手指南：从环境搭建到第一个CANN程序

为了帮助开发者快速入门CANN，本节提供一个从环境搭建到编写第一个CANN程序的完整指南。我们将以在昇腾NPU上运行一个简单的向量加法算子为例，演示如何使用CANN的ACL接口和Ascend C编程语言完成开发、编译和运行的全过程。

步骤1：环境准备

在开始开发之前，需要先搭建好CANN的开发和运行环境。以下是环境搭建的主要步骤：

• 安装CANN软件包：根据昇腾硬件型号和操作系统，从华为昇腾官网下载对应版本的CANN软件包（包括Toolkit、Kernels、NNAL等）并安装。确保安装的CANN版本与硬件驱动兼容。

• 配置环境变量：安装完成后，需要设置环境变量以便系统能够找到CANN的头文件和库文件。通常需要执行类似以下命令（以bash为例）：

source /usr/local/Ascend/ascend-toolkit/set_env.sh

• 该脚本会将CANN的安装路径添加到PATH和LD_LIBRARY_PATH等环境变量中。

• 验证安装：可以通过运行CANN自带的样例或使用npu-smi命令来验证环境是否搭建成功。例如，执行npu-smi应能列出昇腾设备的状态信息，表示驱动和运行时已正确安装。

步骤2：编写第一个CANN程序

我们将编写一个简单的向量加法程序，该程序使用Ascend C语言实现一个自定义的向量加法算子，并通过ACL接口在昇腾NPU上执行该算子。下面是完整的代码示例：

#include <iostream>
#include <vector>
#include "acl/acl.h"

// 自定义向量加法算子的核函数（在NPU上执行）
extern "C" __global__ __aicore__ void add_custom_kernel(const float* x, const float* y, float* z, uint32_t totalLength) {
    // 获取当前处理的数据索引
    uint32_t idx = get_block_idx() * get_block_stride() + get_thread_idx();
    // 边界检查，防止越界
    if (idx < totalLength) {
        z[idx] = x[idx] + y[idx];
    }
}

int main() {
    // 1. 初始化ACL运行时
    auto ret = aclInit(nullptr);
    if (ret != ACL_SUCCESS) {
        std::cerr << "Failed to initialize ACL, error: " << ret << std::endl;
        return -1;
    }

    // 2. 设置当前使用的设备
    int32_t deviceId = 0;
    ret = aclrtSetDevice(deviceId);
    if (ret != ACL_SUCCESS) {
        std::cerr << "Failed to set device, error: " << ret << std::endl;
        aclFinalize();
        return -1;
    }

    // 3. 准备输入数据
    const uint32_t length = 1024;
    std::vector<float> host_x(length, 1.0f);  // 向量x，元素全为1
    std::vector<float> host_y(length, 2.0f);  // 向量y，元素全为2
    std::vector<float> host_z(length, 0.0f);  // 结果向量z，初始为0

    // 4. 在设备上分配内存
    void* device_x = nullptr;
    void* device_y = nullptr;
    void* device_z = nullptr;
    size_t buffer_size = length * sizeof(float);
    aclrtMalloc(&device_x, buffer_size, ACL_MEM_MALLOC_HUGE_FIRST);
    aclrtMalloc(&device_y, buffer_size, ACL_MEM_MALLOC_HUGE_FIRST);
    aclrtMalloc(&device_z, buffer_size, ACL_MEM_MALLOC_HUGE_FIRST);

    // 5. 将输入数据从Host拷贝到Device
    aclrtMemcpy(device_x, buffer_size, host_x.data(), buffer_size, ACL_MEMCPY_HOST_TO_DEVICE);
    aclrtMemcpy(device_y, buffer_size, host_y.data(), buffer_size, ACL_MEMCPY_HOST_TO_DEVICE);

    // 6. 创建执行流
    aclrtStream stream;
    aclrtCreateStream(&stream);

    // 7. 使用<<<启动语法调用核函数（类似于CUDA的启动方式）
    // 这里使用1个Block，每个Block包含length个Thread
    add_custom_kernel<<<1, length>>>(reinterpret_cast<float*>(device_x),
                                   reinterpret_cast<float*>(device_y),
                                   reinterpret_cast<float*>(device_z),
                                   length);

    // 8. 等待Device执行完成
    aclrtSynchronizeStream(stream);

    // 9. 将结果数据从Device拷贝回Host
    aclrtMemcpy(host_z.data(), buffer_size, device_z, buffer_size, ACL_MEMCPY_DEVICE_TO_HOST);

    // 10. 验证结果
    bool correct = true;
    for (uint32_t i = 0; i < length; ++i) {
        if (abs(host_z[i] - 3.0f) > 1e-6) {
            correct = false;
            break;
        }
    }
    if (correct) {
        std::cout << "Result is correct!" << std::endl;
    } else {
        std::cout << "Result is incorrect!" << std::endl;
    }

    // 11. 释放资源
    aclrtFree(device_x);
    aclrtFree(device_y);
    aclrtFree(device_z);
    aclrtDestroyStream(stream);
    aclrtResetDevice(deviceId);
    aclFinalize();

    return 0;
}

代码解析：

• 第1-10行：包含必要的头文件，并定义了自定义的向量加法核函数add_custom_kernel。该核函数使用Ascend C的扩展语法，其中global和aicore是Ascend C特有的修饰符，表示该函数将在昇腾AI Core上执行。核函数的逻辑非常简单，就是将输入的两个向量逐元素相加，并将结果存入输出向量。

• 第12-55行：main函数实现了完整的ACL调用流程。首先初始化ACL运行时并设置设备，然后准备输入数据并在设备上分配内存。接着将输入数据从主机内存拷贝到设备内存，之后使用<<<>>启动语法调用核函数（类似于CUDA的核函数启动方式）。核函数启动后，通过aclrtSynchronizeStream等待设备执行完成，然后将结果数据拷贝回主机内存进行验证。最后释放所有申请的资源。

步骤3：编译与运行

将上述代码保存为add_custom.cpp，然后使用CANN提供的编译器ascendc进行编译。编译命令如下：

ascendc add_custom.cpp -o add_custom -I/usr/local/Ascend/ascend-toolkit/latest/acllib/include -L/usr/local/Ascend/ascend-toolkit/latest/acllib/lib64 -lacl

该命令指定了头文件和库文件的路径，并链接了ACL库。编译成功后，会生成可执行文件add_custom。

运行程序：

./add_custom

如果一切正常，程序将输出“Result is correct!”，表示向量加法的结果正确。至此，我们完成了从环境搭建到编写、编译、运行第一个CANN程序的全过程。

小结：通过这个简单的示例，开发者可以掌握CANN的基本开发流程，包括ACL初始化、设备管理、内存拷贝、核函数启动等关键步骤。这为后续开发更复杂的AI应用奠定了基础。

九、性能优化最佳实践：释放CANN极致性能

在掌握了CANN的基本使用方法后，如何进一步优化程序性能以充分发挥昇腾硬件的算力，是开发者关注的重点。本节将结合CANN的特性，介绍一些常用的性能优化最佳实践，并提供相应的代码示例。

1.优化内存访问模式

内存访问效率是影响算子性能的关键因素之一。昇腾AI处理器具有多级存储结构（如L1/L2缓存、本地内存等），合理的内存访问模式可以显著提升性能。以下是一些优化建议：

• 尽量使用连续内存访问：避免跨步（stride）访问，尽量按顺序访问内存，以提高缓存命中率。例如，将非连续访问改为连续访问可以减少缓存未命中，提升带宽利用率。

• 利用本地内存（Local Memory）：对于需要多次访问的数据，可以将其从全局内存（Global Memory）加载到本地内存中，减少重复的全局内存访问。本地内存的访问延迟更低，带宽更高，能够有效提升算子性能。

• 数据对齐：确保数据在内存中的对齐，避免非对齐访问带来的性能损失。CANN对数据地址有对齐要求（通常需要32字节对齐），不满足对齐的访问可能导致额外的开销或错误。

下面是一个优化内存访问的示例代码片段，展示了如何通过使用本地内存来减少全局内存访问：

__global__ __aicore__ void optimized_add_kernel(const float* x, const float* y, float* z, uint32_t totalLength) {
    // 使用本地内存缓存输入数据
    __local__ float local_x[256];
    __local__ float local_y[256];
    uint32_t idx = get_block_idx() * get_block_stride() + get_thread_idx();
    // 分批处理数据，每次处理256个元素
    for (uint32_t i = 0; i < totalLength; i += 256) {
        // 将数据从全局内存加载到本地内存
        DataCopy(local_x, x + i, 256 * sizeof(float));
        DataCopy(local_y, y + i, 256 * sizeof(float));
        // 在本地内存中执行计算
        for (uint32_t j = 0; j < 256; ++j) {
            z[i + j] = local_x[j] + local_y[j];
        }
    }
}

在上述代码中，我们使用了local关键字定义了本地内存数组local_x和local_y，并通过DataCopy接口将数据从全局内存拷贝到本地内存。然后在本地内存中执行加法计算，最后将结果写回全局内存。相比直接在全局内存中逐元素访问，这种分批处理并利用本地内存的方式可以减少全局内存访问次数，提升性能。

2.利用融合算子减少数据搬运

融合算子（Fused Operator）是将多个连续的计算步骤合并为一个算子，以减少中间结果的内存访问和调度开销。CANN提供了丰富的融合算子，开发者应尽量使用这些融合算子，或者通过Ascend C将多个基础算子融合为一个自定义算子，以提升性能。

例如，对于常见的“矩阵乘+偏置加+激活函数”序列，可以使用CANN提供的融合算子MatmulBiasRelu，将这三步合并为一个算子执行，从而避免中间结果的存储和再次加载。又如，在大模型推理中，可以将注意力机制中的多个小算子融合为一个大的“注意力算子”，显著减少数据搬运次数。

如果CANN内置的融合算子无法满足需求，开发者可以使用Ascend C编写自定义的融合算子。下面是一个将“矩阵乘+ReLU”融合的示例：

__global__ __aicore__ void matmul_relu_fusion_kernel(const float* A, const float* B, float* C, uint32_t M, uint32_t N, uint32_t K) {
    // 计算当前线程处理的输出元素索引
    uint32_t row = get_block_idx() * get_block_stride() + get_thread_idx();
    uint32_t col = 0; // 假设每个线程处理一行
    // 边界检查
    if (row >= M) return;
    // 计算矩阵乘法
    float sum = 0.0f;
    for (uint32_t k = 0; k < K; ++k) {
        sum += A[row * K + k] * B[k * N + col];
    }
    // 应用ReLU激活函数
    C[row * N + col] = (sum > 0) ? sum : 0;
}

在上述代码中，我们将矩阵乘法和ReLU激活融合在一个核函数中完成，直接输出激活后的结果。相比先调用矩阵乘算子再调用ReLU算子，这种融合算子减少了一次中间结果的存储和再次加载，能够提升整体性能。

3.合理使用并行和流水

Ascend C支持多核并行和流水线并行。开发者应充分利用昇腾AI处理器的多核特性，将数据拆分到多个核上并行处理，以提升吞吐量。同时，通过流水线技术，可以将数据搬运和计算重叠执行，隐藏内存访问延迟，提高硬件资源的利用率。

以下是一个利用多核并行的示例：

__global__ __aicore__ void parallel_add_kernel(const float* x, const float* y, float* z, uint32_t totalLength) {
    // 获取当前核的索引
    uint32_t blockIdx = get_block_idx();
    // 计算每个核处理的数据范围
    uint32_t blockSize = totalLength / get_block_num();
    uint32_t startIdx = blockIdx * blockSize;
    uint32_t endIdx = (blockIdx == get_block_num() - 1) ? totalLength : startIdx + blockSize;
    // 每个核处理自己的数据段
    for (uint32_t i = startIdx; i < endIdx; ++i) {
        z[i] = x[i] + y[i];
    }
}

在上述代码中，我们通过get_block_idx获取当前核的索引，然后计算每个核负责处理的数据范围。每个核只处理总数据的一部分，从而实现多核并行。这种并行方式可以充分利用昇腾AI处理器的多核优势，提升算子的执行效率。

4.使用Profiler定位瓶颈

性能优化是一个迭代的过程，开发者需要借助工具来定位性能瓶颈并进行针对性优化。CANN提供的Ascend Profiler是强大的性能分析工具，能够采集算子执行时间、内存带宽、硬件资源利用率等关键指标，并生成可视化报告。开发者应定期使用Profiler对程序进行性能分析，找出耗时最长的算子或资源利用率最低的部分，然后进行优化。

例如，通过Profiler报告发现某个算子的执行时间占比过高，且其计算单元利用率很低，而DDR带宽使用率很高，那么可以判断该算子存在内存访问瓶颈。针对这一瓶颈，开发者可以采取相应的优化措施，如启用数据预取、调整数据布局、使用融合算子等，以减少内存访问次数，提升计算单元利用率。

5.调整编译选项和参数

CANN的编译器和运行时提供了许多可调参数，开发者可以根据应用特点进行调整以获取更好的性能。例如：

• 调整算子编译选项：在编译自定义算子时，可以尝试不同的编译选项（如-O3优化级别、-march指定目标架构等）来生成更高效的机器码。

• 调整运行时参数：在ACL初始化时，可以通过aclrtSetDevice的参数选择不同的设备模式（如RC模式或EP模式）以适应不同的应用场景。对于推理场景，通常使用EP模式以获得更低的延迟；对于训练场景，可以使用RC模式以获得更高的吞吐。

• 调整算子调度参数：可以通过环境变量或ACL接口调整算子调度的策略，如设置ACL_OP_DEBUG_LEVEL来获取算子执行的详细信息，或设置ACL_EXEC_REPEAT来重复执行算子以减少调度开销等。

通过以上优化实践，开发者可以逐步提升程序在昇腾硬件上的运行效率，充分释放CANN的极致性能。

十、性能优化工具：Ascend Profiler助力瓶颈定位

在AI应用的开发和部署过程中，性能优化是永恒的主题。为了帮助开发者深入挖掘模型和算子的性能潜力，CANN提供了强大的性能分析工具——Ascend Profiler。Ascend Profiler是CANN生态中面向昇腾芯片的专业性能分析工具，支持训练与推理全场景的性能数据采集。它通过全方位的数据采集与可视化分析，成为开发者定位和突破算子性能瓶颈的核心利器。

Ascend Profiler的核心优势在于其多维度的数据采集能力和直观的可视化分析界面。它能够采集算子计算时间、内存带宽、硬件资源利用率（NPU计算单元、DDR、PCIe）等关键指标，并通过时序图、统计报表、火焰图等形式直观呈现性能瓶颈。开发者可以借助Profiler深入洞察模型在昇腾硬件上的运行细节，从而有针对性地进行优化。

使用Ascend Profiler进行性能分析的一般流程如下：

1. 环境配置：在训练或推理脚本中集成Profiler的初始化代码，配置需要采集的指标类型和范围。例如，可以设置采集所有算子的执行时长和硬件资源使用情况。

2. 数据采集：运行目标模型或算子，Profiler会在后台记录性能数据。开发者可以控制采集的起止时间，以捕获特定场景下的性能信息。

3. 结果分析：采集完成后，Profiler会生成HTML格式的可视化报告和JSON格式的原始数据文件。开发者打开HTML报告，可以通过交互式的图表查看性能数据。例如，在“Operator Analysis”页面，可以查看每个算子的平均执行时间、计算单元利用率、DDR带宽使用率等指标。这些数据能够帮助开发者快速定位哪些算子是性能瓶颈。

4. 瓶颈定位与优化：通过分析报告，开发者可以识别出性能瓶颈的根源。例如，如果发现某个算子的执行时间占比过高，且其计算单元利用率很低，而DDR带宽使用率很高，那么可以判断该算子存在内存访问瓶颈。针对这一瓶颈，开发者可以采取相应的优化措施，如启用数据预取、调整数据布局、使用融合算子等，以减少内存访问次数，提升计算单元利用率。

5. 优化效果验证：在实施优化后，开发者可以再次使用Profiler采集性能数据，对比优化前后的报告，验证优化效果。如果优化成功，将看到算子的执行时间缩短、硬件利用率提升等积极变化。

Ascend Profiler在复杂场景下尤为有用。例如，在大模型训练中，模型可能包含成百上千个算子，手动定位瓶颈几乎不可能。而Profiler能够自动采集和分析所有算子的性能数据，帮助开发者快速找到需要优化的关键算子。再如，在多卡分布式训练场景下，Profiler可以采集通信相关的性能数据，帮助开发者发现通信瓶颈并进行优化。

总之，Ascend Profiler为开发者提供了一把“手术刀”，能够精准地剖析模型在昇腾硬件上的运行状况。通过掌握Profiler的使用方法，开发者可以大幅提升性能调优的效率，充分释放昇腾AI处理器的算力潜力。

十一、结语

通过以上对CANN异构计算架构的深度评测，我们可以清晰地看到，CANN作为华为昇腾AI生态的核心软件平台，在简化AI开发、提升计算效率方面展现出了卓越的价值。它通过统一的ACL接口和强大的图引擎，将复杂的底层硬件操作封装为简洁易用的API，大幅降低了AI应用的开发门槛。同时，CANN通过深度优化的ACLNN算子库和完善的性能分析工具，帮助开发者充分挖掘昇腾硬件的性能潜力，实现极致的计算效率。此外，CANN开放的自定义算子开发链路和开源策略，为开发者提供了无限的灵活性和创新空间，推动了AI计算生态的繁荣。

随着CANN的不断演进和开源开放的深入，我们有理由相信，它将成为更多开发者的首选AI计算平台。在未来的AI应用开发中，CANN将持续赋能开发者，让AI创新更加高效、便捷。对于广大开发者而言，掌握CANN的使用，将意味着掌握了一把开启昇腾AI算力宝库的钥匙，能够在AI时代抢占先机，创造更大的价值。