【2024第一期CANN训练营】3、AscendCL运行时管理

news/2024/11/15 3:52:08/

文章目录

  • 【2024第一期CANN训练营】3、AscendCL运行时管理
    • 1. 初始化与去初始化
    • 2. 资源申请与释放
      • 2.1 申请流程
      • 2.2 释放流程
      • 2.3 运行模式（可选）
    • 3. 数据传输
      • 3.1 接口调用流程
      • 3.2 主要数据传输场景
        • 1. Host内的数据传输
        • 2. 从Host到Device的数据传输
        • 3. 从Device到Host的数据传输
        • 4. 一个Device内的数据传输
        • 5. 两个Device间的数据传输
    • 4. Stream管理
      • 4.1 单线程单Stream
      • 4.2 单线程多Stream
      • 4.3 多线程多Stream
    • 5. 多Device切换
      • 5.1 多Device切换关键接口
      • 5.2 多Device切换流程
    • 6. 同步等待
      • 6.1 Event的同步等待
      • 6.2 Stream内任务的同步等待
      • 6.3 Stream间任务的同步等待
      • 6.4 Device的同步等待

【2024第一期CANN训练营】3、AscendCL运行时管理

本教程将介绍如何使用昇腾社区AscendCL应用开发接口进行运行时管理。并从AscendCL的初始化与去初始化、运行管理资源的申请与释放、数据传输、Stream管理、多Device切换以及同步等待等关键步骤来展开内容

以下教程涉及的所有代码都可以从样例介绍中获得

1. 初始化与去初始化

在使用AscendCL进行开发前，首先需要初始化AscendCL环境。这可以通过调用aclInit接口来完成。如果默认配置已满足需求，可以直接传入NULL。

aclError ret = aclInit(NULL);

完成所有AscendCL调用后，需要调用aclFinalize接口去初始化AscendCL。

ret = aclFinalize();

2. 资源申请与释放

运行管理资源包括Device、Context和Stream。申请和释放这些资源的顺序很重要。

2.1 申请流程

  1. 使用aclrtSetDevice显式指定运算的Device。
  2. 通过aclrtCreateContext创建Context。
  3. 使用aclrtCreateStream创建Stream。

示例代码：

// 初始化变量
int32_t deviceId=0 ;
aclrtContext context;
aclrtStream stream;aclError ret = aclrtSetDevice(deviceId);
ret = aclrtCreateContext(&context, deviceId);
ret = aclrtCreateStream(&stream);

2.2 释放流程

  1. 使用aclrtDestroyStream销毁Stream。
  2. 通过aclrtDestroyContext销毁Context。
  3. 调用aclrtResetDevice重置Device。

示例代码：

ret = aclrtDestroyStream(stream);
ret = aclrtDestroyContext(context);
ret = aclrtResetDevice(deviceId);

2.3 运行模式（可选）

获取当前昇腾AI软件栈的运行模式，根据不同的运行模式，后续的接口调用方式不同

  • 如果查询结果为ACL_HOST，则数据传输时涉及申请Host上的内存。
  • 如果查询结果为ACL_DEVICE，则数据传输时仅需申请Device上的内存。
aclrtRunMode runMode;
extern bool g_isDevice;ret = aclrtGetRunMode(&runMode);
g_isDevice = (runMode == ACL_DEVICE);

3. 数据传输

数据传输包含申请内存，将数据读入内存，内存复制三个环节

3.1 接口调用流程

  1. 申请内存：
    • 在Host上申请内存可以使用C++标准库中的new或malloc，或者使用AscendCL提供的aclrtMallocHost接口。
    • 在Device上申请内存则需要使用aclrtMalloc接口。
  2. 将数据读入内存：用户需要自行管理数据读入内存的实现逻辑。
  3. 内存复制：通过内存复制实现数据传输，可以选择同步或异步内存复制。
    • 同步内存复制使用aclrtMemcpy接口
    • 异步内存复制使用aclrtMemcpyAsync接口，并配合aclrtSynchronizeStream接口实现同步等待。

