Merge pull request #1056 from InfiniTensor/issue/1031

【算子比赛2025秋】T1-1-9 & T1-1-17

include/infinicore/ops.hpp

 #pragma once
 
+#include "ops/adaptive_max_pool1d.hpp"
 #include "ops/add.hpp"
 #include "ops/add_rms_norm.hpp"
+#include "ops/asinh.hpp"
 #include "ops/attention.hpp"
+#include "ops/avg_pool1d.hpp"
+#include "ops/baddbmm.hpp"
+#include "ops/bilinear.hpp"
 #include "ops/causal_softmax.hpp"
+#include "ops/cross_entropy.hpp"
 #include "ops/embedding.hpp"
 #include "ops/flash_attention.hpp"
+#include "ops/fmod.hpp"
+#include "ops/hardswish.hpp"
+#include "ops/hardtanh.hpp"
 #include "ops/kv_caching.hpp"
 #include "ops/matmul.hpp"
 #include "ops/ones.hpp"

include/infinicore/ops/adaptive_max_pool1d.hpp

+#pragma once
+
+#include "../device.hpp"
+#include "common/op.hpp"
+
+namespace infinicore::op {
+class AdaptiveMaxPool1d {
+public:
+    using schema = void (*)(Tensor, Tensor, size_t);
+    static void execute(Tensor y, Tensor x, size_t output_size);
+    static common::OpDispatcher<schema> &dispatcher();
+};
+
+Tensor adaptive_max_pool1d(Tensor x, size_t output_size);
+void adaptive_max_pool1d_(Tensor y, Tensor x, size_t output_size);
+} // namespace infinicore::op

include/infinicore/ops/asinh.hpp

+#pragma once
+
+#include "../device.hpp"
+#include "common/op.hpp"
+
+namespace infinicore::op {
+class Asinh {
+public:
+    using schema = void (*)(Tensor, Tensor);
+    static void execute(Tensor y, Tensor x);
+    static common::OpDispatcher<schema> &dispatcher();
+};
+
+Tensor asinh(Tensor x);
+void asinh_(Tensor y, Tensor x);
+} // namespace infinicore::op

include/infinicore/ops/avg_pool1d.hpp

+#pragma once
+
+#include "../device.hpp"
+#include "common/op.hpp"
+
+namespace infinicore::op {
+
+class AvgPool1d {
+public:
+    using schema = void (*)(Tensor, Tensor, size_t, size_t, size_t);
+    static void execute(Tensor output, Tensor input, size_t kernel_size, size_t stride, size_t padding);
+    static common::OpDispatcher<schema> &dispatcher();
+};
+
+Tensor avg_pool1d(Tensor input, size_t kernel_size, size_t stride = 0, size_t padding = 0);
+void avg_pool1d_(Tensor output, Tensor input, size_t kernel_size, size_t stride = 0, size_t padding = 0);
+
+} // namespace infinicore::op

include/infinicore/ops/baddbmm.hpp

+#pragma once
+
+#include "../device.hpp"
+#include "common/op.hpp"
+#include <optional>
+
+namespace infinicore::op {
+
+Tensor baddbmm(Tensor input, Tensor batch1, Tensor batch2,
+               float beta = 1.0f,
+               float alpha = 1.0f);
+void baddbmm_(Tensor out, Tensor input, Tensor batch1, Tensor batch2,
+              float beta = 1.0f,
+              float alpha = 1.0f);
+} // namespace infinicore::op

include/infinicore/ops/bilinear.hpp

+#pragma once
+
+#include "../device.hpp"
+#include "common/op.hpp"
+#include <optional>
+
+namespace infinicore::op {
+
+Tensor bilinear(Tensor x1, Tensor x2, Tensor weight, std::optional<Tensor> bias);
+void bilinear_(Tensor out, Tensor x1, Tensor x2, Tensor weight, std::optional<Tensor> bias);
+
+} // namespace infinicore::op

include/infinicore/ops/cross_entropy.hpp

+#pragma once
+
+#include "../device.hpp"
+#include "common/op.hpp"
+
+namespace infinicore::op {
+
+class CrossEntropy {
+public:
+    // Schema 定义：函数指针类型
+    // CrossEntropy 需要接收三个 Tensor: Output (Loss), Input (Logits), Target (Labels)
+    using schema = void (*)(Tensor, Tensor, Tensor);
+
+    // 执行入口
+    static void execute(Tensor output, Tensor input, Tensor target);
+
+    // 分发器访问接口
+    static common::OpDispatcher<schema> &dispatcher();
+};
+
+// ==================================================================
+// 对外 Functional API
+// ==================================================================
+
+// 1. Out-of-place 接口：
+// 输入 Logits 和 Target，内部自动创建 Output Tensor 并返回
+Tensor cross_entropy(Tensor input, Tensor target);
+
+// 2. Explicit Output 接口 (类似于 In-place 风格)：
+// 用户显式提供 Output Tensor 用于存储结果
+// 注意：虽然命名带有下划线 _，但通常 CrossEntropy 无法真正原地修改 input，
+// 所以这里只是表示“写入指定的 output 内存”
+void cross_entropy_(Tensor output, Tensor input, Tensor target);
+
+} // namespace infinicore::op

