Skip to content

asc_copy_gm2l1_nd2nz(NPU架构版本3510)

产品支持情况​

  • Ascend 950PR&950DT系列产品:支持
  • Atlas A3系列产品:不支持
  • Atlas A2系列产品:不支持
  • Atlas 200I/500 A2推理产品:不支持
  • Atlas推理系列产品AI Core:不支持
  • Atlas推理系列产品Vector Core:不支持
  • Atlas训练系列产品:不支持

功能说明​

头文件路径为:"c_api/cube_datamove/cube_datamove.h"。

将数据从Global Memory搬运到L1 Buffer,并在搬运过程中将源端按N维连续排布的ND格式数据转换为L1 Buffer侧的Nz分形排布,使其满足后续矩阵计算对分形列连续性的要求。该接口也适用于卷积格式NHWC(ND)转换为NC1HWC0格式等转换场景。

进行ND2Nz格式搬运前,需先通过asc_set_gm2l1_nz_para接口配置ND2Nz搬运的目的Nz矩阵的stride与ND矩阵搬运个数。

本接口仅在AIC上执行有效。

如图1所示,ND到Nz的格式转换也等价于DN到Zn的格式转换,如果要进行DN到Zn的格式转换可采用此指令。

图1 ND2Nz与DN2Zn示意图

搬入前的数据排布参见关键分形格式详解;地址对齐与搬运粒度要求参见矩阵计算输入搬运约束,并结合本接口的参数和约束说明使用。

函数原型​

C++
__aicore__ inline void asc_copy_gm2l1_nd2nz(__cbuf__ <dtype>* dst,
                                            __gm__ <dtype>* src,
                                            uint64_t src_d_value,
                                            asc_load_l2_cache_mode l2_cache_mode,
                                            uint16_t n_value,
                                            uint32_t d_value,
                                            uint64_t src_nd_matrix_stride,
                                            bool enable_small_c0)

dtype支持数据类型​

dtype取值为:int8_t、uint8_t、hifloat8_t、fp8_e5m2_t、fp8_e4m3fn_t、int16_t、uint16_t、half、bfloat16_t、int32_t、uint32_t、float。

函数原型典型示例​

C++
// 示例:half类型的ND到Nz格式搬运。
__aicore__ inline void asc_copy_gm2l1_nd2nz(__cbuf__ half* dst,
                                            __gm__ half* src,
                                            uint64_t src_d_value,
                                            asc_load_l2_cache_mode l2_cache_mode,
                                            uint16_t n_value,
                                            uint32_t d_value,
                                            uint64_t src_nd_matrix_stride,
                                            bool enable_small_c0)

参数说明​

表1 参数说明

参数名输入/输出含义
dst输出目的操作数,存储位置为L1 Buffer。起始地址需要按照32字节对齐。
src输入源操作数,存储位置为GM。起始地址需要按照1字节对齐。
src_d_value输入源矩阵相邻行起始地址之间的偏移,单位为字节。取值范围:[0, ]。
l2_cache_mode输入使用asc_load_l2_cache_mode枚举值配置输入GM数据在L2 Cache中的管理策略。仅支持asc_load_l2_cache_mode::NORMAL_FIRST_VICTIM、asc_load_l2_cache_mode::NORMAL_LAST_VICTIM、asc_load_l2_cache_mode::NORMAL_PERSISTENT和asc_load_l2_cache_mode::NOTALLOC_KEEP。
n_value输入源矩阵中ND矩阵的行数,单位为元素,取值范围:[1, 65535]。
d_value输入源矩阵中ND矩阵的列数,单位为元素,取值范围:[1, ]。搬运过程中,当不满足32字节对齐时,硬件在目的矩阵中自动补0至32字节对齐。
src_nd_matrix_stride输入源矩阵相邻ND矩阵起始地址间的偏移,单位为字节。取值范围:[0, ]。
  • 源矩阵ND矩阵个数为1时,此参数无意义,设置为0即可。
  • 源矩阵ND矩阵个数大于1时,当src_nd_matrix_stride = 0时,表示重复搬出源矩阵的第一个ND矩阵。
enable_small_c0输入SmallC0模式开关,仅当时可开启,否则导致搬运异常。
  • false:不开启SmallC0模式,按标准Nz格式的C0(32字节)排布搬运;
  • true:开启SmallC0模式,搬运过程中搬运的数据量不满足字节对齐时,硬件在目的矩阵中自动补0至字节对齐。

