issue/71 合并infiniStatus

src/infiniop/ops/matmul/blas.h

@@ -16,7 +16,7 @@ struct BlasMatrix {
 
     BlasMatrix() = default;
 
-    BlasMatrix(infiniopTensorDescriptor_t layout, infiniopStatus_t *status) {
+    BlasMatrix(infiniopTensorDescriptor_t layout, infiniStatus_t *status) {
         if (layout->ndim == 2) {
             ndim = 2;
             batch = 1;
@@ -34,16 +34,16 @@ struct BlasMatrix {
             row_stride = layout->strides[1];
             col_stride = layout->strides[2];
         } else {
-            *status = INFINIOP_STATUS_BAD_TENSOR_SHAPE;
+            *status = INFINI_STATUS_BAD_TENSOR_SHAPE;
             return;
         }
 
         if (row_stride != 1 && col_stride != 1) {
-            *status = INFINIOP_STATUS_BAD_TENSOR_STRIDES;
+            *status = INFINI_STATUS_BAD_TENSOR_STRIDES;
             return;
         }
 
-        *status = INFINIOP_STATUS_SUCCESS;
+        *status = INFINI_STATUS_SUCCESS;
     }
 
     bool match_batch(size_t _batch) const {
@@ -77,29 +77,29 @@ struct MatmulInfo {
     MatmulInfo(infiniopTensorDescriptor_t c_desc,
                infiniopTensorDescriptor_t a_desc,
                infiniopTensorDescriptor_t b_desc,
-               infiniopStatus_t *status,
+               infiniStatus_t *status,
                MatrixLayout layout) {
         a_matrix = BlasMatrix(a_desc, status);
-        if (*status != INFINIOP_STATUS_SUCCESS) {
+        if (*status != INFINI_STATUS_SUCCESS) {
             return;
         }
         b_matrix = BlasMatrix(b_desc, status);
-        if (*status != INFINIOP_STATUS_SUCCESS) {
+        if (*status != INFINI_STATUS_SUCCESS) {
             return;
         }
         c_matrix = BlasMatrix(c_desc, status);
-        if (*status != INFINIOP_STATUS_SUCCESS) {
+        if (*status != INFINI_STATUS_SUCCESS) {
             return;
         }
 
         if (c_matrix.rows != a_matrix.rows || c_matrix.cols != b_matrix.cols || a_matrix.cols != b_matrix.rows) {
-            *status = INFINIOP_STATUS_BAD_TENSOR_SHAPE;
+            *status = INFINI_STATUS_BAD_TENSOR_SHAPE;
             return;
         }
 
         batch = c_matrix.batch;
         if (!a_matrix.match_batch(batch) || !b_matrix.match_batch(batch)) {
-            *status = INFINIOP_STATUS_BAD_TENSOR_SHAPE;
+            *status = INFINI_STATUS_BAD_TENSOR_SHAPE;
             return;
         }
 

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

@@ -6,7 +6,7 @@ namespace matmul::cpu {
 
 Descriptor::~Descriptor() = default;
 
-infiniopStatus_t Descriptor::create(
+infiniStatus_t Descriptor::create(
     infiniopHandle_t handle_,
     Descriptor **desc_ptr,
     infiniopTensorDescriptor_t c_desc,
@@ -16,12 +16,12 @@ infiniopStatus_t Descriptor::create(
     auto dtype = c_desc->dtype;
 
     if (dtype != INFINI_DTYPE_F16 && dtype != INFINI_DTYPE_F32) {
-        return INFINIOP_STATUS_BAD_TENSOR_DTYPE;
+        return INFINI_STATUS_BAD_TENSOR_DTYPE;
     }
 
-    infiniopStatus_t status;
+    infiniStatus_t status;
     auto info = MatmulInfo(c_desc, a_desc, b_desc, &status, MatrixLayout::COL_MAJOR);
-    if (status != INFINIOP_STATUS_SUCCESS) {
+    if (status != INFINI_STATUS_SUCCESS) {
         return status;
     }
 
@@ -29,7 +29,7 @@ infiniopStatus_t Descriptor::create(
         dtype, info, 0,
         nullptr,
         handle->device, handle->device_id);
-    return INFINIOP_STATUS_SUCCESS;
+    return INFINI_STATUS_SUCCESS;
 }
 
 template <typename Tdata>
@@ -72,7 +72,7 @@ void calculate(
     }
 }
 
-infiniopStatus_t Descriptor::calculate(
+infiniStatus_t Descriptor::calculate(
     void *workspace,
     size_t workspace_size,
     void *c,
@@ -85,14 +85,14 @@ infiniopStatus_t Descriptor::calculate(
     switch (_dtype) {
     case INFINI_DTYPE_F16:
         cpu::calculate<uint16_t>(_info, c, beta, a, b, alpha);
-        return INFINIOP_STATUS_SUCCESS;
+        return INFINI_STATUS_SUCCESS;
 
     case INFINI_DTYPE_F32:
         cpu::calculate<float>(_info, c, beta, a, b, alpha);
-        return INFINIOP_STATUS_SUCCESS;
+        return INFINI_STATUS_SUCCESS;
 
     default:
-        return INFINIOP_STATUS_BAD_TENSOR_DTYPE;
+        return INFINI_STATUS_BAD_TENSOR_DTYPE;
     }
 }
 

src/infiniop/ops/matmul/cuda/matmul_cuda.cu

@@ -12,7 +12,7 @@ Descriptor::~Descriptor() {
     delete _opaque;
 }
 
-infiniopStatus_t Descriptor::create(
+infiniStatus_t Descriptor::create(
     infiniopHandle_t handle_,
     Descriptor **desc_ptr,
     infiniopTensorDescriptor_t c_desc,
@@ -22,12 +22,12 @@ infiniopStatus_t Descriptor::create(
     auto dtype = c_desc->dtype;
 
     if (dtype != INFINI_DTYPE_F16 && dtype != INFINI_DTYPE_F32) {
-        return INFINIOP_STATUS_BAD_TENSOR_DTYPE;
+        return INFINI_STATUS_BAD_TENSOR_DTYPE;
     }
 
-    infiniopStatus_t status;
+    infiniStatus_t status;
     auto info = MatmulInfo(c_desc, a_desc, b_desc, &status, MatrixLayout::COL_MAJOR);
-    if (status != INFINIOP_STATUS_SUCCESS) {
+    if (status != INFINI_STATUS_SUCCESS) {
         return status;
     }
 
@@ -35,7 +35,7 @@ infiniopStatus_t Descriptor::create(
         dtype, info, 0,
         new Opaque{handle->cublas_handle_pool},
         handle->device, handle->device_id);
-    return INFINIOP_STATUS_SUCCESS;
+    return INFINI_STATUS_SUCCESS;
 }
 
 template <typename Tdata>
@@ -100,7 +100,7 @@ void calculate(
                });
 }
 
-infiniopStatus_t Descriptor::calculate(
+infiniStatus_t Descriptor::calculate(
     void *workspace,
     size_t workspace_size,
     void *c,
@@ -113,14 +113,14 @@ infiniopStatus_t Descriptor::calculate(
     switch (_dtype) {
     case INFINI_DTYPE_F16:
         cuda::calculate<uint16_t>(_info, _opaque->cublas_handle_pool, c, beta, a, b, alpha, (cudaStream_t)stream);
-        return INFINIOP_STATUS_SUCCESS;
+        return INFINI_STATUS_SUCCESS;
 
     case INFINI_DTYPE_F32:
         cuda::calculate<float>(_info, _opaque->cublas_handle_pool, c, beta, a, b, alpha, (cudaStream_t)stream);
-        return INFINIOP_STATUS_SUCCESS;
+        return INFINI_STATUS_SUCCESS;
 
     default:
-        return INFINIOP_STATUS_BAD_TENSOR_DTYPE;
+        return INFINI_STATUS_BAD_TENSOR_DTYPE;
     }
 }
 

src/infiniop/ops/matmul/matmul.h

@@ -71,14 +71,14 @@
                                                           \
         ~Descriptor();                                    \
                                                           \
-        static infiniopStatus_t create(                   \
+        static infiniStatus_t create(                     \
             infiniopHandle_t handle,                      \
             Descriptor **desc_ptr,                        \
             infiniopTensorDescriptor_t c_desc,            \
             infiniopTensorDescriptor_t a_desc,            \
             infiniopTensorDescriptor_t b_desc);           \
                                                           \
-        infiniopStatus_t calculate(                       \
+        infiniStatus_t calculate(                         \
             void *workspace,                              \
             size_t workspace_size,                        \
             void *c,                                      \

src/infiniop/ops/matmul/operator.cc

@@ -13,7 +13,7 @@
 #include "ascend/matmul_ascend.h"
 #endif
 
-__C infiniopStatus_t infiniopCreateMatmulDescriptor(
+__C infiniStatus_t infiniopCreateMatmulDescriptor(
     infiniopHandle_t handle,
     infiniopMatmulDescriptor_t *desc_ptr,
     infiniopTensorDescriptor_t c_desc,
@@ -45,13 +45,13 @@ __C infiniopStatus_t infiniopCreateMatmulDescriptor(
 #endif
 
     default:
-        return INFINIOP_STATUS_DEVICE_TYPE_NOT_SUPPORTED;
+        return INFINI_STATUS_DEVICE_TYPE_NOT_SUPPORTED;
     }
 
 #undef CREATE
 }
 
-__C infiniopStatus_t
+__C infiniStatus_t
 infiniopGetMatmulWorkspaceSize(
     infiniopMatmulDescriptor_t desc,
     size_t *size) {
@@ -59,7 +59,7 @@ infiniopGetMatmulWorkspaceSize(
 #define GET(CASE, NAMESPACE)                                                                   \
     case CASE:                                                                                 \
         *size = reinterpret_cast<const matmul::NAMESPACE::Descriptor *>(desc)->workspace_size; \
-        return INFINIOP_STATUS_SUCCESS
+        return INFINI_STATUS_SUCCESS
 
     switch (desc->device_type) {
 
@@ -77,13 +77,13 @@ infiniopGetMatmulWorkspaceSize(
 #endif
 
     default:
-        return INFINIOP_STATUS_DEVICE_TYPE_NOT_SUPPORTED;
+        return INFINI_STATUS_DEVICE_TYPE_NOT_SUPPORTED;
     }
 
 #undef GET
 }
 
-__C infiniopStatus_t infiniopMatmul(
+__C infiniStatus_t infiniopMatmul(
     infiniopMatmulDescriptor_t desc,
     void *workspace, size_t workspace_size,
     void *c,
@@ -117,19 +117,19 @@ __C infiniopStatus_t infiniopMatmul(
 #endif
 
     default:
-        return INFINIOP_STATUS_DEVICE_TYPE_NOT_SUPPORTED;
+        return INFINI_STATUS_DEVICE_TYPE_NOT_SUPPORTED;
     }
 
 #undef CALCULATE
 }
 
-__C infiniopStatus_t
+__C infiniStatus_t
 infiniopDestroyMatmulDescriptor(infiniopMatmulDescriptor_t desc) {
 
 #define DELETE(CASE, NAMESPACE)                                               \
     case CASE:                                                                \
         delete reinterpret_cast<const matmul::NAMESPACE::Descriptor *>(desc); \
-        return INFINIOP_STATUS_SUCCESS;
+        return INFINI_STATUS_SUCCESS;
 
     switch (desc->device_type) {
 
@@ -147,7 +147,7 @@ infiniopDestroyMatmulDescriptor(infiniopMatmulDescriptor_t desc) {
 #endif
 
     default:
-        return INFINIOP_STATUS_DEVICE_TYPE_NOT_SUPPORTED;
+        return INFINI_STATUS_DEVICE_TYPE_NOT_SUPPORTED;
     }
 
 #undef DELETE

src/infiniop/ops/random_sample/operator.cc

 #include "infiniop/ops/random_sample.h"
 
-__C infiniopStatus_t infiniopCreateRandomSampleDescriptor(infiniopHandle_t handle, infiniopRandomSampleDescriptor_t *desc_ptr, infiniopTensorDescriptor_t result, infiniopTensorDescriptor_t probs) {
+__C infiniStatus_t infiniopCreateRandomSampleDescriptor(infiniopHandle_t handle, infiniopRandomSampleDescriptor_t *desc_ptr, infiniopTensorDescriptor_t result, infiniopTensorDescriptor_t probs) {
     switch (handle->device) {
 #ifdef ENABLE_CPU
     case DevCpu:
@@ -35,10 +35,10 @@ __C infiniopStatus_t infiniopCreateRandomSampleDescriptor(infiniopHandle_t handl
         return musaCreateRandomSampleDescriptor((MusaHandle_t)handle, (RandomSampleMusaDescriptor_t *)desc_ptr, result, probs);
 #endif
     }
-    return INFINIOP_STATUS_DEVICE_TYPE_NOT_SUPPORTED;
+    return INFINI_STATUS_DEVICE_TYPE_NOT_SUPPORTED;
 };
 
-__C infiniopStatus_t infiniopGetRandomSampleWorkspaceSize(infiniopRandomSampleDescriptor_t desc, size_t *size) {
+__C infiniStatus_t infiniopGetRandomSampleWorkspaceSize(infiniopRandomSampleDescriptor_t desc, size_t *size) {
     switch (desc->device_type) {
 #ifdef ENABLE_CPU
     case DevCpu:
@@ -72,19 +72,19 @@ __C infiniopStatus_t infiniopGetRandomSampleWorkspaceSize(infiniopRandomSampleDe
     }
 #endif
     }
-    return INFINIOP_STATUS_DEVICE_TYPE_NOT_SUPPORTED;
+    return INFINI_STATUS_DEVICE_TYPE_NOT_SUPPORTED;
 }
 
-__C infiniopStatus_t infiniopRandomSample(infiniopRandomSampleDescriptor_t desc,
-                                          void *workspace,
-                                          size_t workspace_size,
-                                          void *result,
-                                          const void *probs,
-                                          float random_val,
-                                          float topp,
-                                          int topk,
-                                          float temperature,
-                                          void *stream) {
+__C infiniStatus_t infiniopRandomSample(infiniopRandomSampleDescriptor_t desc,
+                                        void *workspace,
+                                        size_t workspace_size,
+                                        void *result,
+                                        const void *probs,
+                                        float random_val,
+                                        float topp,
+                                        int topk,
+                                        float temperature,
+                                        void *stream) {
     switch (desc->device_type) {
 #ifdef ENABLE_CPU
     case DevCpu:
@@ -114,10 +114,10 @@ __C infiniopStatus_t infiniopRandomSample(infiniopRandomSampleDescriptor_t desc,
         return musaRandomSample((RandomSampleMusaDescriptor_t)desc, workspace, workspace_size, result, probs, random_val, topp, topk, temperature, stream);
 #endif
     }
-    return INFINIOP_STATUS_DEVICE_TYPE_NOT_SUPPORTED;
+    return INFINI_STATUS_DEVICE_TYPE_NOT_SUPPORTED;
 }
 
-__C infiniopStatus_t infiniopDestroyRandomSampleDescriptor(infiniopRandomSampleDescriptor_t desc) {
+__C infiniStatus_t infiniopDestroyRandomSampleDescriptor(infiniopRandomSampleDescriptor_t desc) {
     switch (desc->device_type) {
 #ifdef ENABLE_CPU
     case DevCpu:
@@ -147,5 +147,5 @@ __C infiniopStatus_t infiniopDestroyRandomSampleDescriptor(infiniopRandomSampleD
         return musaDestroyRandomSampleDescriptor((RandomSampleMusaDescriptor_t)desc);
 #endif
     }
-    return INFINIOP_STATUS_DEVICE_TYPE_NOT_SUPPORTED;
+    return INFINI_STATUS_DEVICE_TYPE_NOT_SUPPORTED;
 }

src/infiniop/ops/rearrange/operator.cc

 #include "infiniop/ops/rearrange.h"
 
-__C infiniopStatus_t infiniopCreateRearrangeDescriptor(
+__C infiniStatus_t infiniopCreateRearrangeDescriptor(
     infiniopHandle_t handle,
     infiniopRearrangeDescriptor_t *desc_ptr,
     infiniopTensorDescriptor_t dst,
@@ -40,10 +40,10 @@ __C infiniopStatus_t infiniopCreateRearrangeDescriptor(
     }
 #endif
     }
-    return INFINIOP_STATUS_DEVICE_TYPE_NOT_SUPPORTED;
+    return INFINI_STATUS_DEVICE_TYPE_NOT_SUPPORTED;
 }
 
-__C infiniopStatus_t infiniopRearrange(infiniopRearrangeDescriptor_t desc, void *dst, const void *src, void *stream) {
+__C infiniStatus_t infiniopRearrange(infiniopRearrangeDescriptor_t desc, void *dst, const void *src, void *stream) {
     switch (desc->device_type) {
 #ifdef ENABLE_CPU
     case DevCpu:
@@ -79,10 +79,10 @@ __C infiniopStatus_t infiniopRearrange(infiniopRearrangeDescriptor_t desc, void
     }
 #endif
     }
-    return INFINIOP_STATUS_DEVICE_TYPE_NOT_SUPPORTED;
+    return INFINI_STATUS_DEVICE_TYPE_NOT_SUPPORTED;
 }
 
-__C infiniopStatus_t infiniopDestroyRearrangeDescriptor(infiniopRearrangeDescriptor_t desc) {
+__C infiniStatus_t infiniopDestroyRearrangeDescriptor(infiniopRearrangeDescriptor_t desc) {
     switch (desc->device_type) {
 #ifdef ENABLE_CPU
     case DevCpu:
@@ -115,5 +115,5 @@ __C infiniopStatus_t infiniopDestroyRearrangeDescriptor(infiniopRearrangeDescrip
     }
 #endif
     }
-    return INFINIOP_STATUS_DEVICE_TYPE_NOT_SUPPORTED;
+    return INFINI_STATUS_DEVICE_TYPE_NOT_SUPPORTED;
 }

src/infiniop/ops/rms_norm/operator.cc

 #include "infiniop/ops/rms_norm.h"
 
-__C infiniopStatus_t infiniopCreateRMSNormDescriptor(
+__C infiniStatus_t infiniopCreateRMSNormDescriptor(
     infiniopHandle_t handle,
     infiniopRMSNormDescriptor_t *desc_ptr,
     infiniopTensorDescriptor_t y_desc,
@@ -43,10 +43,10 @@ __C infiniopStatus_t infiniopCreateRMSNormDescriptor(
     }
 #endif
     }
-    return INFINIOP_STATUS_DEVICE_TYPE_NOT_SUPPORTED;
+    return INFINI_STATUS_DEVICE_TYPE_NOT_SUPPORTED;
 }
 
-__C infiniopStatus_t infiniopGetRMSNormWorkspaceSize(infiniopRMSNormDescriptor_t desc, size_t *size) {
+__C infiniStatus_t infiniopGetRMSNormWorkspaceSize(infiniopRMSNormDescriptor_t desc, size_t *size) {
     switch (desc->device_type) {
 #ifdef ENABLE_CPU
     case DevCpu:
@@ -80,11 +80,11 @@ __C infiniopStatus_t infiniopGetRMSNormWorkspaceSize(infiniopRMSNormDescriptor_t
     }
 #endif
     }
-    return INFINIOP_STATUS_DEVICE_TYPE_NOT_SUPPORTED;
+    return INFINI_STATUS_DEVICE_TYPE_NOT_SUPPORTED;
 }
 
-__C infiniopStatus_t infiniopRMSNorm(infiniopRMSNormDescriptor_t desc, void *workspace, size_t workspace_size,
-                                     void *y, const void *x, const void *w, void *stream) {
+__C infiniStatus_t infiniopRMSNorm(infiniopRMSNormDescriptor_t desc, void *workspace, size_t workspace_size,
+                                   void *y, const void *x, const void *w, void *stream) {
     switch (desc->device_type) {
 #ifdef ENABLE_CPU
     case DevCpu:
@@ -123,10 +123,10 @@ __C infiniopStatus_t infiniopRMSNorm(infiniopRMSNormDescriptor_t desc, void *wor
     }
 #endif
     }
-    return INFINIOP_STATUS_DEVICE_TYPE_NOT_SUPPORTED;
+    return INFINI_STATUS_DEVICE_TYPE_NOT_SUPPORTED;
 }
 
-__C infiniopStatus_t infiniopDestroyRMSNormDescriptor(infiniopRMSNormDescriptor_t desc) {
+__C infiniStatus_t infiniopDestroyRMSNormDescriptor(infiniopRMSNormDescriptor_t desc) {
     switch (desc->device_type) {
 #ifdef ENABLE_CPU
     case DevCpu:
@@ -159,5 +159,5 @@ __C infiniopStatus_t infiniopDestroyRMSNormDescriptor(infiniopRMSNormDescriptor_
     }
 #endif
     }
-    return INFINIOP_STATUS_DEVICE_TYPE_NOT_SUPPORTED;
+    return INFINI_STATUS_DEVICE_TYPE_NOT_SUPPORTED;
 }

src/infiniop/ops/rotary_embedding/operator.cc

 #include "infiniop/ops/rotary_embedding.h"
 
-__C infiniopStatus_t infiniopCreateRoPEDescriptor(
+__C infiniStatus_t infiniopCreateRoPEDescriptor(
     infiniopHandle_t handle, infiniopRoPEDescriptor_t *desc_ptr,
     infiniopTensorDescriptor_t t, infiniopTensorDescriptor_t pos_ids,
     infiniopTensorDescriptor_t sin_table,
@@ -49,11 +49,11 @@ __C infiniopStatus_t infiniopCreateRoPEDescriptor(
     }
 #endif
     }
-    return INFINIOP_STATUS_DEVICE_TYPE_NOT_SUPPORTED;
+    return INFINI_STATUS_DEVICE_TYPE_NOT_SUPPORTED;
 }
 
-__C infiniopStatus_t infiniopGetRoPEWorkspaceSize(infiniopRoPEDescriptor_t desc,
-                                                  size_t *size) {
+__C infiniStatus_t infiniopGetRoPEWorkspaceSize(infiniopRoPEDescriptor_t desc,
+                                                size_t *size) {
     switch (desc->device_type) {
 #ifdef ENABLE_CPU
     case DevCpu:
@@ -86,14 +86,14 @@ __C infiniopStatus_t infiniopGetRoPEWorkspaceSize(infiniopRoPEDescriptor_t desc,
     }
 #endif
     }
-    return INFINIOP_STATUS_DEVICE_TYPE_NOT_SUPPORTED;
+    return INFINI_STATUS_DEVICE_TYPE_NOT_SUPPORTED;
 }
 
-__C infiniopStatus_t infiniopRoPE(infiniopRoPEDescriptor_t desc,
-                                  void *workspace, size_t workspace_size,
-                                  void *t, const void *pos_ids,
-                                  const void *sin_table, const void *cos_table,
-                                  void *stream) {
+__C infiniStatus_t infiniopRoPE(infiniopRoPEDescriptor_t desc,
+                                void *workspace, size_t workspace_size,
+                                void *t, const void *pos_ids,
+                                const void *sin_table, const void *cos_table,
+                                void *stream) {
     switch (desc->device_type) {
 #ifdef ENABLE_CPU
     case DevCpu:
@@ -133,10 +133,10 @@ __C infiniopStatus_t infiniopRoPE(infiniopRoPEDescriptor_t desc,
     }
 #endif
     }
-    return INFINIOP_STATUS_DEVICE_TYPE_NOT_SUPPORTED;
+    return INFINI_STATUS_DEVICE_TYPE_NOT_SUPPORTED;
 }
 
-__C infiniopStatus_t
+__C infiniStatus_t
 infiniopDestroyRoPEDescriptor(infiniopRoPEDescriptor_t desc) {
     switch (desc->device_type) {
 #ifdef ENABLE_CPU
@@ -170,5 +170,5 @@ infiniopDestroyRoPEDescriptor(infiniopRoPEDescriptor_t desc) {
     }
 #endif
     }
-    return INFINIOP_STATUS_DEVICE_TYPE_NOT_SUPPORTED;
+    return INFINI_STATUS_DEVICE_TYPE_NOT_SUPPORTED;
 }

src/infiniop/ops/swiglu/operator.cc

 #include "infiniop/ops/swiglu.h"
 
-__C infiniopStatus_t infiniopCreateSwiGLUDescriptor(
+__C infiniStatus_t infiniopCreateSwiGLUDescriptor(
     infiniopHandle_t handle, infiniopSwiGLUDescriptor_t *desc_ptr,
     infiniopTensorDescriptor_t c_desc, infiniopTensorDescriptor_t a_desc,
     infiniopTensorDescriptor_t b_desc) {
@@ -42,12 +42,12 @@ __C infiniopStatus_t infiniopCreateSwiGLUDescriptor(
             handle, (SwiGLUMusaDescriptor_t *)desc_ptr, c_desc, a_desc, b_desc);
 #endif
     }
-    return INFINIOP_STATUS_DEVICE_TYPE_NOT_SUPPORTED;
+    return INFINI_STATUS_DEVICE_TYPE_NOT_SUPPORTED;
 };
 
-__C infiniopStatus_t infiniopSwiGLU(infiniopSwiGLUDescriptor_t desc, void *c,
-                                    const void *a, const void *b,
-                                    void *stream) {
+__C infiniStatus_t infiniopSwiGLU(infiniopSwiGLUDescriptor_t desc, void *c,
+                                  const void *a, const void *b,
+                                  void *stream) {
     switch (desc->device_type) {
 #ifdef ENABLE_CPU
     case DevCpu:
@@ -75,10 +75,10 @@ __C infiniopStatus_t infiniopSwiGLU(infiniopSwiGLUDescriptor_t desc, void *c,
         return musaSwiGLU((SwiGLUMusaDescriptor_t)desc, c, a, b, stream);
 #endif
     }
-    return INFINIOP_STATUS_DEVICE_TYPE_NOT_SUPPORTED;
+    return INFINI_STATUS_DEVICE_TYPE_NOT_SUPPORTED;
 }
 
-__C infiniopStatus_t
+__C infiniStatus_t
 infiniopDestroySwiGLUDescriptor(infiniopSwiGLUDescriptor_t desc) {
     switch (desc->device_type) {
 #ifdef ENABLE_CPU
@@ -107,5 +107,5 @@ infiniopDestroySwiGLUDescriptor(infiniopSwiGLUDescriptor_t desc) {
         return musaDestroySwiGLUDescriptor((SwiGLUMusaDescriptor_t)desc);
 #endif
     }
-    return INFINIOP_STATUS_DEVICE_TYPE_NOT_SUPPORTED;
+    return INFINI_STATUS_DEVICE_TYPE_NOT_SUPPORTED;
 }

src/infiniop/tensor_descriptor.cc

 #include "infiniop/tensor_descriptor.h"
 #include <cstring>
 
-__C __export infiniopStatus_t infiniopCreateTensorDescriptor(infiniopTensorDescriptor_t *desc_ptr, size_t ndim, size_t const *shape_, ptrdiff_t const *strides_, infiniDtype_t datatype) {
+__C __export infiniStatus_t infiniopCreateTensorDescriptor(infiniopTensorDescriptor_t *desc_ptr, size_t ndim, size_t const *shape_, ptrdiff_t const *strides_, infiniDtype_t datatype) {
     size_t *shape = new size_t[ndim];
     ptrdiff_t *strides = new ptrdiff_t[ndim];
     std::memcpy(shape, shape_, ndim * sizeof(size_t));
@@ -15,12 +15,12 @@ __C __export infiniopStatus_t infiniopCreateTensorDescriptor(infiniopTensorDescr
         }
     }
     *desc_ptr = new InfiniopTensorDescriptor{datatype, ndim, shape, strides};
-    return INFINIOP_STATUS_SUCCESS;
+    return INFINI_STATUS_SUCCESS;
 }
 
-__C __export infiniopStatus_t infiniopDestroyTensorDescriptor(infiniopTensorDescriptor_t desc) {
+__C __export infiniStatus_t infiniopDestroyTensorDescriptor(infiniopTensorDescriptor_t desc) {
     delete[] desc->shape;
     delete[] desc->strides;
     delete desc;
-    return INFINIOP_STATUS_SUCCESS;
+    return INFINI_STATUS_SUCCESS;
 }