3.2 主要数据传输场景

1. Host内的数据传输

当前仅支持调用aclrtMemcpy接口执行同步Host内的内存复制任务，不支持调用aclrtMemcpyAsync接口执行异步Host内的内存复制功能

// 申请内存
uint64_t size = 1 * 1024 * 1024;
void* hostPtrA = NULL;
void* hostPtrB = NULL;
aclrtMallocHost(&hostPtrA, size);
aclrtMallocHost(&hostPtrB, size);// 向内存中读入数据
ReadFile(fileName, hostPtrA, size);// 同步内存复制
aclrtMemcpy(hostPtrB, size, hostPtrA, size, ACL_MEMCPY_HOST_TO_HOST);// 释放资源
aclrtFreeHost(hostPtrA);
aclrtFreeHost(hostPtrB);
2. 从Host到Device的数据传输

既支持同步内存复制，又支持异步内存复制

  • 同步内存复制
// 申请内存
uint64_t size = 1 * 1024 * 1024;
void* hostPtrA = NULL;
void* devPtrB = NULL;
aclrtMallocHost(&hostPtrA, size);
aclrtMalloc(&devPtrB, size, ACL_MEM_MALLOC_NORMAL_ONLY);// 向内存中读入数据
ReadFile(fileName, hostPtrA, size);// 同步内存复制
aclrtMemcpy(devPtrB, size, hostPtrA, size, ACL_MEMCPY_HOST_TO_DEVICE);// 释放资源
aclrtFreeHost(hostPtrA);
aclrtFree(devPtrB);
  • 异步内存复制
// 申请内存
uint64_t size = 1 * 1024 * 1024;
void* hostAddr = NULL;
void* devAddr = NULL;
aclrtMallocHost(&hostAddr, size + 64);
aclrtMalloc(&devAddr, size, ACL_MEM_MALLOC_NORMAL_ONLY);
aclrtStream stream = NULL;
aclrtCreateStream(&stream);// 获取到64字节对齐的地址
char *hostAlignAddr =(char *)hostAddr + 64 - ((uintptr_t)hostAddr % 64);// 向内存中读入数据
ReadFile(fileName, hostAlignAddr, size);// 异步内存复制
aclrtMemcpyAsync(devAddr, size, hostAlignAddr, size, ACL_MEMCPY_HOST_TO_DEVICE, stream);
aclrtSynchronizeStream(stream);// 释放资源
aclrtDestroyStream(stream);
aclrtFreeHost(hostAddr);
aclrtFree(devAddr);
3. 从Device到Host的数据传输

既支持同步内存复制，又支持异步内存复制

  • 同步内存复制
// 申请内存
uint64_t size = 1 * 1024 * 1024;
void* devPtrA = NULL;
void* hostPtrB = NULL;
aclrtMalloc(&devPtrA, size, ACL_MEM_MALLOC_NORMAL_ONLY);
aclrtMallocHost(&hostPtrB, size);// 向内存中读入数据
ReadFile(fileName, devPtrA, size);// 同步内存复制
aclrtMemcpy(hostPtrB, size, devPtrA, size, ACL_MEMCPY_DEVICE_TO_HOST);// 释放资源
aclrtFree(devPtrA);
aclrtFreeHost(hostPtrB);
  • 异步内存复制
