Issue/888 - 算子比赛遗留算子迁移

include/infiniop/ops/averagepool.h

@@ -0,0 +1,29 @@
+#ifndef __INFINIOP_AVERAGEPOOL_H__
+#define __INFINIOP_AVERAGEPOOL_H__
+
+#include "../operator_descriptor.h"
+
+__C typedef struct InfiniopDescriptor *infiniopAvgPoolDescriptor_t;
+
+__C infiniStatus_t infiniopCreateAvgPoolDescriptor(infiniopHandle_t handle,
+                                                   infiniopAvgPoolDescriptor_t *desc_ptr,
+                                                   infiniopTensorDescriptor_t output_desc,
+                                                   infiniopTensorDescriptor_t input_desc,
+                                                   void *kernel_size,
+                                                   void *strides,
+                                                   void *pads,
+                                                   bool ceil_mode);
+
+__C infiniStatus_t infiniopGetAvgPoolWorkspaceSize(infiniopAvgPoolDescriptor_t desc,
+                                                   size_t *size);
+
+__C infiniStatus_t infiniopAvgPool(infiniopAvgPoolDescriptor_t desc,
+                                   void *workspace,
+                                   size_t workspace_size,
+                                   void *output,
+                                   const void *input,
+                                   void *stream);
+
+__C infiniStatus_t infiniopDestroyAvgPoolDescriptor(infiniopAvgPoolDescriptor_t desc);
+
+#endif // __INFINIOP_AVERAGEPOOL_H__

include/infiniop/ops/batch_norm.h

@@ -0,0 +1,37 @@
+#ifndef __INFINIOP_BATCH_NORM_API_H__
+#define __INFINIOP_BATCH_NORM_API_H__
+
+#include "../operator_descriptor.h"
+
+typedef struct InfiniopDescriptor *infiniopBatchNormDescriptor_t;
+
+__C __export infiniStatus_t infiniopCreateBatchNormDescriptor(
+    infiniopHandle_t handle,
+    infiniopBatchNormDescriptor_t *desc_ptr,
+	infiniopTensorDescriptor_t output_desc,
+	infiniopTensorDescriptor_t running_mean_desc,
+	infiniopTensorDescriptor_t running_var_desc,
+	infiniopTensorDescriptor_t input_desc,
+	infiniopTensorDescriptor_t weight_desc,
+	infiniopTensorDescriptor_t bias_desc,
+	float momentum,
+	float eps
+);
+
+__C __export infiniStatus_t infiniopGetBatchNormWorkspaceSize(infiniopBatchNormDescriptor_t desc, size_t *size);
+
+__C __export infiniStatus_t infiniopBatchNorm(infiniopBatchNormDescriptor_t desc,
+    void *workspace,
+    size_t workspace_size,
+	void * output,
+	void * running_mean,
+	void * running_var,
+	const void * input,
+	const void * weight,
+	const void * bias,
+    void *stream
+);
+
+__C __export infiniStatus_t infiniopDestroyBatchNormDescriptor(infiniopBatchNormDescriptor_t desc);
+
+#endif

include/infiniop/ops/cross_entropy_loss.h

@@ -0,0 +1,27 @@
+#ifndef __INFINIOP_CROSS_ENTROPY_LOSS_API_H__
+#define __INFINIOP_CROSS_ENTROPY_LOSS_API_H__
+
+#include "../operator_descriptor.h"
+
+typedef struct InfiniopDescriptor *infiniopCrossEntropyLossDescriptor_t;
+
+__C infiniStatus_t infiniopCreateCrossEntropyLossDescriptor(infiniopHandle_t handle,
+                                                            infiniopCrossEntropyLossDescriptor_t *desc_ptr,
+                                                            infiniopTensorDescriptor_t loss_desc,
+                                                            infiniopTensorDescriptor_t logits_desc,
+                                                            infiniopTensorDescriptor_t target_desc);
+
+__C infiniStatus_t infiniopGetCrossEntropyLossWorkspaceSize(infiniopCrossEntropyLossDescriptor_t desc,
+                                                            size_t *size);
+
+__C infiniStatus_t infiniopCrossEntropyLoss(infiniopCrossEntropyLossDescriptor_t desc,
+                                            void *workspace,
+                                            size_t workspace_size,
+                                            void *loss,
+                                            const void *logits,
+                                            const void *target,
+                                            void *stream);
+
+__C infiniStatus_t infiniopDestroyCrossEntropyLossDescriptor(infiniopCrossEntropyLossDescriptor_t desc);
+
+#endif // __INFINIOP_CROSS_ENTROPY_LOSS_API_H__

