issue/1033 - replace __C with __INFINI_C

src/infiniop/ops/swiglu/operator.cc

@@ -28,7 +28,7 @@
 #include "moore/swiglu_moore.h"
 #endif
 
-__C infiniStatus_t infiniopCreateSwiGLUDescriptor(
+__INFINI_C infiniStatus_t infiniopCreateSwiGLUDescriptor(
     infiniopHandle_t handle,
     infiniopSwiGLUDescriptor_t *desc_ptr,
     infiniopTensorDescriptor_t c_desc,
@@ -105,7 +105,7 @@ __C infiniStatus_t infiniopCreateSwiGLUDescriptor(
 #undef CREATE_CUDA
 }
 
-__C infiniStatus_t infiniopGetSwiGLUWorkspaceSize(infiniopSwiGLUDescriptor_t desc, size_t *size) {
+__INFINI_C infiniStatus_t infiniopGetSwiGLUWorkspaceSize(infiniopSwiGLUDescriptor_t desc, size_t *size) {
 
 #define GET(CASE, NAMESPACE)                                                                  \
     case CASE:                                                                                \
@@ -168,7 +168,7 @@ __C infiniStatus_t infiniopGetSwiGLUWorkspaceSize(infiniopSwiGLUDescriptor_t des
 #undef GET_CUDA
 }
 
-__C infiniStatus_t infiniopSwiGLU(
+__INFINI_C infiniStatus_t infiniopSwiGLU(
     infiniopSwiGLUDescriptor_t desc,
     void *workspace,
     size_t workspace_size,
@@ -239,7 +239,7 @@ __C infiniStatus_t infiniopSwiGLU(
 #undef CALCULATE_CUDA
 }
 
-__C infiniStatus_t
+__INFINI_C infiniStatus_t
 infiniopDestroySwiGLUDescriptor(infiniopSwiGLUDescriptor_t desc) {
 
 #define DELETE(CASE, NAMESPACE)                                                   \

src/infiniop/ops/tanh/operator.cc

@@ -12,7 +12,7 @@
 // #include "metax/tanh_metax.h"
 // #endif
 
-__C infiniStatus_t infiniopCreateTanhDescriptor(
+__INFINI_C infiniStatus_t infiniopCreateTanhDescriptor(
     infiniopHandle_t handle,
     infiniopTanhDescriptor_t *desc_ptr,
     infiniopTensorDescriptor_t output_desc,
@@ -55,7 +55,7 @@ __C infiniStatus_t infiniopCreateTanhDescriptor(
 #undef CREATE
 }
 
-__C infiniStatus_t infiniopGetTanhWorkspaceSize(infiniopTanhDescriptor_t desc, size_t *size) {
+__INFINI_C infiniStatus_t infiniopGetTanhWorkspaceSize(infiniopTanhDescriptor_t desc, size_t *size) {
 
 #define GET(CASE, NAMESPACE)                                                                \
     case CASE:                                                                              \
@@ -90,7 +90,7 @@ __C infiniStatus_t infiniopGetTanhWorkspaceSize(infiniopTanhDescriptor_t desc, s
     return INFINI_STATUS_DEVICE_TYPE_NOT_SUPPORTED;
 }
 
-__C infiniStatus_t infiniopTanh(
+__INFINI_C infiniStatus_t infiniopTanh(
     infiniopTanhDescriptor_t desc,
     void *workspace,
     size_t workspace_size,
@@ -132,7 +132,7 @@ __C infiniStatus_t infiniopTanh(
 #undef CALCULATE
 }
 
-__C infiniStatus_t
+__INFINI_C infiniStatus_t
 infiniopDestroyTanhDescriptor(infiniopTanhDescriptor_t desc) {
 
 #define DELETE(CASE, NAMESPACE)                                                 \

src/infiniop/ops/topkrouter/operator.cc

@@ -15,7 +15,7 @@
 #include "kunlun/topkrouter_kunlun.h"
 #endif
 
-__C infiniStatus_t infiniopCreateTopkrouterDescriptor(infiniopHandle_t handle, infiniopTopkrouterDescriptor_t *desc_ptr,
+__INFINI_C infiniStatus_t infiniopCreateTopkrouterDescriptor(infiniopHandle_t handle, infiniopTopkrouterDescriptor_t *desc_ptr,
                                                       infiniopTensorDescriptor_t x_desc,
                                                       infiniopTensorDescriptor_t correction_bias_desc) {
 #define CREATE(CASE, NAMESPACE)                               \
@@ -49,7 +49,7 @@ __C infiniStatus_t infiniopCreateTopkrouterDescriptor(infiniopHandle_t handle, i
 #undef CREATE
 }
 
-__C infiniStatus_t infiniopGetTopkrouterWorkspaceSize(infiniopTopkrouterDescriptor_t desc, size_t *size) {
+__INFINI_C infiniStatus_t infiniopGetTopkrouterWorkspaceSize(infiniopTopkrouterDescriptor_t desc, size_t *size) {
 #define GET(CASE, NAMESPACE)                                                                      \
     case CASE:                                                                                    \
         *size = reinterpret_cast<op::topkrouter::NAMESPACE::Descriptor *>(desc)->workspaceSize(); \
@@ -81,7 +81,7 @@ __C infiniStatus_t infiniopGetTopkrouterWorkspaceSize(infiniopTopkrouterDescript
 #undef GET
 }
 
-__C infiniStatus_t infiniopTopkrouter(infiniopTopkrouterDescriptor_t desc, void *workspace, size_t workspace_size,
+__INFINI_C infiniStatus_t infiniopTopkrouter(infiniopTopkrouterDescriptor_t desc, void *workspace, size_t workspace_size,
                                       void *values, void *indices, const void *x, const void *correction_bias,
                                       const float routed_scaling_factor, const size_t topk, void *stream) {
 #define CALCULATE(CASE, NAMESPACE)                                                                                          \
@@ -116,7 +116,7 @@ __C infiniStatus_t infiniopTopkrouter(infiniopTopkrouterDescriptor_t desc, void
 #undef CALCULATE
 }
 
-__C infiniStatus_t infiniopDestroyTopkrouterDescriptor(infiniopTopkrouterDescriptor_t desc) {
+__INFINI_C infiniStatus_t infiniopDestroyTopkrouterDescriptor(infiniopTopkrouterDescriptor_t desc) {
 #define DESTROY(CASE, NAMESPACE)                                                \
     case CASE:                                                                  \
         delete reinterpret_cast<op::topkrouter::NAMESPACE::Descriptor *>(desc); \

src/infiniop/ops/topksoftmax/operator.cc

@@ -12,7 +12,7 @@
 #include "metax/topksoftmax_metax.cuh"
 #endif
 
-__C infiniStatus_t infiniopCreateTopksoftmaxDescriptor(infiniopHandle_t handle,
+__INFINI_C infiniStatus_t infiniopCreateTopksoftmaxDescriptor(infiniopHandle_t handle,
                                                        infiniopTopksoftmaxDescriptor_t *desc_ptr,
                                                        infiniopTensorDescriptor_t x_desc) {
 
@@ -47,7 +47,7 @@ __C infiniStatus_t infiniopCreateTopksoftmaxDescriptor(infiniopHandle_t handle,
 #undef CREATE
 }
 
-__C infiniStatus_t infiniopGetTopksoftmaxWorkspaceSize(infiniopTopksoftmaxDescriptor_t desc, size_t *size) {
+__INFINI_C infiniStatus_t infiniopGetTopksoftmaxWorkspaceSize(infiniopTopksoftmaxDescriptor_t desc, size_t *size) {
 
 #define GET(CASE, NAMESPACE)                                                                       \
     case CASE:                                                                                     \
@@ -80,7 +80,7 @@ __C infiniStatus_t infiniopGetTopksoftmaxWorkspaceSize(infiniopTopksoftmaxDescri
 #undef GET
 }
 
-__C infiniStatus_t infiniopTopksoftmax(infiniopTopksoftmaxDescriptor_t desc, void *workspace, size_t workspace_size,
+__INFINI_C infiniStatus_t infiniopTopksoftmax(infiniopTopksoftmaxDescriptor_t desc, void *workspace, size_t workspace_size,
                                        void *values, void *indices, const void *x, const size_t topk, const int norm,
                                        void *stream) {
     if (topk > 32) {
@@ -118,7 +118,7 @@ __C infiniStatus_t infiniopTopksoftmax(infiniopTopksoftmaxDescriptor_t desc, voi
 #undef CALCULATE
 }
 
-__C infiniStatus_t infiniopDestroyTopksoftmaxDescriptor(infiniopTopksoftmaxDescriptor_t desc) {
+__INFINI_C infiniStatus_t infiniopDestroyTopksoftmaxDescriptor(infiniopTopksoftmaxDescriptor_t desc) {
 
 #define DESTROY(CASE, NAMESPACE)                                                 \
     case CASE:                                                                   \

src/infiniop/ops/zeros/operator.cc

@@ -15,7 +15,7 @@
 #include "moore/zeros_moore.h"
 #endif
 
-__C infiniStatus_t infiniopCreateZerosDescriptor(
+__INFINI_C infiniStatus_t infiniopCreateZerosDescriptor(
     infiniopHandle_t handle,
     infiniopZerosDescriptor_t *desc_ptr,
     infiniopTensorDescriptor_t y_desc,
@@ -59,7 +59,7 @@ __C infiniStatus_t infiniopCreateZerosDescriptor(
 #undef CREATE
 }
 
-__C infiniStatus_t infiniopGetZerosWorkspaceSize(infiniopZerosDescriptor_t desc, size_t *size) {
+__INFINI_C infiniStatus_t infiniopGetZerosWorkspaceSize(infiniopZerosDescriptor_t desc, size_t *size) {
 
 #define GET(CASE, NAMESPACE)                                                                 \
     case CASE:                                                                               \
@@ -96,7 +96,7 @@ __C infiniStatus_t infiniopGetZerosWorkspaceSize(infiniopZerosDescriptor_t desc,
     return INFINI_STATUS_DEVICE_TYPE_NOT_SUPPORTED;
 }
 
-__C infiniStatus_t infiniopZeros(
+__INFINI_C infiniStatus_t infiniopZeros(
     infiniopZerosDescriptor_t desc,
     void *workspace,
     size_t workspace_size,
@@ -139,7 +139,7 @@ __C infiniStatus_t infiniopZeros(
 #undef CALCULATE
 }
 
-__C infiniStatus_t
+__INFINI_C infiniStatus_t
 infiniopDestroyZerosDescriptor(infiniopZerosDescriptor_t desc) {
 
 #define DELETE(CASE, NAMESPACE)                                                  \

src/infiniop/tensor_descriptor.cc

@@ -5,7 +5,7 @@
 #include <functional>
 #include <numeric>
 
-__C __export infiniStatus_t infiniopCreateTensorDescriptor(infiniopTensorDescriptor_t *desc_ptr, size_t ndim, size_t const *shape_, ptrdiff_t const *strides_, infiniDtype_t datatype) {
+__INFINI_C __export infiniStatus_t infiniopCreateTensorDescriptor(infiniopTensorDescriptor_t *desc_ptr, size_t ndim, size_t const *shape_, ptrdiff_t const *strides_, infiniDtype_t datatype) {
     if (strides_ != nullptr) {
         *desc_ptr = new InfiniopTensorDescriptor(datatype, ndim, shape_, strides_);
     } else {
@@ -23,7 +23,7 @@ __C __export infiniStatus_t infiniopCreateTensorDescriptor(infiniopTensorDescrip
     return INFINI_STATUS_SUCCESS;
 }
 
-__C __export infiniStatus_t infiniopDestroyTensorDescriptor(infiniopTensorDescriptor_t desc) {
+__INFINI_C __export infiniStatus_t infiniopDestroyTensorDescriptor(infiniopTensorDescriptor_t desc) {
     delete desc;
     return INFINI_STATUS_SUCCESS;
 }

src/infinirt/infinirt.cc

@@ -13,14 +13,14 @@ thread_local int CURRENT_DEVICE_ID = 0;
 thread_local infiniDevice_t PREVIOUS_NON_CPU_DEVICE_TYPE = INFINI_DEVICE_TYPE_COUNT;
 thread_local int PREVIOUS_NON_CPU_DEVICE_ID = 0;
 
-__C infiniStatus_t infinirtInit() {
+__INFINI_C infiniStatus_t infinirtInit() {
 #ifdef ENABLE_ASCEND_API
     CHECK_STATUS(infinirt::ascend::init());
 #endif
     return INFINI_STATUS_SUCCESS;
 }
 
-__C infiniStatus_t infinirtGetAllDeviceCount(int *count_array) {
+__INFINI_C infiniStatus_t infinirtGetAllDeviceCount(int *count_array) {
     if (count_array == nullptr) {
         return INFINI_STATUS_NULL_POINTER;
     }
@@ -33,7 +33,7 @@ __C infiniStatus_t infinirtGetAllDeviceCount(int *count_array) {
     return INFINI_STATUS_SUCCESS;
 }
 
-__C infiniStatus_t infinirtGetDevice(infiniDevice_t *device_ptr, int *device_id_ptr) {
+__INFINI_C infiniStatus_t infinirtGetDevice(infiniDevice_t *device_ptr, int *device_id_ptr) {
     if (device_ptr == nullptr && device_id_ptr == nullptr) {
         return INFINI_STATUS_NULL_POINTER;
     }
@@ -93,14 +93,14 @@ __C infiniStatus_t infinirtGetDevice(infiniDevice_t *device_ptr, int *device_id_
 
 #define INFINIRT_CALL_DEVICE_API(API, PARAMS) INFINIRT_CALL_DEVICE_API_AND(CURRENT_DEVICE_TYPE, API, PARAMS, )
 
-__C infiniStatus_t infinirtGetDeviceCount(infiniDevice_t device, int *count) {
+__INFINI_C infiniStatus_t infinirtGetDeviceCount(infiniDevice_t device, int *count) {
     if (count == nullptr) {
         return INFINI_STATUS_NULL_POINTER;
     }
     INFINIRT_CALL_DEVICE_API_AND(device, getDeviceCount, (count), {});
 }
 
-__C infiniStatus_t infinirtSetDevice(infiniDevice_t device, int device_id) {
+__INFINI_C infiniStatus_t infinirtSetDevice(infiniDevice_t device, int device_id) {
     bool skip_set = CURRENT_DEVICE_TYPE == INFINI_DEVICE_CPU && device == PREVIOUS_NON_CPU_DEVICE_TYPE && device_id == PREVIOUS_NON_CPU_DEVICE_ID;
     if (CURRENT_DEVICE_TYPE != INFINI_DEVICE_CPU) {
         PREVIOUS_NON_CPU_DEVICE_TYPE = CURRENT_DEVICE_TYPE;
@@ -116,99 +116,99 @@ __C infiniStatus_t infinirtSetDevice(infiniDevice_t device, int device_id) {
                                    CURRENT_DEVICE_ID = device_id; });
 }
 
-__C infiniStatus_t infinirtDeviceSynchronize() {
+__INFINI_C infiniStatus_t infinirtDeviceSynchronize() {
     INFINIRT_CALL_DEVICE_API(deviceSynchronize, ());
 }
 
-__C infiniStatus_t infinirtStreamCreate(infinirtStream_t *stream_ptr) {
+__INFINI_C infiniStatus_t infinirtStreamCreate(infinirtStream_t *stream_ptr) {
     INFINIRT_CALL_DEVICE_API(streamCreate, (stream_ptr));
 }
 
-__C infiniStatus_t infinirtStreamDestroy(infinirtStream_t stream) {
+__INFINI_C infiniStatus_t infinirtStreamDestroy(infinirtStream_t stream) {
     INFINIRT_CALL_DEVICE_API(streamDestroy, (stream));
 }
 
-__C infiniStatus_t infinirtStreamSynchronize(infinirtStream_t stream) {
+__INFINI_C infiniStatus_t infinirtStreamSynchronize(infinirtStream_t stream) {
     INFINIRT_CALL_DEVICE_API(streamSynchronize, (stream));
 }
 
-__C infiniStatus_t infinirtStreamWaitEvent(infinirtStream_t stream, infinirtEvent_t event) {
+__INFINI_C infiniStatus_t infinirtStreamWaitEvent(infinirtStream_t stream, infinirtEvent_t event) {
     INFINIRT_CALL_DEVICE_API(streamWaitEvent, (stream, event));
 }
 
-__C infiniStatus_t infinirtEventCreate(infinirtEvent_t *event_ptr) {
+__INFINI_C infiniStatus_t infinirtEventCreate(infinirtEvent_t *event_ptr) {
     INFINIRT_CALL_DEVICE_API(eventCreate, (event_ptr));
 }
 
-__C infiniStatus_t infinirtEventCreateWithFlags(infinirtEvent_t *event_ptr, uint32_t flags) {
+__INFINI_C infiniStatus_t infinirtEventCreateWithFlags(infinirtEvent_t *event_ptr, uint32_t flags) {
     INFINIRT_CALL_DEVICE_API(eventCreateWithFlags, (event_ptr, flags));
 }
 
-__C infiniStatus_t infinirtEventRecord(infinirtEvent_t event, infinirtStream_t stream) {
+__INFINI_C infiniStatus_t infinirtEventRecord(infinirtEvent_t event, infinirtStream_t stream) {
     INFINIRT_CALL_DEVICE_API(eventRecord, (event, stream));
 }
 
-__C infiniStatus_t infinirtEventQuery(infinirtEvent_t event, infinirtEventStatus_t *status_ptr) {
+__INFINI_C infiniStatus_t infinirtEventQuery(infinirtEvent_t event, infinirtEventStatus_t *status_ptr) {
     INFINIRT_CALL_DEVICE_API(eventQuery, (event, status_ptr));
 }
 
-__C infiniStatus_t infinirtEventSynchronize(infinirtEvent_t event) {
+__INFINI_C infiniStatus_t infinirtEventSynchronize(infinirtEvent_t event) {
     INFINIRT_CALL_DEVICE_API(eventSynchronize, (event));
 }
 
-__C infiniStatus_t infinirtEventDestroy(infinirtEvent_t event) {
+__INFINI_C infiniStatus_t infinirtEventDestroy(infinirtEvent_t event) {
     INFINIRT_CALL_DEVICE_API(eventDestroy, (event));
 }
 
-__C infiniStatus_t infinirtEventElapsedTime(float *ms_ptr, infinirtEvent_t start, infinirtEvent_t end) {
+__INFINI_C infiniStatus_t infinirtEventElapsedTime(float *ms_ptr, infinirtEvent_t start, infinirtEvent_t end) {
     INFINIRT_CALL_DEVICE_API(eventElapsedTime, (ms_ptr, start, end));
 }
 
-__C infiniStatus_t infinirtMalloc(void **p_ptr, size_t size) {
+__INFINI_C infiniStatus_t infinirtMalloc(void **p_ptr, size_t size) {
     INFINIRT_CALL_DEVICE_API(mallocDevice, (p_ptr, size));
 }
 
-__C infiniStatus_t infinirtMallocHost(void **p_ptr, size_t size) {
+__INFINI_C infiniStatus_t infinirtMallocHost(void **p_ptr, size_t size) {
     INFINIRT_CALL_DEVICE_API(mallocHost, (p_ptr, size));
 }
 
-__C infiniStatus_t infinirtFree(void *ptr) {
+__INFINI_C infiniStatus_t infinirtFree(void *ptr) {
     INFINIRT_CALL_DEVICE_API(freeDevice, (ptr));
 }
 
-__C infiniStatus_t infinirtFreeHost(void *ptr) {
+__INFINI_C infiniStatus_t infinirtFreeHost(void *ptr) {
     INFINIRT_CALL_DEVICE_API(freeHost, (ptr));
 }
 
-__C infiniStatus_t infinirtMemcpy(void *dst, const void *src, size_t size, infinirtMemcpyKind_t kind) {
+__INFINI_C infiniStatus_t infinirtMemcpy(void *dst, const void *src, size_t size, infinirtMemcpyKind_t kind) {
     INFINIRT_CALL_DEVICE_API(memcpy, (dst, src, size, kind));
 }
 
-__C infiniStatus_t infinirtMemcpyAsync(void *dst, const void *src, size_t size, infinirtMemcpyKind_t kind, infinirtStream_t stream) {
+__INFINI_C infiniStatus_t infinirtMemcpyAsync(void *dst, const void *src, size_t size, infinirtMemcpyKind_t kind, infinirtStream_t stream) {
     INFINIRT_CALL_DEVICE_API(memcpyAsync, (dst, src, size, kind, stream));
 }
 
-__C infiniStatus_t infinirtMallocAsync(void **p_ptr, size_t size, infinirtStream_t stream) {
+__INFINI_C infiniStatus_t infinirtMallocAsync(void **p_ptr, size_t size, infinirtStream_t stream) {
     INFINIRT_CALL_DEVICE_API(mallocAsync, (p_ptr, size, stream));
 }
 
-__C infiniStatus_t infinirtFreeAsync(void *ptr, infinirtStream_t stream) {
+__INFINI_C infiniStatus_t infinirtFreeAsync(void *ptr, infinirtStream_t stream) {
     INFINIRT_CALL_DEVICE_API(freeAsync, (ptr, stream));
 }
 
-__C infiniStatus_t infinirtStreamBeginCapture(infinirtStream_t stream, infinirtStreamCaptureMode_t mode) {
+__INFINI_C infiniStatus_t infinirtStreamBeginCapture(infinirtStream_t stream, infinirtStreamCaptureMode_t mode) {
     INFINIRT_CALL_DEVICE_API(streamBeginCapture, (stream, mode));
 }
 
-__C infiniStatus_t infinirtStreamEndCapture(infinirtStream_t stream, infinirtGraph_t *graph_ptr) {
+__INFINI_C infiniStatus_t infinirtStreamEndCapture(infinirtStream_t stream, infinirtGraph_t *graph_ptr) {
     INFINIRT_CALL_DEVICE_API(streamEndCapture, (stream, graph_ptr));
 }
 
-__C infiniStatus_t infinirtGraphDestroy(infinirtGraph_t graph) {
+__INFINI_C infiniStatus_t infinirtGraphDestroy(infinirtGraph_t graph) {
     INFINIRT_CALL_DEVICE_API(graphDestroy, (graph));
 }
 
-__C infiniStatus_t infinirtGraphInstantiate(
+__INFINI_C infiniStatus_t infinirtGraphInstantiate(
     infinirtGraphExec_t *graph_exec_ptr,
     infinirtGraph_t graph,
     infinirtGraphNode_t *node_ptr,
@@ -217,10 +217,10 @@ __C infiniStatus_t infinirtGraphInstantiate(
     INFINIRT_CALL_DEVICE_API(graphInstantiate, (graph_exec_ptr, graph, node_ptr, log_buffer, buffer_size));
 }
 
-__C infiniStatus_t infinirtGraphExecDestroy(infinirtGraphExec_t graph_exec) {
+__INFINI_C infiniStatus_t infinirtGraphExecDestroy(infinirtGraphExec_t graph_exec) {
     INFINIRT_CALL_DEVICE_API(graphExecDestroy, (graph_exec));
 }
 
-__C infiniStatus_t infinirtGraphLuanch(infinirtGraphExec_t graph_exec, infinirtStream_t stream) {
+__INFINI_C infiniStatus_t infinirtGraphLuanch(infinirtGraphExec_t graph_exec, infinirtStream_t stream) {
     INFINIRT_CALL_DEVICE_API(graphLuanch, (graph_exec, stream));
 }