华为昇腾910使用初探

/*

export DDK_PATH=~/Ascend/ascend-toolkit/20.1.rc1/arm64-linux

$CXX -std=c++11 -I$DDK_PATH/fwkacllib/include -L$DDK_PATH/fwkacllib/lib64 \
-lascendcl -lacl_op_compiler -o MatMul MatMul.cc

./MatMul 8192 8192 8192

*/

#include <acl/acl.h>
#include <acl/acl_op_compiler.h>
#include <functional>
#include <string>
#include <sys/time.h>

#define ACLCHECK(cmd)                                                          \
  do {                                                                         \
    int e = cmd;                                                               \
    if (e != ACL_ERROR_NONE) {                                                 \
      fprintf(stderr, "%d", e);                                                \
      exit(1);                                                                 \
    }                                                                          \
  } while (0)

void WuK_Timer(const char *tag, float flo, const std::function<void()> &kernel,
               int test_time = 1) {
  double min_time = 9e99;
  while (test_time--) {
    struct timeval start, end;
    gettimeofday(&start, NULL);
    kernel();
    gettimeofday(&end, NULL);
    min_time = std::min(min_time, (end.tv_sec - start.tv_sec) * 1e3 +
                                      (end.tv_usec - start.tv_usec) * 1e-3);
  }
  fprintf(stdout, "%s: %f ms, %e FLOPS\n", tag, min_time, flo * 1e3 / min_time);
}