include/infiniop/ops/exp.h

@@ -0,0 +1,24 @@
+#ifndef __INFINIOP_EXP_API_H__
+#define __INFINIOP_EXP_API_H__
+
+#include "../operator_descriptor.h"
+
+typedef struct InfiniopDescriptor *infiniopExpDescriptor_t;
+
+__C __export infiniStatus_t infiniopCreateExpDescriptor(infiniopHandle_t handle,
+                                                        infiniopExpDescriptor_t *desc_ptr,
+                                                        infiniopTensorDescriptor_t output,
+                                                        infiniopTensorDescriptor_t input);
+
+__C __export infiniStatus_t infiniopGetExpWorkspaceSize(infiniopExpDescriptor_t desc, size_t *size);
+
+__C __export infiniStatus_t infiniopExp(infiniopExpDescriptor_t desc,
+                                        void *workspace,
+                                        size_t workspace_size,
+                                        void *output,
+                                        const void *input,
+                                        void *stream);
+
+__C __export infiniStatus_t infiniopDestroyExpDescriptor(infiniopExpDescriptor_t desc);
+
+#endif

include/infiniop/ops/gather.h

@@ -0,0 +1,31 @@
+#ifndef __INFINIOP_GATHER_API_H__
+#define __INFINIOP_GATHER_API_H__
+
+#include "../operator_descriptor.h"
+
+typedef struct InfiniopDescriptor *infiniopGatherDescriptor_t;
+
+__C __export infiniStatus_t infiniopCreateGatherDescriptor(
+    infiniopHandle_t handle,
+    infiniopGatherDescriptor_t *desc_ptr,
+    infiniopTensorDescriptor_t output_desc,
+    infiniopTensorDescriptor_t input_desc,
+    infiniopTensorDescriptor_t index_desc,
+    size_t dim
+);
+
+__C __export infiniStatus_t infiniopGetGatherWorkspaceSize(infiniopGatherDescriptor_t desc, size_t *size);
+
+__C __export infiniStatus_t infiniopGather(
+    infiniopGatherDescriptor_t desc,
+    void *workspace,
+    size_t workspace_size,
+    void * output,
+    const void * input,
+    const void * index,
+    void *stream
+);
+
+__C __export infiniStatus_t infiniopDestroyGatherDescriptor(infiniopGatherDescriptor_t desc);
+
+#endif

include/infiniop/ops/hardswish.h

@@ -0,0 +1,24 @@
+#ifndef __INFINIOP_HARDSWISH_API_H__
+#define __INFINIOP_HARDSWISH_API_H__
+
+#include "../operator_descriptor.h"
+
+typedef struct InfiniopDescriptor *infiniopHardswishDescriptor_t;
+
+__C __export infiniStatus_t infiniopCreateHardswishDescriptor(infiniopHandle_t handle,
+                                                              infiniopHardswishDescriptor_t *desc_ptr,
+                                                              infiniopTensorDescriptor_t output,
+                                                              infiniopTensorDescriptor_t input);
+
+__C __export infiniStatus_t infiniopGetHardswishWorkspaceSize(infiniopHardswishDescriptor_t desc, size_t *size);
+
+__C __export infiniStatus_t infiniopHardswish(infiniopHardswishDescriptor_t desc,
+                                              void *workspace,
+                                              size_t workspace_size,
+                                              void *output,
+                                              const void *input,
+                                              void *stream);
+
+__C __export infiniStatus_t infiniopDestroyHardswishDescriptor(infiniopHardswishDescriptor_t desc);
+
+#endif