include/infinicore/ops/equal.hpp

+#pragma once
+
+#include "../device.hpp"
+#include "common/op.hpp"
+
+namespace infinicore::op {
+
+class Equal {
+public:
+    using schema = void (*)(Tensor, Tensor, Tensor);
+
+    static void execute(Tensor out, Tensor a, Tensor b);
+    static common::OpDispatcher<schema> &dispatcher();
+};
+
+Tensor equal(Tensor a, Tensor b);
+void equal_(Tensor out, Tensor a, Tensor b);
+
+} // namespace infinicore::op

include/infinicore/ops/fmod.hpp

+#pragma once
+
+#include "../device.hpp"
+#include "common/op.hpp"
+
+namespace infinicore::op {
+class Fmod {
+public:
+    using schema = void (*)(Tensor, Tensor, Tensor);
+    static void execute(Tensor c, Tensor a, Tensor b);
+    static common::OpDispatcher<schema> &dispatcher();
+};
+
+Tensor fmod(Tensor a, Tensor b);
+void fmod_(Tensor c, Tensor a, Tensor b);
+} // namespace infinicore::op

include/infinicore/ops/hardswish.hpp

+#pragma once
+
+#include "../device.hpp"
+#include "common/op.hpp"
+
+namespace infinicore::op {
+
+class Hardswish {
+public:
+    using schema = void (*)(Tensor, Tensor);
+    static void execute(Tensor output, Tensor input);
+    static common::OpDispatcher<schema> &dispatcher();
+};
+
+Tensor hardswish(Tensor input);
+void hardswish_(Tensor output, Tensor input);
+
+} // namespace infinicore::op

include/infinicore/ops/hardtanh.hpp

+#pragma once
+
+#include "../device.hpp"
+#include "common/op.hpp"
+
+namespace infinicore::op {
+
+class HardTanh {
+public:
+    using schema = void (*)(Tensor, Tensor, float, float);
+    static void execute(Tensor output, Tensor input, float min_val, float max_val);
+    static common::OpDispatcher<schema> &dispatcher();
+};
+
+Tensor hardtanh(Tensor input, float min_val = -1.0f, float max_val = 1.0f);
+void hardtanh_(Tensor output, Tensor input, float min_val = -1.0f, float max_val = 1.0f);
+
+} // namespace infinicore::op

include/infiniop.h

@@ -2,8 +2,10 @@
 #define __INFINIOP_API_H__
 
 #include "infiniop/handle.h"
+#include "infiniop/ops/adaptive_max_pool1d.h"
 #include "infiniop/ops/add.h"
 #include "infiniop/ops/add_rms_norm.h"
+#include "infiniop/ops/asinh.h"
 #include "infiniop/ops/attention.h"
 #include "infiniop/ops/causal_softmax.h"
 #include "infiniop/ops/clip.h"
@@ -11,6 +13,7 @@
 #include "infiniop/ops/dequantize_awq.h"
 #include "infiniop/ops/embedding.h"
 #include "infiniop/ops/flash_attention.h"
+#include "infiniop/ops/fmod.h"
 #include "infiniop/ops/gelu.h"
 #include "infiniop/ops/gemm.h"
 #include "infiniop/ops/int8_gemm.h"
@@ -42,4 +45,10 @@
 #include "infiniop/ops/zeros.h"
 #include "infiniop/tensor_descriptor.h"
 
+#include "infiniop/ops/cross_entropy.h"
+#include "infiniop/ops/hardswish.h"
+#include "infiniop/ops/avg_pool1d.h"
+#include "infiniop/ops/equal.h"
+#include "infiniop/ops/hardtanh.h"
+
 #endif // __INFINIOP_API_H__

include/infiniop/ops/adaptive_max_pool1d.h

