CANN 组织链接： https://atomgit.com/cann
asc-devkit 仓库链接： https://atomgit.com/cann/asc-devkit

---

在人工智能芯片的广阔领域中，硬件的强大算力需要一套同样强大的软件工具来充分挖掘和利用。asc-devkit 正是 CANN (Compute Architecture for Neural Networks) 软件栈中扮演这一核心角色的低层级开发工具包。它不仅仅是一个简单的库集合，而是直接暴露了 AI 处理器硬件底层能力的接口层，为上层的 CANN Runtime、Compiler、Catlass 等组件提供了与 AI 处理器进行高效交互的基石。

asc-devkit 封装了对 AI 处理器设备的管理、内存操作、任务提交以及性能监控等关键功能，使得开发者能够构建出极致优化的 AI 应用。无论是进行底层的 Kernel 开发、性能调优，还是构建定制化的 AI 解决方案，asc-devkit 都提供了必要的工具和接口。它使得 CANN 软件栈能够充分利用 AI 处理器独特的并行计算架构和异构特性，是实现高效、稳定 AI 应用不可或缺的底层支撑。本文将深入探讨 asc-devkit 的技术内涵、其在 AI 处理器生态中的价值以及如何赋能高性能 AI 应用的开发。

1. 引言：asc-devkit 在 AI 处理器生态中的核心角色

asc-devkit 作为 CANN 软件栈的底层组件，其存在意义在于提供一个稳定、高效、可控的接口层，连接复杂多变的 AI 处理器硬件与上层应用软件。

1.1 与硬件交互的桥梁

AI 处理器具备高度定制化的计算单元、多层次存储结构和复杂的并行调度机制。直接与这些硬件交互需要深入了解其微架构细节，这对于大多数开发者来说门槛极高。asc-devkit 通过构建一套统一的抽象层，极大地简化了这一过程：

• 指令集与微码封装：它将 AI 处理器底层的复杂指令集和微码操作封装成易于理解和调用的 API。开发者无需直接编写硬件汇编，即可驱动 AI 处理器执行计算任务。
• 硬件接口标准化：无论是不同型号的 AI 处理器，还是同一型号的不同版本，asc-devkit 都能提供一套标准化的接口。这意味着基于 asc-devkit 开发的软件具备良好的跨硬件平台兼容性。
• 屏蔽底层复杂性：从设备初始化、内存管理到任务提交和同步，asc-devkit 将这些复杂的硬件编程细节抽象化，使得上层软件能够专注于其核心逻辑，而无需担忧底层的实现细节。

1.2 低层级开发者的核心工具

对于追求极致性能、需要深度定制或进行特定硬件功能验证的开发者而言，asc-devkit 是不可或缺的工具。它提供了直接操纵硬件资源的能力：

• 自定义 Kernel 开发：开发者可以利用 asc-devkit 提供的底层接口，结合专用编程语言（如 Ascend C），编写高性能的自定义算子 Kernel。这使得 AI 处理器能够灵活支持新型算法或特定业务逻辑。
• 精细化性能调优：通过 asc-devkit，开发者可以对内存访问模式、任务调度、数据传输等进行精细化控制。这对于在特定应用场景下榨取硬件的最后一丝性能至关重要。
• 硬件功能验证与测试：在 AI 处理器开发和测试阶段，asc-devkit 提供了直接访问硬件功能和性能计数器的能力，便于验证硬件设计的正确性和效率。

1.3 CANN 软件栈的底层支撑

asc-devkit 的高效与稳定，直接支撑着 CANN 软件栈中更高层组件的正常运行和优异表现。它是整个 AI 计算生态系统中的基石：

• CANN Runtime 的驱动：CANN Runtime 作为执行层，负责将编译后的模型部署到 AI 处理器上运行。Runtime 的所有底层设备管理、内存操作和任务提交，都通过 asc-devkit 提供的 API 来完成。
• Catlass 算子库的实现基础：Catlass 库中的所有高性能算子，其底层实现都离不开 asc-devkit 提供的硬件接口。asc-devkit 确保了这些算子能够高效地利用 AI 处理器独特的计算能力。
• 编译器优化的落地：CANN 编译器在进行图优化和算子融合后，最终生成的底层指令或 Kernel 代码，也需要通过 asc-devkit 提交给 AI 处理器执行。asc-devkit 确保了编译器优化的成果能够高效地转化为硬件性能。