// 申请内存
uint64_t size = 1 * 1024 * 1024;
void* hostAddr = NULL;
void* devAddr = NULL;
aclrtMallocHost(&hostAddr, size + 64);
aclrtMalloc(&devAddr, size, ACL_MEM_MALLOC_NORMAL_ONLY);
aclrtStream stream = NULL;
aclrtCreateStream(&stream);// 向内存中读入数据
ReadFile(fileName, devAddr, size);// 获取到64字节对齐的地址
char *hostAlignAddr =(char *)hostAddr + 64 - ((uintptr_t)hostAddr % 64);// 异步内存复制
aclrtMemcpyAsync(hostAlignAddr, size, devAddr, size, ACL_MEMCPY_DEVICE_TO_HOST, stream);
aclrtSynchronizeStream(stream);// 释放资源
aclrtDestroyStream(stream);
aclrtFreeHost(hostAddr);
aclrtFree(devAddr);
4. 一个Device内的数据传输
// 申请内存
uint64_t size = 1 * 1024 * 1024;
void* devPtrA = NULL;
void* devPtrB = NULL;
aclrtMalloc(&devPtrA, size, ACL_MEM_MALLOC_NORMAL_ONLY);
aclrtMalloc(&devPtrB, size, ACL_MEM_MALLOC_NORMAL_ONLY);// 向内存中读入数据
ReadFile(fileName, devPtrA, size);// 同步内存复制
aclrtMemcpy(devPtrB, size, devPtrA, size, ACL_MEMCPY_DEVICE_TO_DEVICE);// 异步内存复制
aclrtStream stream;
aclrtCreateStream(&stream);
aclrtMemcpyAsync(devPtrB, size, devPtrA, size, ACL_MEMCPY_DEVICE_TO_DEVICE, stream);
aclrtSynchronizeStream(stream);// 释放资源
aclrtFree(devPtrA);
aclrtFree(devPtrB);
5. 两个Device间的数据传输
  • Atlas 200/300/500 推理产品上，不支持该功能。
  • Atlas 200/500 A2推理产品，不支持该功能。
// AscendCL初始化
auto ret = aclInit(NULL);// 查询Device 0和Device 1之间是否支持内存复制
int32_t canAccessPeer = 0;
ret = aclrtDeviceCanAccessPeer(&canAccessPeer, 0, 1);// 1表示支持内存复制
if (canAccessPeer == 1) {// Device 0下的操作，包括内存申请、数据写入、内存复制等ret = aclrtSetDevice(0);		void *dev0;ret = aclrtMalloc(&dev0, 10, ACL_MEM_MALLOC_HUGE_FIRST_P2P);ret = aclrtMemset(dev0, 10, 1, 10);// Device 1下的操作ret = aclrtSetDevice(1);ret = aclrtDeviceEnablePeerAccess(0, 0);void *dev1;ret = aclrtMalloc(&dev1, 10, ACL_MEM_MALLOC_HUGE_FIRST_P2P);ret = aclrtMemset(dev1, 10, 0, 10);// 执行复制，将Device 0上的内存数据复制到Device 1上ret = aclrtMemcpy(dev1, 10, dev0, 10, ACL_MEMCPY_DEVICE_TO_DEVICE);ret = aclrtResetDevice(1);ret = aclrtSetDevice(0);ret = aclrtResetDevice(0);printf("P2P copy success\n");
} else {printf("current device doesn't support p2p feature\n");
}// AscendCL去初始化
aclFinalize();

注意事项

  • 在进行数据传输时，需要确保内存申请和释放的正确性，避免内存泄漏。
  • 异步内存复制时，需要确保内存地址的64字节对齐。
  • 在使用AscendCL进行数据传输时，应该增加异常处理逻辑，以便于及时发现并解决问题。

4. Stream管理

在AscendCL应用开发中，Stream是任务队列的抽象，用于管理任务的并行执行。理解并有效管理Stream对于提升程序性能和资源利用率至关重要。AscendCL提供了以下几种Stream管理机制：

4.1 单线程单Stream

在单线程环境下，可以创建一个Stream来管理任务的执行。

#include "acl/acl.h"// 显式创建一个Stream
aclrtStream stream;
aclrtCreateStream(&stream);// 调用触发任务的接口，传入stream参数
aclrtMemcpyAsync(dstPtr, dstSize, srcPtr, srcSize, ACL_MEMCPY_HOST_TO_DEVICE, stream);// 调用aclrtSynchronizeStream接口，阻塞应用程序运行，直到指定Stream中的所有任务都完成。
aclrtSynchronizeStream(stream);// Stream使用结束后，显式销毁Stream
aclrtDestroyStream(stream);