ND到Nz的格式转换如图2所示。

图2 ND2Nz转换示意图

ND2Nz格式转换后的数据排布

返回值说明​

无

流水类型​

PIPE_MTE2

约束说明​

通用约束​

  • 本接口非AIC调用直接返回。
  • dst起始地址需要按照32字节对齐(L1 Buffer对齐要求),否则会导致搬运异常。
  • src起始地址需要按照1字节对齐(GM对齐要求),否则会导致搬运异常。
  • 如果本指令与其他指令存在数据依赖,需要插入同步指令,保证多个指令串行化,防止出现异常数据。
  • L1 Buffer容量上限:L1 Buffer总容量512KB,dst偏移量与搬运大小之和不可越界,否则触发异常。

ND2Nz搬运约束​

  • 调用本指令前,需要先调用asc_set_gm2l1_nz_para接口配置ND2Nz搬运的目的Nz矩阵步长与ND矩阵搬运个数。
  • src_d_value取值范围为[0, ],超出取值范围的值会被截断,导致搬运结果不符合预期。
  • n_value取值范围为[1, 65535],超出取值范围的值会被截断,导致搬运结果不符合预期。
  • d_value取值范围为[1, ],超出取值范围的值会被截断,导致搬运结果不符合预期。
  • src_nd_matrix_stride取值范围为[0, ],超出取值范围的值会被截断,导致搬运结果不符合预期。
  • enable_small_c0设置为true时,,否则导致搬运异常。

调用示例​

将代码保存为examples.asc后,可通过bisheng命令编译运行,其中--npu-arch参数需根据实际产品型号指定对应的NPU架构,具体产品与NPU架构的映射关系请参考__NPU_ARCH__。

以Ascend 950PR&950DT系列产品(对应NPU架构为dav-3510)为例,编译运行命令如下:

Bash
bisheng examples.asc -o main --npu-arch=dav-3510 && ./main

样例单核占用32KB L1 Buffer、16KB L0A Buffer、16KB L0B Buffer和64KB L0C Buffer。样例依次复用EVENT_ID0完成MTE2到MTE1、MTE1到M、M到FIX的同步。

C++
#include <cstdint>
#include <iostream>
#include <vector>
#include "c_api/asc_simd.h"
#include "acl/acl.h"

namespace {
constexpr uint32_t M = 128;
constexpr uint32_t K = 128;
constexpr uint32_t N = 128;
constexpr uint32_t ELEMENTS = M * N;
constexpr uint32_t CUBE_M = 16;
constexpr uint32_t CUBE_K = 32;

__global__ __cube__ void AscCopyGm2l1Nd2nzKernel(__gm__ int8_t* a, __gm__ int8_t* b,
    __gm__ int32_t* output)
{
    asc_init();
    __cbuf__ int8_t a_l1[M * K], b_l1[N * K];
    __ca__ int8_t a_l0[M * K];
    __cb__ int8_t b_l0[K * N];
    __cc__ int32_t c_l0[ELEMENTS];

    // 将两个128 x 128的ND矩阵从GM搬入L1并转换为Nz格式。
    asc_set_gm2l1_nz_para(1, 1, 128, 0);
    asc_copy_gm2l1_nd2nz(a_l1, a, K * sizeof(int8_t), asc_load_l2_cache_mode::NORMAL_FIRST_VICTIM,
        M, K, 0, false);
    asc_set_gm2l1_nz_para(1, 1, 128, 0);
    asc_copy_gm2l1_nd2nz(b_l1, b, K * sizeof(int8_t), asc_load_l2_cache_mode::NORMAL_FIRST_VICTIM,
        N, K, 0, false);
    asc_sync_notify(PIPE_MTE2, PIPE_MTE1, EVENT_ID0);
    asc_sync_wait(PIPE_MTE2, PIPE_MTE1, EVENT_ID0);

    // 将Nz矩阵分别搬入L0A和L0B,供矩阵乘计算使用。
    asc_copy_l12l0a(a_l0, a_l1, 0, 0, M / CUBE_M, K / CUBE_K,
        M / CUBE_M, M / CUBE_M);
    asc_copy_l12l0b(b_l0, b_l1, 0, 0, N / CUBE_M, K / CUBE_K,
        N / CUBE_M, N / CUBE_M);
    asc_sync_notify(PIPE_MTE1, PIPE_M, EVENT_ID0);
    asc_sync_wait(PIPE_MTE1, PIPE_M, EVENT_ID0);

    // 计算128 x 128矩阵乘,并将结果从L0C搬回GM。
    asc_mmad(c_l0, a_l0, b_l0, M, K, N, asc_unit_flag_mode::DISABLE, true, false, true);
    asc_sync_notify(PIPE_M, PIPE_FIX, EVENT_ID0);
    asc_sync_wait(PIPE_M, PIPE_FIX, EVENT_ID0);

    asc_set_l0c_copy_nz_para(1, 0, 0);
    asc_copy_l0c2gm(output, c_l0, N, M, N, M, asc_store_l2_cache_mode::NORMAL_FIRST_VICTIM,
        asc_unit_flag_mode::DISABLE, QuantMode_t::NoQuant, asc_relu_pre_mode::NONE, false, true, false, false);
    asc_sync_pipe(PIPE_FIX);
}

template <typename T>
void PrintRow(const char* label, const std::vector<T>& data)
{
    std::cout << label << ':';
    for (uint32_t i = 0; i < 8; ++i) {
        std::cout << ' ' << +data[i];
    }
    std::cout << " ..." << std::endl;
}
} // namespace