2. 设备管理与资源抽象

asc-devkit 的核心功能之一是有效地管理 AI 处理器设备及其宝贵的计算和存储资源，并向上层提供清晰的抽象。

2.1 AI 处理器设备发现与初始化

在任何 AI 处理器计算任务开始之前，系统都需要识别并准备好可用的硬件。asc-devkit 在此过程中扮演关键角色：

• 设备枚举与识别：asc-devkit 能够扫描系统，发现所有已安装和可用的 AI 处理器设备，并为每个设备分配一个唯一的逻辑 ID。这使得上层应用可以指定在哪个设备上执行任务。
• 设备状态查询：开发者可以通过 asc-devkit 查询设备的详细信息，如设备型号、计算能力、可用内存、固件版本、健康状况等，为任务分配和故障诊断提供依据。
• 设备初始化与配置：在设备被使用前，asc-devkit 会进行一系列的初始化操作，包括加载必要的固件、设置设备工作模式、清除状态等，确保设备处于可执行计算任务的就绪状态。

2.2 设备内存管理与数据传输

高效的内存管理和数据传输是 AI 处理器性能的关键。asc-devkit 提供了精细的设备内存操作能力：

• 设备内存分配与释放：asc-devkit 允许上层应用在 AI 处理器设备上动态分配和释放显存（Device Memory）。这包括为模型权重、输入/输出数据、中间激活等分配空间，并提供不同类型的内存分配策略（如连续内存、共享内存）。
• 主机-设备数据传输：提供主机（CPU）与 AI 处理器之间数据传输的接口。这包括同步和异步的内存拷贝操作。异步拷贝允许主机 CPU 在数据传输进行时继续执行其他任务，从而隐藏数据传输延迟，提升整体效率。
• 内存区域与访问权限管理：在多进程、多用户或多租户场景下，asc-devkit 能够管理 AI 处理器上不同的内存区域，并设置相应的访问权限，确保资源隔离和数据安全，防止非法访问。

2.3 多设备上下文与流管理

为了支持复杂的并行任务和资源共享，asc-devkit 引入了上下文和流的概念：

• 设备上下文 (Context)：上下文是 AI 处理器设备上的一个逻辑执行环境，它封装了设备的资源、状态和配置。每个应用或模块通常会创建一个或多个上下文，实现资源隔离和管理。
• 任务流 (Stream)：流是 AI 处理器上一个独立的指令序列，同一流中的操作按提交顺序执行。不同流中的操作可以并行执行（如果硬件资源允许），从而实现计算和数据传输的异步并发。
• 流间同步与事件 (Event)：asc-devkit 提供了事件机制，允许开发者在流中的特定点记录事件，并在其他流中等待事件完成。这使得实现通信和计算的精确同步、管理任务依赖变得可能，例如，确保数据传输完成后才开始计算。

3. 任务提交与指令执行

asc-devkit 是将上层应用意图转化为 AI 处理器可执行操作的关键环节，它负责高效地提交计算任务和管理指令执行流程。

3.1 Kernel 函数加载与调用

AI 处理器上的实际计算逻辑通常以 Kernel 函数的形式存在。asc-devkit 提供了加载和执行这些 Kernel 的机制：

• Kernel 模块加载：预编译好的 Kernel 二进制模块（通常包含 AI 处理器原生指令）通过 asc-devkit 加载到 AI 处理器设备内存中。asc-devkit 负责处理 Kernel 的内存映射和准备工作。
• Kernel 参数传递：当需要执行一个 Kernel 时，asc-devkit 负责将输入数据的设备地址、输出数据的设备地址以及算子所需的其他常量参数高效地传递给 Kernel。这些参数通常存储在设备内存中或通过寄存器传递。
• Kernel 启动与调度：asc-devkit 负责向 AI 处理器硬件下达指令，启动指定的 Kernel 函数。在多任务环境下，asc-devkit 还会参与 Kernel 任务的调度，确保硬件资源的合理分配和任务的顺利执行。

3.2 DMA 控制与数据搬运

为了避免 CPU 成为数据传输的瓶颈，AI 处理器通常配备了 DMA 引擎。asc-devkit 提供了对其的精细控制：