int main(int argc, char **argv) {

  int64_t m = std::stoi(argv[1]), n = std::stoi(argv[2]),
          k = std::stoi(argv[3]), dimA[] = {m, k}, dimB[] = {k, n},
          dimC[] = {m, n}, sAsize = (m * k * sizeof(float) + 63) / 32 * 32,
          sBsize = (k * n * sizeof(float) + 63) / 32 * 32,
          sCsize = (m * n * sizeof(float) + 63) / 32 * 32,
          sALPHAsize = (sizeof(float) + 63) / 32 * 32,
          sBETAsize = (sizeof(float) + 63) / 32 * 32,
          hAsize = (m * k * sizeof(aclFloat16) + 63) / 32 * 32,
          hBsize = (k * n * sizeof(aclFloat16) + 63) / 32 * 32,
          hCsize = (m * k * sizeof(aclFloat16) + 63) / 32 * 32,
          hALPHAsize = (sizeof(aclFloat16) + 63) / 32 * 32,
          hBETAsize = (sizeof(aclFloat16) + 63) / 32 * 32;

  aclTensorDesc
      *sAdesc = aclCreateTensorDesc(ACL_FLOAT, 2, dimA, ACL_FORMAT_ND),
      *sBdesc = aclCreateTensorDesc(ACL_FLOAT, 2, dimB, ACL_FORMAT_ND),
      *sCdesc = aclCreateTensorDesc(ACL_FLOAT, 2, dimC, ACL_FORMAT_ND),
      *sALPHAdesc = aclCreateTensorDesc(ACL_FLOAT, 0, dimC, ACL_FORMAT_ND),
      *sBETAdesc = aclCreateTensorDesc(ACL_FLOAT, 0, dimC, ACL_FORMAT_ND),
      *sDesc[] = {sAdesc, sBdesc, sCdesc, sALPHAdesc, sBETAdesc},
      *hAdesc = aclCreateTensorDesc(ACL_FLOAT16, 2, dimA, ACL_FORMAT_ND),
      *hBdesc = aclCreateTensorDesc(ACL_FLOAT16, 2, dimB, ACL_FORMAT_ND),
      *hCdesc = aclCreateTensorDesc(ACL_FLOAT16, 2, dimC, ACL_FORMAT_ND),
      *hALPHAdesc = aclCreateTensorDesc(ACL_FLOAT16, 0, dimC, ACL_FORMAT_ND),
      *hBETAdesc = aclCreateTensorDesc(ACL_FLOAT16, 0, dimC, ACL_FORMAT_ND),
      *hDesc[] = {hAdesc, hBdesc, hCdesc, hALPHAdesc, hBETAdesc};

  aclopAttr *attrMatMul = aclopCreateAttr(), *attrGEMM = aclopCreateAttr(),
            *attrCastFp16 = aclopCreateAttr(),
            *attrCastFp32 = aclopCreateAttr();

  ACLCHECK(aclopSetAttrBool(attrMatMul, "transpose_x1", 0));
  ACLCHECK(aclopSetAttrBool(attrMatMul, "transpose_x2", 0));
  ACLCHECK(aclopSetAttrBool(attrGEMM, "transpose_a", 0));
  ACLCHECK(aclopSetAttrBool(attrGEMM, "transpose_b", 0));
  ACLCHECK(aclopSetAttrInt(attrCastFp16, "dst_type", ACL_FLOAT16));
  ACLCHECK(aclopSetAttrInt(attrCastFp32, "dst_type", ACL_FLOAT));

  WuK_Timer("aclInit", 0, [&] { ACLCHECK(aclInit(NULL)); });

  aclrtContext HPLAI_ACL_BLASPP_CONTEXT;

  WuK_Timer("aclrtCreateContext", 0, [&] {
    uint32_t deviceId = 0, count = 0;
    aclrtGetDeviceCount(&count);
    ACLCHECK(aclrtCreateContext(&HPLAI_ACL_BLASPP_CONTEXT, deviceId % count));
  });

  WuK_Timer("aclrtSetCurrentContext", 0, [&] {
    ACLCHECK(aclrtSetCurrentContext(HPLAI_ACL_BLASPP_CONTEXT));
  });

  void *HPLAI_ACL_BLASPP_HOST_BUFFER, *HPLAI_ACL_BLASPP_DEVICE_BUFFER;
  int64_t HPLAI_ACL_BLASPP_HOST_BUFFER_SIZE =
              sAsize + sBsize + sCsize + sALPHAsize + sBETAsize,
          HPLAI_ACL_BLASPP_DEVICE_BUFFER_SIZE =
              HPLAI_ACL_BLASPP_HOST_BUFFER_SIZE + hAsize + hBsize + hCsize +
              hALPHAsize + hBETAsize;

  WuK_Timer("aclrtMalloc", 0, [&] {
    ACLCHECK(aclrtMalloc(&HPLAI_ACL_BLASPP_DEVICE_BUFFER,
                         HPLAI_ACL_BLASPP_DEVICE_BUFFER_SIZE,
                         ACL_MEM_MALLOC_HUGE_FIRST));
  });

  WuK_Timer("aclrtMallocHost", 0, [&] {
    ACLCHECK(aclrtMallocHost(&HPLAI_ACL_BLASPP_HOST_BUFFER,
                             HPLAI_ACL_BLASPP_HOST_BUFFER_SIZE));
  });

  char *sAdevice = (char *)HPLAI_ACL_BLASPP_DEVICE_BUFFER,
       *sBdevice = sAdevice + sAsize, *sCdevice = sBdevice + sBsize,
       *sALPHAdevice = sCdevice + sCsize,
       *sBETAdevice = sALPHAdevice + sALPHAsize,
       *hAdevice = sBETAdevice + sBETAsize, *hBdevice = hAdevice + hAsize,
       *hCdevice = hBdevice + hBsize, *hALPHAdevice = hCdevice + hCsize,
       *hBETAdevice = hALPHAdevice + hALPHAsize,
       *sAhost = (char *)HPLAI_ACL_BLASPP_HOST_BUFFER,
       *sBhost = sAhost + sAsize, *sChost = sBhost + sBsize,
       *sALPHAhost = sChost + sCsize, *sBETAhost = sALPHAhost + sALPHAsize;

  WuK_Timer("aclrtMemsetAsync", 0, [&] {
    ACLCHECK(aclrtMemsetAsync(HPLAI_ACL_BLASPP_HOST_BUFFER,
                              HPLAI_ACL_BLASPP_HOST_BUFFER_SIZE, 0,
                              HPLAI_ACL_BLASPP_HOST_BUFFER_SIZE, NULL));
    ACLCHECK(aclrtSynchronizeStream(NULL));
  });

  WuK_Timer("aclrtMemcpyAsyncHtoD", 0, [&] {
    ACLCHECK(aclrtMemcpyAsync(
        HPLAI_ACL_BLASPP_DEVICE_BUFFER, HPLAI_ACL_BLASPP_DEVICE_BUFFER_SIZE,
        HPLAI_ACL_BLASPP_HOST_BUFFER, HPLAI_ACL_BLASPP_HOST_BUFFER_SIZE,
        ACL_MEMCPY_HOST_TO_DEVICE, NULL));
    ACLCHECK(aclrtSynchronizeStream(NULL));
  });

  aclDataBuffer *sAdata = aclCreateDataBuffer(sAdevice, sAsize),
                *sBdata = aclCreateDataBuffer(sBdevice, sBsize),
                *sCdata = aclCreateDataBuffer(sCdevice, sCsize),
                *sALPHAdata = aclCreateDataBuffer(sALPHAdevice, sALPHAsize),
                *sBETAdata = aclCreateDataBuffer(sBETAdevice, sBETAsize),
                *sData[] = {sAdata, sBdata, sCdata, sALPHAdata, sBETAdata},
                *hAdata = aclCreateDataBuffer(hAdevice, hAsize),
                *hBdata = aclCreateDataBuffer(hBdevice, hBsize),
                *hCdata = aclCreateDataBuffer(hCdevice, hCsize),
                *hALPHAdata = aclCreateDataBuffer(hALPHAdevice, hALPHAsize),
                *hBETAdata = aclCreateDataBuffer(hBETAdevice, hBETAsize),
                *hData[] = {hAdata, hBdata, hCdata, hALPHAdata, hBETAdata};

  WuK_Timer(
      "Cast(aclFloat16)", 0,
      [&] {
        ACLCHECK(aclopCompileAndExecute("Cast", 1, sDesc, sData, 1, hDesc,
                                        hData, attrCastFp16, ACL_ENGINE_SYS,
                                        ACL_COMPILE_SYS, NULL, NULL));
        ACLCHECK(aclrtSynchronizeStream(NULL));
      },
      10);
  WuK_Timer(
      "Cast(float)", 0,
      [&] {
        ACLCHECK(aclopCompileAndExecute(
            "Cast", 1, hDesc + 2, hData + 2, 1, sDesc + 2, sData + 2,
            attrCastFp32, ACL_ENGINE_SYS, ACL_COMPILE_SYS, NULL, NULL));
        ACLCHECK(aclrtSynchronizeStream(NULL));
      },
      10);

  WuK_Timer(
      "MatMulV2(aclFloat16)", 2.0 * m * n * k,
      [&] {
        ACLCHECK(aclopCompileAndExecute(
            "MatMulV2", 2, hDesc, hData, 1, hDesc + 2, hData + 2, attrMatMul,
            ACL_ENGINE_SYS, ACL_COMPILE_SYS, NULL, NULL));
        ACLCHECK(aclrtSynchronizeStream(NULL));
      },
      10);

  WuK_Timer(
      "MatMulV2(float)", 2.0 * m * n * k,
      [&] {
        ACLCHECK(aclopCompileAndExecute(
            "MatMulV2", 2, sDesc, sData, 1, sDesc + 2, sData + 2, attrMatMul,
            ACL_ENGINE_SYS, ACL_COMPILE_SYS, NULL, NULL));
        ACLCHECK(aclrtSynchronizeStream(NULL));
      },
      10);

  WuK_Timer(
      "MatMul(aclFloat16)", 2.0 * m * n * k,
      [&] {
        ACLCHECK(aclopCompileAndExecute("MatMul", 2, hDesc, hData, 1, hDesc + 2,
                                        hData + 2, attrMatMul, ACL_ENGINE_SYS,
                                        ACL_COMPILE_SYS, NULL, NULL));
        ACLCHECK(aclrtSynchronizeStream(NULL));
      },
      10);

  WuK_Timer(
      "MatMul(float)", 2.0 * m * n * k,
      [&] {
        ACLCHECK(aclopCompileAndExecute("MatMul", 2, sDesc, sData, 1, sDesc + 2,
                                        sData + 2, attrMatMul, ACL_ENGINE_SYS,
                                        ACL_COMPILE_SYS, NULL, NULL));
        ACLCHECK(aclrtSynchronizeStream(NULL));
      },
      10);

  WuK_Timer(
      "GEMM(aclFloat16)", 2.0 * m * n * k,
      [&] {
        ACLCHECK(aclopCompileAndExecute("GEMM", 5, hDesc, hData, 1, hDesc + 2,
                                        hData + 2, attrGEMM, ACL_ENGINE_SYS,
                                        ACL_COMPILE_SYS, NULL, NULL));
        ACLCHECK(aclrtSynchronizeStream(NULL));
      },
      10);

  WuK_Timer("aclrtMemcpyAsyncDtoH", 0, [&] {
    ACLCHECK(aclrtMemcpyAsync(sChost, sCsize, sCdevice, sCsize,
                              ACL_MEMCPY_DEVICE_TO_HOST, NULL));
    ACLCHECK(aclrtSynchronizeStream(NULL));
  });

  ACLCHECK(aclDestroyDataBuffer(sAdata));
  ACLCHECK(aclDestroyDataBuffer(sBdata));
  ACLCHECK(aclDestroyDataBuffer(sCdata));
  ACLCHECK(aclDestroyDataBuffer(sALPHAdata));
  ACLCHECK(aclDestroyDataBuffer(sBETAdata));
  ACLCHECK(aclDestroyDataBuffer(hAdata));
  ACLCHECK(aclDestroyDataBuffer(hBdata));
  ACLCHECK(aclDestroyDataBuffer(hCdata));
  ACLCHECK(aclDestroyDataBuffer(hALPHAdata));
  ACLCHECK(aclDestroyDataBuffer(hBETAdata));
  aclopDestroyAttr(attrCastFp32);
  aclopDestroyAttr(attrCastFp16);
  aclopDestroyAttr(attrGEMM);
  aclopDestroyAttr(attrMatMul);

  WuK_Timer("aclrtFree", 0,
            [&] { ACLCHECK(aclrtFree(HPLAI_ACL_BLASPP_DEVICE_BUFFER)); });
  WuK_Timer("aclrtFreeHost", 0,
            [&] { ACLCHECK(aclrtFreeHost(HPLAI_ACL_BLASPP_HOST_BUFFER)); });

  WuK_Timer("aclrtDestroyContext", 0,
            [&] { ACLCHECK(aclrtDestroyContext(HPLAI_ACL_BLASPP_CONTEXT)); });

  WuK_Timer("aclFinalize", 0, [&] { ACLCHECK(aclFinalize()); });
}