feat: 修改ascend结构体命名，调整格式

.gitignore

@@ -16,3 +16,6 @@ __pycache__/
 
 # Cache
 cache/
+
+# JSON
+*.json

src/infiniop/devices/ascend/ascend_handle.cc

 #include "common_ascend.h"
 
-infiniopStatus_t createAscendHandle(infiniopAscendHandle_t *handle_ptr, int device_id) {
+infiniopStatus_t createAscendHandle(infiniopAscendHandle_t *handle_ptr,
+                                    int device_id) {
     uint32_t device_count;
     aclrtGetDeviceCount(&device_count);
     if (device_id >= static_cast<int>(device_count)) {
@@ -16,8 +17,7 @@ infiniopStatus_t createAscendHandle(infiniopAscendHandle_t *handle_ptr, int devi
     return INFINIOP_STATUS_SUCCESS;
 }
 
-infiniopStatus_t deleteAscendHandle(infiniopAscendHandle_t handle_ptr) {
+infiniopStatus_t destroyAscendHandle(infiniopAscendHandle_t handle_ptr) {
     delete handle_ptr;
-
     return INFINIOP_STATUS_SUCCESS;
 }

src/infiniop/devices/ascend/ascend_handle.h

 #ifndef __INFINIOP_ASCEND_HANDLE_H__
 #define __INFINIOP_ASCEND_HANDLE_H__
 
-
 #include "infinicore.h"
 #include "infiniop/handle.h"
 
 struct InfiniopAscendHandle;
 typedef struct InfiniopAscendHandle *infiniopAscendHandle_t;
 
-infiniopStatus_t createAscendHandle(infiniopAscendHandle_t *handle_ptr, int device_id);
+infiniopStatus_t createAscendHandle(infiniopAscendHandle_t *handle_ptr,
+                                    int device_id);
 
-infiniopStatus_t deleteAscendHandle(infiniopAscendHandle_t handle_ptr);
+infiniopStatus_t destroyAscendHandle(infiniopAscendHandle_t handle_ptr);
 
 #endif

src/infiniop/devices/bang/bang_handle.cc

+#include "../pool.h"
 #include "common_bang.h"
 #include <memory>
-#include "../pool.h"
 
-infiniopStatus_t createBangHandle(infiniopBangHandle_t *handle_ptr, int device_id) {
+infiniopStatus_t createBangHandle(infiniopBangHandle_t *handle_ptr,
+                                  int device_id) {
     unsigned int device_count;
     cnrtGetDeviceCount(&device_count);
     if (device_id >= static_cast<int>(device_count)) {
@@ -10,19 +11,20 @@ infiniopStatus_t createBangHandle(infiniopBangHandle_t *handle_ptr, int device_i
     }
 
     auto pool = std::make_shared<Pool<cnnlHandle_t>>();
-    if (cnrtSetDevice(device_id) != cnrtSuccess){
+    if (cnrtSetDevice(device_id) != cnrtSuccess) {
         return INFINIOP_STATUS_BAD_DEVICE;
     }
     cnnlHandle_t handle;
     cnnlCreate(&handle);
     pool->push(std::move(handle));
 
-    *handle_ptr = new InfiniopBangHandle{INFINI_DEVICE_CAMBRICON, device_id, std::move(pool)};
+    *handle_ptr = new InfiniopBangHandle{INFINI_DEVICE_CAMBRICON, device_id,
+                                         std::move(pool)};
 
     return INFINIOP_STATUS_SUCCESS;
 }
 
-infiniopStatus_t deleteBangHandle(infiniopBangHandle_t handle){
+infiniopStatus_t destroyBangHandle(infiniopBangHandle_t handle) {
     delete handle;
     return INFINIOP_STATUS_SUCCESS;
 }

src/infiniop/devices/bang/bang_handle.h

@@ -8,5 +8,6 @@ typedef struct InfiniopBangHandle *infiniopBangHandle_t;
 
 infiniopStatus_t createBangHandle(infiniopBangHandle_t *handle_ptr,
                                   int device_id);
-infiniopStatus_t deleteBangHandle(infiniopBangHandle_t handle);
+infiniopStatus_t destroyBangHandle(infiniopBangHandle_t handle);
+
 #endif

src/infiniop/devices/cpu/cpu_handle.cc

 #include "./cpu_handle.h"
 
-infiniopStatus_t createCpuHandle(infiniopCpuHandle_t* handle_ptr){
+infiniopStatus_t createCpuHandle(infiniopCpuHandle_t *handle_ptr) {
     *handle_ptr = new InfiniopHandle{INFINI_DEVICE_CPU, 0};
     return INFINIOP_STATUS_SUCCESS;
 }
+
+infiniopStatus_t destroyCpuHandle(infiniopCpuHandle_t handle) {
+    delete handle;
+    return INFINIOP_STATUS_SUCCESS;
+}

src/infiniop/devices/cpu/cpu_handle.h

@@ -7,4 +7,6 @@ typedef infiniopHandle_t infiniopCpuHandle_t;
 
 infiniopStatus_t createCpuHandle(infiniopCpuHandle_t *handle_ptr);
 
+infiniopStatus_t destroyCpuHandle(infiniopCpuHandle_t handle);
+
 #endif

src/infiniop/devices/handle.cc

@@ -12,8 +12,9 @@
 #include "./ascend/ascend_handle.h"
 #endif
 
-
-__C infiniopStatus_t infiniopCreateHandle(infiniopHandle_t *handle_ptr, infiniDevice_t device, int device_id) {
+__C infiniopStatus_t infiniopCreateHandle(infiniopHandle_t *handle_ptr,
+                                          infiniDevice_t device,
+                                          int device_id) {
     if (handle_ptr == nullptr) {
         return INFINIOP_STATUS_NULL_POINTER;
     }
@@ -23,50 +24,50 @@ __C infiniopStatus_t infiniopCreateHandle(infiniopHandle_t *handle_ptr, infiniDe
 
     switch (device) {
 #ifdef ENABLE_CPU_API
-        case INFINI_DEVICE_CPU:
-            return createCpuHandle((infiniopCpuHandle_t *) handle_ptr);
+    case INFINI_DEVICE_CPU:
+        return createCpuHandle((infiniopCpuHandle_t *)handle_ptr);
 #endif
 #ifdef ENABLE_CUDA_API
-        case INFINI_DEVICE_NVIDIA: {
-            return createCudaHandle((infiniopCudaHandle_t *) handle_ptr, device_id, device);
-        }
+    case INFINI_DEVICE_NVIDIA: {
+        return createCudaHandle((infiniopCudaHandle_t *)handle_ptr, device_id,
+                                device);
+    }
 #endif
 #ifdef ENABLE_CAMBRICON_API
-        case INFINI_DEVICE_CAMBRICON: {
-            return createBangHandle((infiniopBangHandle_t *) handle_ptr, device_id);
-        }
+    case INFINI_DEVICE_CAMBRICON: {
+        return createBangHandle((infiniopBangHandle_t *)handle_ptr, device_id);
+    }
 #endif
 #ifdef ENABLE_ASCEND_API
-        case INFINI_DEVICE_ASCEND: {
-            return createAscendHandle((infiniopAscendHandle_t *) handle_ptr, device_id);
-        }
+    case INFINI_DEVICE_ASCEND: {
+        return createAscendHandle((infiniopAscendHandle_t *)handle_ptr,
+                                  device_id);
+    }
 #endif
     }
     return INFINIOP_STATUS_DEVICE_TYPE_NOT_SUPPORTED;
 }
 
-
 __C infiniopStatus_t infiniopDestroyHandle(infiniopHandle_t handle) {
     switch (handle->device) {
 #ifdef ENABLE_CPU_API
-        case INFINI_DEVICE_CPU:
-            delete handle;
-            return INFINIOP_STATUS_SUCCESS;
+    case INFINI_DEVICE_CPU:
+        return destroyCpuHandle((infiniopCpuHandle_t)handle);
 #endif
 #ifdef ENABLE_CUDA_API
-        case INFINI_DEVICE_NVIDIA: {
-            return deleteCudaHandle((infiniopCudaHandle_t) handle);
-        }
+    case INFINI_DEVICE_NVIDIA: {
+        return deleteCudaHandle((infiniopCudaHandle_t)handle);
+    }
 #endif
 #ifdef ENABLE_CAMBRICON_API
-        case INFINI_DEVICE_CAMBRICON: {
-            return deleteBangHandle((infiniopBangHandle_t) handle);
-        }
+    case INFINI_DEVICE_CAMBRICON: {
+        return destroyBangHandle((infiniopBangHandle_t)handle);
+    }
 #endif
 #ifdef ENABLE_ASCEND_API
-        case INFINI_DEVICE_ASCEND: {
-            return deleteAscendHandle((infiniopAscendHandle_t) handle);
-        }
+    case INFINI_DEVICE_ASCEND: {
+        return destroyAscendHandle((infiniopAscendHandle_t)handle);
+    }
 #endif
     }
     return INFINIOP_STATUS_DEVICE_TYPE_NOT_SUPPORTED;

src/infiniop/ops/matmul/ascend/matmul_aclnn.cc

 #include "matmul_aclnn.h"
 
-MatmulAclnnDescriptor::MatmulAclnnDescriptor(infiniDevice_t _device) {
+InfiniopMatmulAclnnDescriptor::InfiniopMatmulAclnnDescriptor(
+    infiniDevice_t _device) {
     device = _device;
     device_id = 0;
     executor = nullptr;
@@ -23,7 +24,7 @@ infiniopStatus_t aclnnCreateMatmulDescriptor(infiniopAscendHandle_t handle,
         return INFINIOP_STATUS_BAD_TENSOR_DTYPE;
     }
 
-    *desc_ptr = new MatmulAclnnDescriptor(handle->device);
+    *desc_ptr = new InfiniopMatmulAclnnDescriptor(handle->device);
     (*desc_ptr)->device_id = handle->device_id;
     (*desc_ptr)->dtype = dtype;
     (*desc_ptr)->mt = mt;

src/infiniop/ops/matmul/ascend/matmul_aclnn.h

@@ -4,25 +4,26 @@
 #include "../../../devices/ascend/tensor_aclnn.h"
 #include "../../utils.h"
 #include "../blas.h"
+#include "matmul_aclnn_api.h"
 #include <acl/acl_base.h>
 #include <aclnn/acl_meta.h>
-#include <aclnnop/level2/aclnn_gemm.h>
 #include <aclnnop/aclnn_matmul.h>
-#include "matmul_aclnn_api.h"
+#include <aclnnop/level2/aclnn_gemm.h>
 
-struct MatmulAclnnDescriptor {
+struct InfiniopMatmulAclnnDescriptor {
     infiniDevice_t device;
     int device_id;
-    aclOpExecutor* executor;
-    MatmulInfo* info;
+    aclOpExecutor *executor;
+    MatmulInfo *info;
     infiniDtype_t dtype;
     aclnnTensorDescriptor_t cDesc, aDesc, bDesc;
     // cubeMathType
-    // see doc: https://www.hiascend.com/document/detail/zh/CANNCommunityEdition/80RC3alpha002/apiref/appdevgapi/context/aclnnBatchMatMul.md
+    // see doc:
+    // https://www.hiascend.com/document/detail/zh/CANNCommunityEdition/80RC3alpha002/apiref/appdevgapi/context/aclnnBatchMatMul.md
     int8_t mt;
     size_t workspaceSize;
 
-    MatmulAclnnDescriptor(infiniDevice_t _device);
+    InfiniopMatmulAclnnDescriptor(infiniDevice_t _device);
 };
 
 #endif

src/infiniop/ops/matmul/ascend/matmul_aclnn_api.h

@@ -3,28 +3,23 @@
 #include "../../../devices/ascend/ascend_handle.h"
 #include "infiniop/operator.h"
 
-struct MatmulAclnnDescriptor;
-typedef struct MatmulAclnnDescriptor *MatmulAclnnDescriptor_t;
+struct InfiniopMatmulAclnnDescriptor;
+typedef struct InfiniopMatmulAclnnDescriptor *MatmulAclnnDescriptor_t;
 
 infiniopStatus_t aclnnCreateMatmulDescriptor(infiniopAscendHandle_t handle,
-    MatmulAclnnDescriptor_t *desc_ptr,
-    infiniopTensorDescriptor_t c_desc,
-    infiniopTensorDescriptor_t a_desc,
-    infiniopTensorDescriptor_t b_desc,
-    int8_t cubeMathType);
+                                             MatmulAclnnDescriptor_t *desc_ptr,
+                                             infiniopTensorDescriptor_t c_desc,
+                                             infiniopTensorDescriptor_t a_desc,
+                                             infiniopTensorDescriptor_t b_desc,
+                                             int8_t cubeMathType);
 
 infiniopStatus_t aclnnGetMatmulWorkspaceSize(MatmulAclnnDescriptor_t desc,
-    size_t *size);
+                                             size_t *size);
 
-infiniopStatus_t aclnnMatmul(MatmulAclnnDescriptor_t desc,
-void *workspace,
-size_t workspace_size,
-void *c,
-const void *a,
-const void *b,
-float alpha,
-float beta,
-void *stream);
+infiniopStatus_t aclnnMatmul(MatmulAclnnDescriptor_t desc, void *workspace,
+                             size_t workspace_size, void *c, const void *a,
+                             const void *b, float alpha, float beta,
+                             void *stream);
 
 infiniopStatus_t aclnnDestroyMatmulDescriptor(MatmulAclnnDescriptor_t desc);
 #endif // __INFINIOP_MATMUL_ACLNN_API_H__

src/infiniop/ops/matmul/cpu/matmul_cpu.h

 #ifndef __INFINIOP_MATMUL_CPU_H__
 #define __INFINIOP_MATMUL_CPU_H__
 
-#include "../../../devices/cpu/cpu_handle.h"
 #include "../blas.h"
-#include "infiniop/operator.h"
+#include "./matmul_cpu_api.h"
 
 typedef struct MatmulCpuDescriptor {
     infiniDevice_t device;
@@ -11,20 +10,4 @@ typedef struct MatmulCpuDescriptor {
     MatmulInfo info;
 } MatmulCpuDescriptor;
 
-typedef struct MatmulCpuDescriptor *infiniopMatmulCpuDescriptor_t;
-
-infiniopStatus_t cpuCreateMatmulDescriptor(
-    infiniopCpuHandle_t handle, infiniopMatmulCpuDescriptor_t *desc_ptr,
-    infiniopTensorDescriptor_t c_desc, infiniopTensorDescriptor_t a_desc,
-    infiniopTensorDescriptor_t b_desc);
-
-infiniopStatus_t cpuGetMatmulWorkspaceSize(infiniopMatmulCpuDescriptor_t desc,
-                                           uint64_t *size);
-
-infiniopStatus_t cpuMatmul(infiniopMatmulCpuDescriptor_t desc, void *workspace,
-                           uint64_t workspace_size, void *c, void const *a,
-                           void const *b, float alpha, float beta);
-
-infiniopStatus_t cpuDestroyMatmulDescriptor(infiniopMatmulCpuDescriptor_t desc);
-
 #endif // __INFINIOP_MATMUL_CPU_H__

src/infiniop/ops/matmul/cpu/matmul_cpu_api.h

+#ifndef __INFINIOP_MATMUL_CPU_API_H__
+#define __INFINIOP_MATMUL_CPU_API_H__
+
+#include "../../../devices/cpu/cpu_handle.h"
+#include "infiniop/operator.h"
+
+struct MatmulCpuDescriptor;
+
+typedef struct MatmulCpuDescriptor *infiniopMatmulCpuDescriptor_t;
+
+infiniopStatus_t cpuCreateMatmulDescriptor(
+    infiniopCpuHandle_t handle, infiniopMatmulCpuDescriptor_t *desc_ptr,
+    infiniopTensorDescriptor_t c_desc, infiniopTensorDescriptor_t a_desc,
+    infiniopTensorDescriptor_t b_desc);
+
+infiniopStatus_t cpuGetMatmulWorkspaceSize(infiniopMatmulCpuDescriptor_t desc,
+                                           uint64_t *size);
+
+infiniopStatus_t cpuMatmul(infiniopMatmulCpuDescriptor_t desc, void *workspace,
+                           uint64_t workspace_size, void *c, void const *a,
+                           void const *b, float alpha, float beta);
+
+infiniopStatus_t cpuDestroyMatmulDescriptor(infiniopMatmulCpuDescriptor_t desc);
+
+#endif // __INFINIOP_MATMUL_CPU_API_H__

src/infiniop/ops/matmul/operator.cc

 #include "infiniop/ops/matmul.h"
 
 #ifdef ENABLE_CPU_API
-#include "cpu/matmul_cpu.h"
+#include "cpu/matmul_cpu_api.h"
 #endif
 #ifdef ENABLE_CUDA_API
 #include "cuda/matmul_cuda_api.h"