• 零拷贝传输：asc-devkit 能够协调 AI 处理器内部的 DMA 引擎，实现在不同内存区域（如全局显存到片上缓冲、AI 处理器到 AI 处理器）之间的高速数据传输，而无需 CPU 介入。这大大减少了数据传输的延迟。
• 计算与传输并行：通过 DMA 引擎的异步操作能力，asc-devkit 允许数据传输与计算任务并行进行。例如，当一个 Kernel 正在处理当前数据块时，DMA 引擎可以同时将下一个数据块从主机内存传输到设备内存，从而隐藏传输延迟。
• 内存访问优化：asc-devkit 在控制 DMA 传输时，会考虑 AI 处理器内存的访问模式，如合并访问、预取等，以最大化内存带宽利用率，减少内存等待时间。

3.3 异步执行与事件同步机制

现代高性能计算系统普遍采用异步执行以提升并行度，asc-devkit 提供了强大的异步机制：

• 非阻塞式 API：asc-devkit 提供大量非阻塞式的 API 调用，如异步内存拷贝、异步 Kernel 启动，这些调用会立即返回，而实际操作在后台由 AI 处理器异步完成。
• 事件 (Event) 管理：开发者可以在任何异步操作完成后标记一个事件。其他依赖此操作的任务可以等待此事件，当事件触发时，依赖任务才开始执行。这种事件驱动的同步机制允许构建复杂的异步计算图。
• 任务队列与依赖：通过流和事件，asc-devkit 能够管理任务之间的依赖关系。例如，它确保只有当一个算子的输入数据完全传输到设备后，相应的计算 Kernel 才会被调度执行，保证了数据流的正确性。

4. 性能分析与调试支持

asc-devkit 不仅负责执行任务，也提供了强大的工具和接口，帮助开发者深入理解 AI 处理器的工作状态，进行性能分析和问题诊断。

4.1 硬件性能计数器访问

为了量化 AI 处理器各个模块的工作效率，asc-devkit 提供了访问底层硬件性能计数器的能力：

• 核心利用率统计：开发者可以通过 asc-devkit 获取矩阵计算单元、向量计算单元、DMA 引擎等核心部件的利用率数据，判断计算任务是否充分利用了硬件资源，是否存在空闲或瓶颈。
• 内存访问统计：asc-devkit 能够提供内存访问次数、缓存命中率、内存带宽占用、内存读写冲突等关键数据，帮助开发者分析内存访问模式，发现数据传输瓶颈和优化内存布局。
• 指令执行与等待统计：更细致的计数器可以统计不同类型指令（如加载、存储、计算）的执行次数、任务等待时间、时钟周期计数等，从而揭示潜在的调度问题、指令级效率瓶颈或硬件流水线停顿。

4.2 事件追踪与时间线分析

要理解复杂并行任务的执行顺序和相互关系，事件追踪是不可或缺的手段，asc-devkit 支持生成详细的事件日志：

• 任务生命周期记录：asc-devkit 能够记录 AI 处理器上各类任务（如 Kernel 启动、数据传输开始/结束、同步点）的精确时间戳。这些记录可以形成详细的任务生命周期日志。
• 时间线可视化支持：通过这些事件日志，结合上层性能分析工具，可以生成直观的时间线视图。开发者可以清晰地看到不同任务（计算、数据传输、同步）在时间轴上的分布、重叠情况以及等待耗时，从而识别潜在的并行度不足或同步开销。
• 数据流追踪：可以追踪特定数据块从主机到设备，再到各个计算单元处理，最终返回主机的完整路径和时间点。这有助于深入分析整个数据流的效率和延迟贡献。

4.3 错误报告与诊断辅助

当 AI 处理器或其驱动程序发生异常时，asc-devkit 提供了详细的错误信息，帮助开发者快速定位问题：

• 系统级错误码：asc-devkit 定义了一套全面、规范的错误码体系，涵盖了设备初始化失败、内存操作错误、Kernel 执行异常、硬件故障等各种底层问题。每个错误码都有清晰的含义。
• 详细错误信息与上下文：除了错误码，asc-devkit 还会提供详细的错误描述、发生错误时的设备ID、函数名称、可能涉及的资源、调用堆栈等上下文信息，极大地加速了问题的诊断过程。
• 日志记录与上报：asc-devkit 内置了丰富的日志记录功能，可以将底层的运行状态、警告和错误信息记录下来，并支持将关键故障信息上报给系统日志、监控平台或远程调试工具，便于远程排查。

5. 开发者接口与编程模型

asc-devkit 提供了一套精心设计的 API 接口和辅助工具，旨在为不同层次的开发者提供灵活而高效的开发体验。