int main()
{
    // 构造输入和CPU侧参考结果。
    std::vector<int8_t> a(M * K), b(N * K);
    std::vector<int32_t> output(ELEMENTS), golden(ELEMENTS);
    for (uint32_t row = 0; row < M; ++row) {
        for (uint32_t k = 0; k < K; ++k) {
            a[row * K + k] = static_cast<int8_t>(static_cast<int32_t>((row + 2 * k) % 5) - 2);
        }
    }
    for (uint32_t col = 0; col < N; ++col) {
        for (uint32_t k = 0; k < K; ++k) {
            b[col * K + k] = static_cast<int8_t>(static_cast<int32_t>((3 * col + k) % 5) - 2);
        }
    }
    for (uint32_t row = 0; row < M; ++row) {
        for (uint32_t col = 0; col < N; ++col) {
            for (uint32_t k = 0; k < K; ++k) {
                golden[row * N + col] += a[row * K + k] * b[col * K + k];
            }
        }
    }

    // 分配Device内存、启动核函数(Kernel)并校验结果。
    aclInit(nullptr);
    aclrtSetDevice(0);
    int8_t *a_device = nullptr, *b_device = nullptr;
    int32_t* output_device = nullptr;
    aclrtMalloc(reinterpret_cast<void**>(&a_device), a.size(), ACL_MEM_MALLOC_HUGE_FIRST);
    aclrtMalloc(reinterpret_cast<void**>(&b_device), b.size(), ACL_MEM_MALLOC_HUGE_FIRST);
    aclrtMalloc(reinterpret_cast<void**>(&output_device), output.size() * sizeof(int32_t),
        ACL_MEM_MALLOC_HUGE_FIRST);
    aclrtMemcpy(a_device, a.size(), a.data(), a.size(), ACL_MEMCPY_HOST_TO_DEVICE);
    aclrtMemcpy(b_device, b.size(), b.data(), b.size(), ACL_MEMCPY_HOST_TO_DEVICE);
    AscCopyGm2l1Nd2nzKernel<<<1, 0>>>(a_device, b_device, output_device);
    aclrtSynchronizeDevice();
    aclrtMemcpy(output.data(), output.size() * sizeof(int32_t), output_device,
        output.size() * sizeof(int32_t), ACL_MEMCPY_DEVICE_TO_HOST);

    PrintRow("Input A row 0", a);
    PrintRow("Input B row 0", b);
    PrintRow("Output row 0", output);
    PrintRow("Golden row 0", golden);
    const bool passed = output == golden;
    std::cout << (passed ? "[Success] asc_copy_gm2l1_nd2nz preserved the MMAD operands/result."
                         : "[Failed] asc_copy_gm2l1_nd2nz result mismatch.") << std::endl;

    aclrtFree(a_device);
    aclrtFree(b_device);
    aclrtFree(output_device);
    aclrtResetDevice(0);
    aclFinalize();
    return passed ? 0 : 1;
}

免责声明:本站内容由 asc-devkit 仓 master 分支自动编译生成,属于持续开发版本,可能存在缺陷,仅供预览与参考。如需稳定及商用资料,请查阅官方 昇腾社区。