include/infiniop/ops/index_copy_inplace.h

@@ -0,0 +1,30 @@
+#ifndef __INFINIOP_INDEX_COPY_INPLACE_API_H__
+#define __INFINIOP_INDEX_COPY_INPLACE_API_H__
+
+#include "../operator_descriptor.h"
+
+typedef struct InfiniopDescriptor *infiniopIndexCopyInplaceDescriptor_t;
+
+__C __export infiniStatus_t infiniopCreateIndexCopyInplaceDescriptor(
+    infiniopHandle_t handle,
+    infiniopIndexCopyInplaceDescriptor_t *desc_ptr,
+	infiniopTensorDescriptor_t output_desc,
+	infiniopTensorDescriptor_t input_desc,
+	infiniopTensorDescriptor_t index_desc,
+	size_t dim
+);
+
+__C __export infiniStatus_t infiniopGetIndexCopyInplaceWorkspaceSize(infiniopIndexCopyInplaceDescriptor_t desc, size_t *size);
+
+__C __export infiniStatus_t infiniopIndexCopyInplace(infiniopIndexCopyInplaceDescriptor_t desc,
+    void *workspace,
+    size_t workspace_size,
+	void * output,
+	const void * input,
+	const void * index,
+    void *stream
+);
+
+__C __export infiniStatus_t infiniopDestroyIndexCopyInplaceDescriptor(infiniopIndexCopyInplaceDescriptor_t desc);
+
+#endif

include/infiniop/ops/interpolate_nearest.h

@@ -0,0 +1,25 @@
+#ifndef __INFINIOP_INTERPOLATE_NEAREST_H__
+#define __INFINIOP_INTERPOLATE_NEAREST_H__
+
+#include "../operator_descriptor.h"
+
+__C typedef struct InfiniopDescriptor *infiniopInterpolateNearestDescriptor_t;
+
+__C infiniStatus_t infiniopCreateInterpolateNearestDescriptor(infiniopHandle_t handle,
+                                                              infiniopInterpolateNearestDescriptor_t *desc_ptr,
+                                                              infiniopTensorDescriptor_t output_desc,
+                                                              infiniopTensorDescriptor_t input_desc);
+
+__C infiniStatus_t infiniopGetInterpolateNearestWorkspaceSize(infiniopInterpolateNearestDescriptor_t desc,
+                                                              size_t *size);
+
+__C infiniStatus_t infiniopInterpolateNearest(infiniopInterpolateNearestDescriptor_t desc,
+                                              void *workspace,
+                                              size_t workspace_size,
+                                              void *output,
+                                              const void *input,
+                                              void *stream);
+
+__C infiniStatus_t infiniopDestroyInterpolateNearestDescriptor(infiniopInterpolateNearestDescriptor_t desc);
+
+#endif // __INFINIOP_INTERPOLATE_NEAREST_H__

include/infiniop/ops/maxpool.h

@@ -0,0 +1,29 @@
+#ifndef __INFINIOP_MAX_POOL_H__
+#define __INFINIOP_MAX_POOL_H__
+
+#include "../operator_descriptor.h"
+
+__C typedef struct InfiniopDescriptor *infiniopMaxPoolDescriptor_t;
+
+__C infiniStatus_t infiniopCreateMaxPoolDescriptor(infiniopHandle_t handle,
+                                                   infiniopMaxPoolDescriptor_t *desc_ptr,
+                                                   infiniopTensorDescriptor_t output_desc,
+                                                   infiniopTensorDescriptor_t input_desc,
+                                                   void *kernel_size,
+                                                   void *strides,
+                                                   void *pads,
+                                                   bool ceil_mode);
+
+__C infiniStatus_t infiniopGetMaxPoolWorkspaceSize(infiniopMaxPoolDescriptor_t desc,
+                                                   size_t *size);
+
+__C infiniStatus_t infiniopMaxPool(infiniopMaxPoolDescriptor_t desc,
+                                   void *workspace,
+                                   size_t workspace_size,
+                                   void *output,
+                                   const void *input,
+                                   void *stream);
+
+__C infiniStatus_t infiniopDestroyMaxPoolDescriptor(infiniopMaxPoolDescriptor_t desc);
+
+#endif // __INFINIOP_MAX_POOL_H__