5.1 C++ API 与底层封装

asc-devkit 的核心功能通常通过 C++ API 的形式暴露，提供了高性能和精细控制的能力，这是因为它需要最大限度地发挥 AI 处理器的潜力：

• 面向对象与函数式：API 设计融合了面向对象和函数式编程范式，提供了直观的类（如 Device, Context, Stream）来表示硬件概念，以及简洁的函数调用来执行操作。
• 内存安全与并发考虑：API 在设计时充分考虑了内存安全和并发访问的需求，提供线程安全的接口，并可能包含 RAII (Resource Acquisition Is Initialization) 风格的资源管理，以减少内存泄漏和并发问题。
• 版本兼容性：asc-devkit 的 API 接口会努力保持向后兼容性，确保基于旧版本 API 开发的应用能在新版本的 asc-devkit 上运行，减少升级成本。

5.2 专用 Kernel 编程语言支持

为了让开发者能够更高效地编写高性能的 Kernel 代码，asc-devkit 生态提供了专用工具：

• Ascend C 语言：作为一种专为 AI 处理器 Kernel 开发设计的语言，Ascend C 提供了更接近硬件的编程范式和丰富的原语。它允许开发者以 C 语言的表达力，同时利用 AI 处理器独特的计算能力（如张量计算单元、向量计算单元），编写高度优化的 Kernel。
• Kernel 编译工具链：asc-devkit 提供配套的编译器和链接器，能够将 Ascend C 或其他 Kernel 源码编译成 AI 处理器可执行的二进制指令。
• 运行时集成：编译后的 Kernel 通过 asc-devkit 的 API 加载并执行。这种集成使得 Kernel 开发者能够专注于计算逻辑，而无需关心底层的硬件交互细节。

5.3 与上层软件的协同

虽然 asc-devkit 提供了底层接口，但其最常见的使用方式是通过上层 CANN 组件进行间接调用，形成一个完整的软件栈：

• CANN Runtime 的底层驱动：CANN Runtime 依赖 asc-devkit 来完成 AI 处理器设备的初始化、内存管理、任务提交和流同步。Runtime 将模型执行的逻辑请求转化为对 asc-devkit 接口的调用。
• Catlass 算子库的实现基础：Catlass 中所有高度优化的算子 Kernel，其底层实现就是通过 asc-devkit 提供的指令集接口和内存操作接口来完成的。asc-devkit 为 Catlass 提供了充分利用硬件的能力。
• 统一的生态视图：通过这种分层设计，开发者可以在不同抽象层次进行开发，既可以通过上层框架快速构建应用，也可以在需要时深入到 asc-devkit 层面进行精细优化，实现了灵活性和效率的平衡。

6. 安全性、稳定性与未来演进

asc-devkit 作为底层基础设施，其安全性和稳定性对于 AI 处理器系统的整体可靠性至关重要。同时，它也在不断演进以适应未来的技术发展。

6.1 资源隔离与故障保护

在多用户、多任务或多租户环境中，确保不同应用之间的资源隔离是系统稳定运行的基础：

• 多进程/多线程安全：asc-devkit 的 API 接口设计考虑了多进程和多线程环境下的安全性，通过互斥锁、信号量等机制确保对共享资源的正确访问，防止数据损坏和死锁。
• 内存保护与沙箱：asc-devkit 在硬件层面利用 AI 处理器的内存管理单元 (MMU) 提供内存保护机制，确保一个应用无法非法访问或修改其他应用或操作系统内核的内存区域。这有效地防止了应用间的干扰和恶意行为。
• 权限管理：系统可以根据用户或应用的权限级别，限制其对 AI 处理器设备的访问能力，例如限制对某些敏感寄存器或内存区域的读写，从而增强系统的安全性。

6.2 固件管理与版本升级

AI 处理器固件的生命周期管理也是 asc-devkit 的重要职责之一，这关系到硬件功能的正确性和安全性：

• 固件加载与验证：asc-devkit 负责在设备初始化时加载 AI 处理器固件。它还会对固件进行完整性校验（如 CRC、哈希）和安全认证（如数字签名），确保固件的合法性、未被篡改，并防止加载恶意固件。
• 固件版本管理：asc-devkit 能够查询当前设备的固件版本信息，并支持在需要时进行固件升级操作。固件升级可以引入新功能、修复硬件缺陷、提升性能或解决安全漏洞。
• 安全更新机制：固件升级过程遵循严格的安全协议，确保升级包的来源可靠、升级过程防篡改，同时支持回滚机制，以防升级失败导致设备不可用。