+#ifndef __INFINIOP_ADAPTIVE_MAX_POOL1D_H__
+#define __INFINIOP_ADAPTIVE_MAX_POOL1D_H__
+
+#include "../operator_descriptor.h"
+
+typedef struct InfiniopDescriptor *infiniopAdaptiveMaxPool1dDescriptor_t;
+
+__INFINI_C __export infiniStatus_t infiniopCreateAdaptiveMaxPool1dDescriptor(
+    infiniopHandle_t handle,
+    infiniopAdaptiveMaxPool1dDescriptor_t *desc,
+    infiniopTensorDescriptor_t y_desc,
+    infiniopTensorDescriptor_t x_desc,
+    size_t output_size);
+
+__INFINI_C __export infiniStatus_t infiniopGetAdaptiveMaxPool1dWorkspaceSize(infiniopAdaptiveMaxPool1dDescriptor_t desc, size_t *size);
+
+__INFINI_C __export infiniStatus_t infiniopAdaptiveMaxPool1d(infiniopAdaptiveMaxPool1dDescriptor_t desc, void *workspace, size_t workspace_size,
+                                                             void *y, const void *x, void *stream);
+
+__INFINI_C __export infiniStatus_t infiniopDestroyAdaptiveMaxPool1dDescriptor(infiniopAdaptiveMaxPool1dDescriptor_t desc);
+
+#endif

include/infiniop/ops/asinh.h

+#ifndef __INFINIOP_ASINH_API_H__
+#define __INFINIOP_ASINH_API_H__
+
+#include "../operator_descriptor.h"
+
+typedef struct InfiniopDescriptor *infiniopAsinhDescriptor_t;
+
+__INFINI_C __export infiniStatus_t infiniopCreateAsinhDescriptor(infiniopHandle_t handle,
+                                                                 infiniopAsinhDescriptor_t *desc_ptr,
+                                                                 infiniopTensorDescriptor_t y,
+                                                                 infiniopTensorDescriptor_t x);
+
+__INFINI_C __export infiniStatus_t infiniopGetAsinhWorkspaceSize(infiniopAsinhDescriptor_t desc, size_t *size);
+
+__INFINI_C __export infiniStatus_t infiniopAsinh(infiniopAsinhDescriptor_t desc,
+                                                 void *workspace,
+                                                 size_t workspace_size,
+                                                 void *y,
+                                                 const void *x,
+                                                 void *stream);
+
+__INFINI_C __export infiniStatus_t infiniopDestroyAsinhDescriptor(infiniopAsinhDescriptor_t desc);
+
+#endif

include/infiniop/ops/avg_pool1d.h

+#ifndef __INFINIOP_AVG_POOL1D_API_H__
+#define __INFINIOP_AVG_POOL1D_API_H__
+
+#include "../operator_descriptor.h"
+
+typedef struct InfiniopDescriptor *infiniopAvgPool1dDescriptor_t;
+
+__INFINI_C __export infiniStatus_t infiniopCreateAvgPool1dDescriptor(
+    infiniopHandle_t handle,
+    infiniopAvgPool1dDescriptor_t *desc_ptr,
+    infiniopTensorDescriptor_t output,
+    infiniopTensorDescriptor_t input,
+    size_t kernel_size,
+    size_t stride,
+    size_t padding);
+
+__INFINI_C __export infiniStatus_t infiniopGetAvgPool1dWorkspaceSize(
+    infiniopAvgPool1dDescriptor_t desc,
+    size_t *size);
+
+__INFINI_C __export infiniStatus_t infiniopAvgPool1d(
+    infiniopAvgPool1dDescriptor_t desc,
+    void *workspace,
+    size_t workspace_size,
+    void *output,
+    const void *input,
+    void *stream);
+
+__INFINI_C __export infiniStatus_t infiniopDestroyAvgPool1dDescriptor(
+    infiniopAvgPool1dDescriptor_t desc);
+
+#endif

include/infiniop/ops/cross_entropy.h

+#ifndef __INFINIOP_CROSS_ENTROPY_API_H__
+#define __INFINIOP_CROSS_ENTROPY_API_H__
+
+#include "../operator_descriptor.h"
+
+typedef struct InfiniopDescriptor *infiniopCrossEntropyDescriptor_t;
+
+__INFINI_C __export infiniStatus_t infiniopCreateCrossEntropyDescriptor(
+    infiniopHandle_t handle,
+    infiniopCrossEntropyDescriptor_t *desc_ptr,
+    infiniopTensorDescriptor_t y_desc,
+    infiniopTensorDescriptor_t x_desc,
+    infiniopTensorDescriptor_t target_desc);
+
+__INFINI_C __export infiniStatus_t infiniopGetCrossEntropyWorkspaceSize(
+    infiniopCrossEntropyDescriptor_t desc,
+    size_t *size);
+
+__INFINI_C __export infiniStatus_t infiniopCrossEntropy(
+    infiniopCrossEntropyDescriptor_t desc,
+    void *workspace,
+    size_t workspace_size,
+    void *y,
+    const void *x,
+    const void *target,
+    void *stream);
+
+__INFINI_C __export infiniStatus_t infiniopDestroyCrossEntropyDescriptor(
+    infiniopCrossEntropyDescriptor_t desc);
+
+#endif

include/infiniop/ops/equal.h