4.2 单线程多Stream

在单线程环境下，可以创建多个Stream来并行执行不同的任务。

#include "acl/acl.h"
int32_t deviceId = 0;
uint32_t modelId1 = 0;
uint32_t modelId2 = 1;// 显式创建一个Stream
aclrtContext context;
aclrtStream stream1, stream2;// 创建Context
aclrtCreateContext(&context, deviceId);// 创建stream1
aclrtCreateStream(&stream1);
// 调用触发任务的接口，例如异步模型推理，任务下发在stream1
aclmdlDataset *input1, *output1;
aclmdlExecuteAsync(modelId1, input1, output1, stream1);// 创建stream2
aclrtCreateStream(&stream2);
// 调用触发任务的接口，例如异步模型推理，任务下发在stream2
aclmdlDataset *input2, *output2;
aclmdlExecuteAsync(modelId2, input2, output2, stream2);// 流同步
aclrtSynchronizeStream(stream1);
aclrtSynchronizeStream(stream2);// 释放资源
aclrtDestroyStream(stream1);
aclrtDestroyStream(stream2);
aclrtDestroyContext(context);

4.3 多线程多Stream

在多线程环境下，每个线程可以创建自己的Stream来执行任务。

#include "acl/acl.h"void runThread(aclrtStream stream) {int32_t deviceId = 0;aclrtContext context;// 创建ContextaclrtCreateContext(&context, deviceId);// 显式创建一个StreamaclrtStream threadStream;aclrtCreateStream(&threadStream);// 释放资源aclrtDestroyStream(threadStream);aclrtDestroyContext(context);
}// 创建2个线程，每个线程对应一个Stream
aclrtStream stream1, stream2;
std::thread t1(runThread, stream1);
std::thread t2(runThread, stream2);// 显式调用join函数确保结束线程
t1.join();
t2.join();

注意事项

  • 在创建Stream之前，确保已经创建了Context。
  • 在多Stream场景下，注意使用aclrtSynchronizeStream接口来同步任务的执行。
  • 在多线程环境下，确保每个线程正确地创建和销毁自己的Stream和Context。
  • 在程序结束前，确保释放所有Stream和Context资源，避免内存泄漏。

5. 多Device切换

在AscendCL应用开发中，多Device切换是一个重要的特性，它允许开发者在多个昇腾AI处理器（Device）之间高效地切换和管理任务。

下图为：同步等待流程_多Device场景

img

5.1 多Device切换关键接口

  1. aclrtSetCurrentContext：用于切换当前线程的Context，比使用aclrtSetDevice接口效率更高。

  2. aclrtSynchronizeDevice：用于等待特定Device上的所有计算任务结束。

5.2 多Device切换流程

  1. 初始化AscendCL：在使用AscendCL进行任何操作之前，需要先初始化AscendCL。

    aclError ret = aclInit(NULL);
if (ret != ACL_ERROR_NONE) {// 错误处理
}

  2. 创建Context：在多Device环境中，每个Device都有一个Context。需要为每个Device创建一个Context。

    aclrtContext context[DEVICE_NUM];