6.3 支持未来硬件与计算范式

asc-devkit 的设计考虑了未来 AI 处理器硬件的快速迭代和 AI 算法的演进，具备良好的可扩展性：

• 适配新型硬件架构：随着 AI 处理器集成更多不同类型的计算单元（如稀疏计算单元、图计算单元），asc-devkit 将持续更新以提供对这些新型硬件的统一编程接口和调度机制。
• 支持新的数据类型与精度：面对未来可能出现的 FP8、BF16 等新的数据类型或混合精度计算模式，asc-devkit 将提供相应的底层支持，确保这些数据类型能在硬件上高效运行。
• 探索新兴计算范式：asc-devkit 将与时俱进，探索与新兴计算范式（如量子计算、类脑计算）的接口和兼容性，为其在 AI 处理器上的实现提供底层支撑，为未来的 AI 创新提供可能性。

---

附录：asc-devkit 概念性 C++ API 交互示例

以下是一个概念性的 C++ 代码片段，旨在说明一个底层应用或 CANN Runtime 组件如何可能与 asc-devkit 提供的 API 进行交互，以完成设备初始化、内存分配和简单的异步内存拷贝操作。此示例着重于展示 API 的调用模式和核心概念，它并非直接可编译运行的代码，因为它省略了所有必要的头文件定义、完整的错误处理和上下文配置。其目的仅仅是展示如何通过 asc-devkit 抽象地调用底层硬件功能。

#include <iostream>
#include <vector>
#include <string>
#include <memory> // For std::unique_ptr
#include <thread> // For std::this_thread::sleep_for
#include <chrono> // For std::chrono::milliseconds

// 概念性：asc-devkit 库的 API 接口头文件
namespace AscDevKit {

    // 概念性：代表一个 AI 处理器设备
    class Device {
    public:
        int id;
        Device(int device_id) : id(device_id) {}
        // ... 其他设备属性和操作，例如查询算力、内存大小等
    };

    // 概念性：代表一个设备上下文，隔离不同任务的资源
    class Context {
    public:
        int device_id;
        std::string handle; // 模拟句柄，标识上下文
        Context(int dev_id) : device_id(dev_id), handle("Context_" + std::to_string(dev_id)) {}
        // ... 其他上下文管理操作，如设置当前上下文
    };

    // 概念性：代表一个异步执行流，用于命令排队
    class Stream {
    public:
        std::string handle; // 模拟句柄
        Stream(const std::string& context_handle) : handle("Stream_from_" + context_handle) {}
        // ... 其他流管理操作，如等待流中所有任务完成
    };

    // 概念性：代表一个事件，用于流间同步
    class Event {
    public:
        std::string handle; // 模拟句柄
        Event() : handle("Event_" + std::to_string(rand())) {} // 随机生成事件 ID
        // ... 其他事件操作，如记录事件、等待事件
    };

    // 概念性：函数返回状态码
    enum Status {
        OK = 0,
        ERROR_DEVICE_NOT_FOUND,
        ERROR_MEMORY_ALLOCATION_FAILED,
        ERROR_INVALID_ARGUMENT,
        ERROR_DEVICE_INIT_FAILED,
        // ... 其他错误码，例如表示 Kernel 执行失败
    };

    // --- 设备管理 API 示例 ---
    Status InitDevice(int device_id) {
        std::cout << "[AscDevKit] 初始化设备 " << device_id << "..." << std::endl;
        // 实际会进行硬件初始化、加载固件、设置驱动等复杂操作
        std::this_thread::sleep_for(std::chrono::milliseconds(50)); // 模拟初始化时间
        if (device_id < 0) return ERROR_DEVICE_INIT_FAILED; // 模拟错误
        return OK;
    }

    Status CreateContext(int device_id, std::unique_ptr<Context>& context_out) {
        std::cout << "[AscDevKit] 为设备 " << device_id << " 创建上下文..." << std::endl;
        std::this_thread::sleep_for(std::chrono::milliseconds(20));
        context_out = std::make_unique<Context>(device_id); // 构造上下文对象
        if (!context_out) return ERROR_MEMORY_ALLOCATION_FAILED;
        return OK;
    }