include/infiniop/ops/scatter.h

@@ -0,0 +1,30 @@
+#ifndef __INFINIOP_SCATTER_API_H__
+#define __INFINIOP_SCATTER_API_H__
+
+#include "../operator_descriptor.h"
+
+typedef struct InfiniopDescriptor *infiniopScatterDescriptor_t;
+
+__C __export infiniStatus_t infiniopCreateScatterDescriptor(
+    infiniopHandle_t handle,
+    infiniopScatterDescriptor_t *desc_ptr,
+	infiniopTensorDescriptor_t output_desc,
+	infiniopTensorDescriptor_t input_desc,
+	infiniopTensorDescriptor_t index_desc,
+	size_t dim
+);
+
+__C __export infiniStatus_t infiniopGetScatterWorkspaceSize(infiniopScatterDescriptor_t desc, size_t *size);
+
+__C __export infiniStatus_t infiniopScatter(infiniopScatterDescriptor_t desc,
+    void *workspace,
+    size_t workspace_size,
+	void * output,
+	const void * input,
+	const void * index,
+    void *stream
+);
+
+__C __export infiniStatus_t infiniopDestroyScatterDescriptor(infiniopScatterDescriptor_t desc);
+
+#endif

src/infiniop/ops/averagepool/averagepool.h

@@ -0,0 +1,52 @@
+#ifndef __AVERAGEPOOL_H__
+#define __AVERAGEPOOL_H__
+
+#include "../../operator.h"
+#include "info.h"
+
+#define DESCRIPTOR(NAMESPACE)                                    \
+    namespace op::averagepool::NAMESPACE {                       \
+    class Descriptor final : public InfiniopDescriptor {         \
+        struct Opaque;                                           \
+        Opaque *_opaque;                                         \
+        infiniDtype_t _dtype;                                    \
+        AvgPoolInfo _info;                                       \
+        size_t _workspace_size;                                  \
+                                                                 \
+        Descriptor(                                              \
+            infiniDtype_t dtype,                                 \
+            AvgPoolInfo info,                                    \
+            size_t workspace_size_,                              \
+            Opaque *opaque,                                      \
+            infiniDevice_t device_type,                          \
+            int device_id)                                       \
+            : InfiniopDescriptor{device_type, device_id},        \
+              _opaque(opaque),                                   \
+              _dtype(dtype),                                     \
+              _info(info),                                       \
+              _workspace_size(workspace_size_) {}                \
+                                                                 \
+    public:                                                      \
+        ~Descriptor();                                           \
+                                                                 \
+        size_t workspaceSize() const { return _workspace_size; } \
+                                                                 \
+        static infiniStatus_t create(                            \
+            infiniopHandle_t handle,                             \
+            Descriptor **desc_ptr,                               \
+            infiniopTensorDescriptor_t output_desc,              \
+            infiniopTensorDescriptor_t input_desc,               \
+            void *kernel_size,                                   \
+            void *strides,                                       \
+            void *pads,                                          \
+            bool ceil_mode);                                     \
+                                                                 \
+        infiniStatus_t calculate(                                \
+            void *workspace, size_t workspace_size,              \
+            void *output,                                        \
+            const void *input,                                   \
+            void *stream) const;                                 \
+    };                                                           \
+    }
+
+#endif // __AVERAGEPOOL_H__