for (int i = 0; i < DEVICE_NUM; ++i) {ret = aclrtCreateContext(&context[i], i);if (ret != ACL_ERROR_NONE) {// 错误处理}
}

  3. 切换Context和Device：在执行任务时，使用aclrtSetCurrentContext接口切换到相应的Context，从而在对应的Device上执行任务。

    // 假设我们要在Device 1上执行任务
aclrtSetCurrentContext(context[1]);
// 执行任务...

  4. 等待Device任务完成：在需要等待特定Device上的任务完成时，使用aclrtSynchronizeDevice接口。

    // 等待Device 2上的任务完成
aclrtSynchronizeDevice(2);

  5. 执行任务：在每个Device上执行相应的任务，如模型推理或算子执行。

    // 模型推理示例
aclmdlExecuteAsync(modelId, input, output, stream);

  6. 释放资源：在任务完成后，释放Context和销毁所有资源。

    for (int i = 0; i < DEVICE_NUM; ++i) {aclrtDestroyContext(context[i]);
}
aclFinalize();

注意事项

  • 在多Device环境中，确保为每个Device创建了对应的Context。
  • 使用aclrtSetCurrentContext接口切换Context时，确保当前线程没有其他Device的任务在执行。
  • 在等待Device任务完成时，确保没有其他任务依赖于这些任务的结果，否则可能会导致死锁。
  • 在程序结束前，确保释放所有Context资源，并调用aclFinalize进行AscendCL的清理。

6. 同步等待

在AscendCL应用开发中，同步等待是一个关键的概念，它确保了在异步计算场景下任务的正确执行顺序和资源的正确管理。

AscendCL提供了以下同步机制：

  1. Event的同步等待：使用aclrtSynchronizeEvent接口，阻塞应用程序运行，等待Event完成。
  2. Stream内任务的同步等待：使用aclrtSynchronizeStream接口，阻塞应用程序运行，直到指定Stream中的所有任务都完成。
  3. Stream间任务的同步等待：使用aclrtStreamWaitEvent接口，阻塞指定Stream的运行，直到指定的Event完成。
  4. Device的同步等待：使用aclrtSynchronizeDevice接口，阻塞应用程序运行，直到正在运算中的Device完成运算。

6.1 Event的同步等待

#include "acl/acl.h"// 创建一个Event
aclrtEvent event;
aclrtCreateEvent(&event);// 显式创建一个Stream
aclrtStream stream;
aclrtCreateStream(&stream);// 在stream末尾添加了一个event
aclrtRecordEvent(event, stream);// 阻塞应用程序运行，等待event发生，也就是stream执行完成
aclrtSynchronizeEvent(event);// 显式销毁资源
aclrtDestroyStream(stream);
aclrtDestroyEvent(event);

6.2 Stream内任务的同步等待

#include "acl/acl.h"// 显式创建一个Stream
aclrtStream stream;
aclrtCreateStream(&stream);// 调用触发任务的接口，传入stream参数
aclrtMemcpyAsync(dstPtr, dstSize, srcPtr, srcSize, ACL_MEMCPY_HOST_TO_DEVICE, stream);// 调用aclrtSynchronizeStream接口，阻塞应用程序运行，直到指定Stream中的所有任务都完成
aclrtSynchronizeStream(stream);// Stream使用结束后，显式销毁Stream
aclrtDestroyStream(stream);

6.3 Stream间任务的同步等待

#include "acl/acl.h"// 创建一个Event
aclrtEvent event;
aclrtCreateEvent(&event);// 创建stream1
aclrtStream s1;
aclrtCreateStream(&s1);// 创建stream2
aclrtStream s2;
aclrtCreateStream(&s2);// 在s1末尾添加了一个event
aclrtRecordEvent(event, s1);// 阻塞s2运行，直到指定event发生，也就是s1执行完成
aclrtStreamWaitEvent(s2, event);// 显式销毁资源
aclrtDestroyStream(s2);
aclrtDestroyStream(s1);
aclrtDestroyEvent(event);

6.4 Device的同步等待

#include "acl/acl.h"// 指定device
aclrtSetDevice(0);// 创建context
aclrtContext ctx;
aclrtCreateContext(&ctx, 0);// 创建stream
aclrtStream stream;
aclrtCreateStream(&stream);// 阻塞应用程序运行，直到正在运算中的Device完成运算
aclrtSynchronizeDevice();// 资源销毁
aclrtDestroyStream(stream);
aclrtDestroyContext(ctx);
aclrtResetDevice(0);

注意事项

  • 在使用同步等待机制时，确保正确地创建和销毁Event和Stream资源。
  • 在多Stream环境中，使用Event和aclrtStreamWaitEvent接口来实现Stream间的同步等待。
  • 在多Device环境中，使用aclrtSynchronizeDevice接口来等待特定Device上的任务完成。
  • 在程序结束前，确保释放所有资源，避免内存泄漏。。

http://www.ppmy.cn/news/1387183.html

相关文章

锦意绵长，丽彩婚典

锦意绵长，丽彩婚典

锦江丽笙酒店亮相婚博会 演绎沪上多彩浪漫情怀 &#xff08;中国上海&#xff0c;2024年3月18日&#xff09;3月16日至17日&#xff0c;2024年上海春季婚博会在上海世博展览馆举办。此次婚庆行业盛会上&#xff0c;锦江丽笙酒店旗下8家酒店联袂登场&#xff0c;凭借深厚的品牌…
阅读更多...
QT插件简单使用2

QT插件简单使用2

目录 1 总的目录结构 2 主程序 3 插件程序 4 运行结果 相比原来的QT插件简单使用-CSDN博客增加了 QObject *create(const QString &name, const QString &spec) override; 函数的使用和Plugin.json的使用 1 总的目录结构 编译器mingw-64 2 主程序 1 新建一个其他…
阅读更多...
【git】常用操作

【git】常用操作

基础操作 git init 初始化仓库 要使用 Git 进行版本管理&#xff0c;必须先初始化仓库&#xff0c; 执行了 git init命令的目录下就会生成 .git 目录。这个 .git 目录里存储着管理当前目录内容所需的仓库数据 git status 查看仓库状态 工作树和仓库在被操作的过程中&#xff0…
阅读更多...
Android制作微信添加多个图片，放大图片

Android制作微信添加多个图片，放大图片

1.添加依赖 implementation com.github.bumptech.glide:glide:4.12.0 //裁剪图片等等 implementation androidx.recyclerview:recyclerview:1.1.0 //recycleview依赖 2.使用recycleview <androidx.recyclerview.widget.RecyclerViewandroid:id"id/recyclerView"…
阅读更多...
【电路笔记】-MOSFET作为开关

【电路笔记】-MOSFET作为开关

MOSFET 作为开关 文章目录 MOSFET 作为开关1、概述2、MOSFET特性曲线2.1 截住区域2.2 饱和区域3、MOSFET作为开关的示例4、功率MOSFET电机控制5、P沟道MOSFET作为开关6、互补MOSFET作为开关电机控制器当 MOSFET 在截止区和饱和区之间工作时，MOSFET 是非常好的电子开关，用于控…
阅读更多...
LeetCode——贪心算法（Java）

LeetCode——贪心算法（Java）

贪心算法 简介[简单] 455. 分发饼干[中等] 376. 摆动序列[中等] 53. 最大子数组和[中等] 122. 买卖股票的最佳时机 II[中等] 55. 跳跃游戏 简介 记录一下自己刷题的历程以及代码。写题过程中参考了 代码随想录的刷题路线。会附上一些个人的思路&#xff0c;如果有错误&#xf…
阅读更多...
MQ组件之RabbitMQ学习

MQ组件之RabbitMQ学习

MQ组件之RabbitMQ入门 同步调用和异步调用 在微服务架构中&#xff0c;服务之间的调用有同步调用和异步调用两种方式。 我们使用OpenFeign去调用是同步调用&#xff0c;同步调用的缺点很明显&#xff0c;在下图的场景中&#xff0c;支付完成后需要调用订单服务、仓库服务、短…
阅读更多...
吴恩达深度学习环境本地化构建wsl+docker+tensorflow+cuda

吴恩达深度学习环境本地化构建wsl+docker+tensorflow+cuda

Tensorflow2 on wsl using cuda 动机环境选择安装步骤1. WSL安装2. docker安装2.1 配置Docker Desktop2.2 WSL上的docker使用2.3 Docker Destop的登陆2.4 测试一下 3. 在WSL上安装CUDA3.1 Software list needed3.2 [CUDA Support for WSL 2](https://docs.nvidia.com/cuda/wsl-…
阅读更多...
最新文章

Copyright @ 2022~2023