    Status DestroyContext(std::unique_ptr<Context>& context) {
        if (!context) return OK;
        std::cout << "[AscDevKit] 销毁上下文 " << context->handle << "..." << std::endl;
        std::this_thread::sleep_for(std::chrono::milliseconds(10));
        context.reset(); // 释放智能指针管理的资源
        return OK;
    }

    // --- 流管理 API 示例 ---
    Status CreateStream(const Context& context, std::unique_ptr<Stream>& stream_out) {
        std::cout << "[AscDevKit] 在上下文 " << context.handle << " 中创建流..." << std::endl;
        std::this_thread::sleep_for(std::chrono::milliseconds(15));
        stream_out = std::make_unique<Stream>(context.handle); // 构造流对象
        if (!stream_out) return ERROR_MEMORY_ALLOCATION_FAILED;
        return OK;
    }

    Status DestroyStream(std::unique_ptr<Stream>& stream) {
        if (!stream) return OK;
        std::cout << "[AscDevKit] 销毁流 " << stream->handle << "..." << std::endl;
        std::this_thread::sleep_for(std::chrono::milliseconds(5));
        stream.reset(); // 释放资源
        return OK;
    }

    // --- 内存管理 API 示例 ---
    Status MallocDeviceMemory(void** dev_ptr, size_t size_bytes) {
        std::cout << "[AscDevKit] 在设备上分配 " << size_bytes << " 字节内存..." << std::endl;
        // 模拟设备内存指针，实际是硬件分配的虚拟地址或物理地址
        *dev_ptr = reinterpret_cast<void*>(0x10000000ULL + (rand() % 0x100000ULL)); // 概念性地址
        if (!*dev_ptr) return ERROR_MEMORY_ALLOCATION_FAILED; // 模拟分配失败
        std::this_thread::sleep_for(std::chrono::milliseconds(10));
        return OK;
    }

    Status FreeDeviceMemory(void* dev_ptr) {
        if (!dev_ptr) return OK;
        std::cout << "[AscDevKit] 释放设备内存 " << dev_ptr << "..." << std::endl;
        std::this_thread::sleep_for(std::chrono::milliseconds(5));
        return OK;
    }

    Status MemcpyHostToDeviceAsync(void* dev_ptr, const void* host_ptr, size_t size_bytes, const Stream& stream) {
        std::cout << "[AscDevKit] 异步拷贝 " << size_bytes << " 字节从 Host " << host_ptr << " 到 Device " << dev_ptr << ", 流 " << stream.handle << "..." << std::endl;
        std::this_thread::sleep_for(std::chrono::milliseconds(30)); // 模拟拷贝时间
        return OK;
    }

    Status MemcpyDeviceToHostAsync(void* host_ptr, const void* dev_ptr, size_t size_bytes, const Stream& stream) {
        std::cout << "[AscDevKit] 异步拷贝 " << size_bytes << " 字节从 Device " << dev_ptr << " 到 Host " << host_ptr << ", 流 " << stream.handle << "..." << std::endl;
        std::this_thread::sleep_for(std::chrono::milliseconds(30)); // 模拟拷贝时间
        return OK;
    }

    // --- 同步 API 示例 ---
    Status StreamSynchronize(const Stream& stream) {
        std::cout << "[AscDevKit] 同步流 " << stream.handle << "，等待所有命令完成..." << std::endl;
        std::this_thread::sleep_for(std::chrono::milliseconds(40)); // 模拟等待任务完成
        return OK;
    }

    // 概念性 Kernel 启动函数
    Status LaunchCustomKernel(const Stream& stream, void* input_dev_ptr, void* output_dev_ptr, size_t element_count) {
        std::cout << "[AscDevKit] 在流 " << stream.handle << " 上启动自定义 Kernel，处理 " << element_count << " 元素..." << std::endl;
        // 实际会在这里将 Kernel 二进制代码提交给 AI 处理器执行
        std::this_thread::sleep_for(std::chrono::milliseconds(70)); // 模拟 Kernel 计算时间
        // 假设 Kernel 只是把输入拷贝到输出，或者做一些简单的元素级操作
        std::cout << "[AscDevKit] Kernel 执行完毕。" << std::endl;
        return OK;
    }

} // namespace AscDevKit