+#ifndef __INFINIOP_EQUAL_API_H__
+#define __INFINIOP_EQUAL_API_H__
+
+#include "../operator_descriptor.h"
+
+typedef struct InfiniopDescriptor *infiniopEqualDescriptor_t;
+
+__INFINI_C __export infiniStatus_t infiniopCreateEqualDescriptor(
+    infiniopHandle_t handle,
+    infiniopEqualDescriptor_t *desc_ptr,
+    infiniopTensorDescriptor_t c,
+    infiniopTensorDescriptor_t a,
+    infiniopTensorDescriptor_t b);
+
+__INFINI_C __export infiniStatus_t infiniopGetEqualWorkspaceSize(
+    infiniopEqualDescriptor_t desc,
+    size_t *size);
+
+__INFINI_C __export infiniStatus_t infiniopEqual(
+    infiniopEqualDescriptor_t desc,
+    void *workspace,
+    size_t workspace_size,
+    void *c,
+    const void *a,
+    const void *b,
+    void *stream);
+
+__INFINI_C __export infiniStatus_t infiniopDestroyEqualDescriptor(
+    infiniopEqualDescriptor_t desc);
+
+#endif

include/infiniop/ops/fmod.h

+#ifndef __INFINIOP_FMOD_API_H__
+#define __INFINIOP_FMOD_API_H__
+
+#include "../operator_descriptor.h"
+
+typedef struct InfiniopDescriptor *infiniopFmodDescriptor_t;
+
+__INFINI_C __export infiniStatus_t infiniopCreateFmodDescriptor(infiniopHandle_t handle,
+                                                                infiniopFmodDescriptor_t *desc_ptr,
+                                                                infiniopTensorDescriptor_t c,
+                                                                infiniopTensorDescriptor_t a,
+                                                                infiniopTensorDescriptor_t b);
+
+__INFINI_C __export infiniStatus_t infiniopGetFmodWorkspaceSize(infiniopFmodDescriptor_t desc, size_t *size);
+
+__INFINI_C __export infiniStatus_t infiniopFmod(infiniopFmodDescriptor_t desc,
+                                                void *workspace,
+                                                size_t workspace_size,
+                                                void *c,
+                                                const void *a,
+                                                const void *b,
+                                                void *stream);
+
+__INFINI_C __export infiniStatus_t infiniopDestroyFmodDescriptor(infiniopFmodDescriptor_t desc);
+
+#endif

include/infiniop/ops/hardswish.h

+#ifndef __INFINIOP_HARDSWISH_API_H__
+#define __INFINIOP_HARDSWISH_API_H__
+
+#include "../operator_descriptor.h"
+
+typedef struct InfiniopDescriptor *infiniopHardSwishDescriptor_t;
+
+__INFINI_C __export infiniStatus_t infiniopCreateHardSwishDescriptor(
+    infiniopHandle_t handle,
+    infiniopHardSwishDescriptor_t *desc_ptr,
+    infiniopTensorDescriptor_t output,
+    infiniopTensorDescriptor_t input);
+
+__INFINI_C __export infiniStatus_t infiniopGetHardSwishWorkspaceSize(
+    infiniopHardSwishDescriptor_t desc,
+    size_t *size);
+
+__INFINI_C __export infiniStatus_t infiniopHardSwish(
+    infiniopHardSwishDescriptor_t desc,
+    void *workspace,
+    size_t workspace_size,
+    void *output,
+    const void *input,
+    void *stream);
+
+__INFINI_C __export infiniStatus_t infiniopDestroyHardSwishDescriptor(
+    infiniopHardSwishDescriptor_t desc);
+
+#endif

include/infiniop/ops/hardtanh.h

+#ifndef __INFINIOP_HARDTANH_API_H__
+#define __INFINIOP_HARDTANH_API_H__
+
+#include "../operator_descriptor.h"
+
+typedef struct InfiniopDescriptor *infiniopHardTanhDescriptor_t;
+
+__INFINI_C __export infiniStatus_t infiniopCreateHardTanhDescriptor(infiniopHandle_t handle,
+                                                                    infiniopHardTanhDescriptor_t *desc_ptr,
+                                                                    infiniopTensorDescriptor_t output,
+                                                                    infiniopTensorDescriptor_t input,
+                                                                    float min_val,
+                                                                    float max_val);
+
+__INFINI_C __export infiniStatus_t infiniopGetHardTanhWorkspaceSize(infiniopHardTanhDescriptor_t desc,
+                                                                    size_t *size);
+
+__INFINI_C __export infiniStatus_t infiniopHardTanh(infiniopHardTanhDescriptor_t desc,
+                                                    void *workspace,
+                                                    size_t workspace_size,
+                                                    void *output,
+                                                    const void *input,
+                                                    void *stream);
+
+__INFINI_C __export infiniStatus_t infiniopDestroyHardTanhDescriptor(infiniopHardTanhDescriptor_t desc);
+
+#endif