int main() {
    std::cout << "--- asc-devkit 概念性 C++ API 交互演示 ---" << std::endl;

    int target_device_id = 0; // 目标 AI 处理器设备 ID
    AscDevKit::Status status;

    // 使用智能指针管理资源，确保在任何退出路径都能正确释放
    std::unique_ptr<AscDevKit::Context> context_ptr;
    std::unique_ptr<AscDevKit::Stream> stream_ptr;
    void* device_input_ptr = nullptr;  // 设备内存指针，需要手动释放
    void* device_output_ptr = nullptr; // 设备内存指针，需要手动释放

    try {
        // 1. 初始化 AI 处理器设备
        status = AscDevKit::InitDevice(target_device_id);
        if (status != AscDevKit::OK) throw std::runtime_error("设备初始化失败");

        // 2. 创建一个设备上下文，管理设备资源
        status = AscDevKit::CreateContext(target_device_id, context_ptr);
        if (status != AscDevKit::OK || !context_ptr) throw std::runtime_error("创建上下文失败");

        // 3. 在上下文中创建一个流，用于提交异步任务
        status = AscDevKit::CreateStream(*context_ptr, stream_ptr);
        if (status != AscDevKit::OK || !stream_ptr) throw std::runtime_error("创建流失败");

        // 4. 准备主机端数据
        size_t data_element_count = 1024 * 1024; // 1M 个 float32 元素
        size_t data_size_bytes = data_element_count * sizeof(float);
        std::vector<float> host_input_data(data_element_count);
        // 填充一些概念性数据
        for (size_t i = 0; i < data_element_count; ++i) {
            host_input_data[i] = static_cast<float>(i);
        }
        std::vector<float> host_output_data(data_element_count, 0.0f); // 用于接收结果

        // 5. 在 AI 处理器设备上分配内存
        status = AscDevKit::MallocDeviceMemory(&device_input_ptr, data_size_bytes);
        if (status != AscDevKit::OK) throw std::runtime_error("设备输入内存分配失败");

        status = AscDevKit::MallocDeviceMemory(&device_output_ptr, data_size_bytes);
        if (status != AscDevKit::OK) throw std::runtime_error("设备输出内存分配失败");

        // 6. 异步将主机数据拷贝到设备内存 (任务提交到流)
        status = AscDevKit::MemcpyHostToDeviceAsync(
            device_input_ptr, host_input_data.data(), data_size_bytes, *stream_ptr);
        if (status != AscDevKit::OK) throw std::runtime_error("Host到Device拷贝失败");

        // 7. 在流上启动一个自定义 Kernel 计算任务 (异步执行)
        status = AscDevKit::LaunchCustomKernel(
            *stream_ptr, device_input_ptr, device_output_ptr, data_element_count);
        if (status != AscDevKit::OK) throw std::runtime_error("启动自定义 Kernel 失败");

        // 8. 异步将设备计算结果拷贝回主机内存 (任务提交到流)
        status = AscDevKit::MemcpyDeviceToHostAsync(
            host_output_data.data(), device_output_ptr, data_size_bytes, *stream_ptr);
        if (status != AscDevKit::OK) throw std::runtime_error("Device到Host拷贝失败");

        // 9. 同步流，确保流上所有任务（拷贝和计算）都已完成
        status = AscDevKit::StreamSynchronize(*stream_ptr);
        if (status != AscDevKit::OK) throw std::runtime_error("流同步失败");

        std::cout << "\n所有操作概念性完成。主机输出数据示例 (前5个):" << std::endl;
        for (int i = 0; i < 5; ++i) {
            std::cout << host_output_data[i] << " ";
        }
        std::cout << std::endl;

    } catch (const std::runtime_error& e) {
        std::cerr << "程序遇到错误: " << e.what() << std::endl;
    }

    // 10. 清理资源 (手动释放设备内存，智能指针会在作用域结束时自动销毁对象)
    std::cout << "\n--- 清理 AscDevKit 资源 ---" << std::endl;
    AscDevKit::FreeDeviceMemory(device_input_ptr);
    AscDevKit::FreeDeviceMemory(device_output_ptr);
    AscDevKit::DestroyStream(stream_ptr);     // 智能指针自动管理，这里只是概念性展示
    AscDevKit::DestroyContext(context_ptr);   // 智能指针自动管理，这里只是概念性展示
    // AscDevKit::UninitDevice(target_device_id); // 概念性反初始化设备函数

    std::cout << "--- 概念性 asc-devkit API 演示结束 ---" << std::endl;

    return 0;
}