Merge pull request #1075 from InfiniTensor/RevertT_1-1-4

Revert T1-1-4

include/infinicore/ops.hpp

@@ -3,13 +3,9 @@
 #include "ops/add.hpp"
 #include "ops/add_rms_norm.hpp"
 #include "ops/attention.hpp"
-#include "ops/avg_pool1d.hpp"
 #include "ops/causal_softmax.hpp"
-#include "ops/cross_entropy.hpp"
 #include "ops/embedding.hpp"
 #include "ops/flash_attention.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/all.hpp

-#pragma once
-
-#include "../device.hpp"
-#include "common/op.hpp"
-#include <optional>
-#include <vector>
-namespace infinicore::op {
-class All {
-public:
-    using schema = void (*)(Tensor, Tensor, std::vector<size_t>, bool);
-    static void execute(Tensor output, Tensor input, std::vector<size_t> dim, bool keepdim = false);
-    static common::OpDispatcher<schema> &dispatcher();
-};
-
-Tensor all(Tensor input, std::vector<size_t> dim, bool keepdim = false);
-void all_(Tensor output, Tensor input, std::vector<size_t> dim, bool keepdim = false);
-
-} // 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/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/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/infinicore/ops/sum.hpp

-#pragma once
-
-#include "../device.hpp"
-#include "common/op.hpp"
-#include <optional>
-#include <vector>
-
-namespace infinicore::op {
-class Sum {
-public:
-    using schema = void (*)(Tensor, Tensor, std::vector<size_t>, bool);
-    static void execute(Tensor output, Tensor input, std::vector<size_t> dim, bool keepdim = false);
-    static common::OpDispatcher<schema> &dispatcher();
-};
-
-Tensor sum(Tensor input, std::vector<size_t> dim, bool keepdim = false);
-void sum_(Tensor output, Tensor input, std::vector<size_t> dim, bool keepdim = false);
-
-} // namespace infinicore::op

include/infinicore/ops/topk.hpp

-#pragma once
-
-#include "../device.hpp"
-#include "common/op.hpp"
-namespace infinicore::op {
-class TopK {
-public:
-    using schema = void (*)(Tensor, Tensor, Tensor, size_t, size_t, bool, bool);
-    static void execute(Tensor values_output, Tensor indices_output, Tensor input, size_t k, size_t dim, bool largest = true, bool sorted = true);
-    static common::OpDispatcher<schema> &dispatcher();
-};
-
-std::pair<Tensor, Tensor> topk(Tensor input, size_t k, size_t dim, bool largest = true, bool sorted = true);
-void topk_(Tensor values_output, Tensor indices_output, Tensor input, size_t k, size_t dim, bool largest = true, bool sorted = true);
-
-} // namespace infinicore::op

include/infinicore/ops/var.hpp

-#pragma once
-
-#include "../device.hpp"
-#include "common/op.hpp"
-#include <optional>
-#include <utility>
-#include <vector>
-namespace infinicore::op {
-class Var {
-public:
-    using schema = void (*)(Tensor, Tensor, std::vector<size_t>, bool, bool); // var_output, input, dim, unbiased, keepdim
-    static void execute(Tensor var_output, Tensor input, std::vector<size_t> dim, bool unbiased = true, bool keepdim = false);
-    static common::OpDispatcher<schema> &dispatcher();
-};
-
-Tensor var(Tensor input, std::vector<size_t> dim, bool unbiased = true, bool keepdim = false);
-void var_(Tensor var_output, Tensor input, std::vector<size_t> dim, bool unbiased = true, bool keepdim = false);
-
-} // namespace infinicore::op

include/infinicore/ops/var_mean.hpp

-#pragma once
-
-#include "../device.hpp"
-#include "common/op.hpp"
-#include <optional>
-#include <utility>
-#include <vector>
-namespace infinicore::op {
-class Var_Mean {
-public:
-    using schema = void (*)(Tensor, Tensor, Tensor, std::vector<size_t>, bool, bool); // var_output, mean_output, input, dim, unbiased, keepdim
-    static void execute(Tensor var_output, Tensor mean_output, Tensor input, std::vector<size_t> dim, bool unbiased = true, bool keepdim = false);
-    static common::OpDispatcher<schema> &dispatcher();
-};
-
-std::pair<Tensor, Tensor> var_mean(Tensor input, std::vector<size_t> dim, bool unbiased = true, bool keepdim = false);
-void var_mean_(Tensor var_output, Tensor mean_output, Tensor input, std::vector<size_t> dim, bool unbiased = true, bool keepdim = false);
-
-} // namespace infinicore::op

include/infiniop.h

@@ -4,7 +4,6 @@
 #include "infiniop/handle.h"
 #include "infiniop/ops/add.h"
 #include "infiniop/ops/add_rms_norm.h"
-#include "infiniop/ops/all.h"
 #include "infiniop/ops/attention.h"
 #include "infiniop/ops/causal_softmax.h"
 #include "infiniop/ops/clip.h"
@@ -36,21 +35,11 @@
 #include "infiniop/ops/softmax.h"
 #include "infiniop/ops/softplus.h"
 #include "infiniop/ops/sub.h"
-#include "infiniop/ops/sum.h"
 #include "infiniop/ops/swiglu.h"
 #include "infiniop/ops/tanh.h"
-#include "infiniop/ops/topk.h"
 #include "infiniop/ops/topkrouter.h"
 #include "infiniop/ops/topksoftmax.h"
-#include "infiniop/ops/var.h"
-#include "infiniop/ops/var_mean.h"
 #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/all.h

-#ifndef __INFINIOP_ALL_API_H__
-#define __INFINIOP_ALL_API_H__
-
-#include "../operator_descriptor.h"
-#include <cstddef>
-#include <vector>
-typedef struct InfiniopDescriptor *infiniopAllDescriptor_t;
-
-__INFINI_C __export infiniStatus_t infiniopCreateAllDescriptor(infiniopHandle_t handle,
-                                                               infiniopAllDescriptor_t *desc_ptr,
-                                                               infiniopTensorDescriptor_t output_desc,
-                                                               infiniopTensorDescriptor_t input_desc,
-                                                               size_t *dim,
-                                                               size_t dim_size,
-                                                               bool keepdim);
-
-__INFINI_C __export infiniStatus_t infiniopGetAllWorkspaceSize(infiniopAllDescriptor_t desc, size_t *size);
-
-__INFINI_C __export infiniStatus_t infiniopAll(infiniopAllDescriptor_t desc,
-                                               void *workspace,
-                                               size_t workspace_size,
-                                               void *output,
-                                               const void *input,
-                                               size_t *dim,
-                                               size_t dim_size,
-                                               bool keepdim,
-                                               void *stream);
-
-__INFINI_C __export infiniStatus_t infiniopDestroyAllDescriptor(infiniopAllDescriptor_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/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

include/infiniop/ops/sum.h

-#ifndef __INFINIOP_SUM_API_H__
-#define __INFINIOP_SUM_API_H__
-
-#include "../operator_descriptor.h"
-#include <cstddef>
-#include <vector>
-typedef struct InfiniopDescriptor *infiniopSumDescriptor_t;
-
-__INFINI_C __export infiniStatus_t infiniopCreateSumDescriptor(infiniopHandle_t handle,
-                                                               infiniopSumDescriptor_t *desc_ptr,
-                                                               infiniopTensorDescriptor_t output_desc,
-                                                               infiniopTensorDescriptor_t input_desc,
-                                                               size_t *dim,
-                                                               size_t dim_size,
-                                                               bool keepdim);
-
-__INFINI_C __export infiniStatus_t infiniopGetSumWorkspaceSize(infiniopSumDescriptor_t desc, size_t *size);
-
-__INFINI_C __export infiniStatus_t infiniopSum(infiniopSumDescriptor_t desc,
-                                               void *workspace,
-                                               size_t workspace_size,
-                                               void *output,
-                                               const void *input,
-                                               size_t *dim,
-                                               size_t dim_size,
-                                               bool keepdim,
-                                               void *stream);
-
-__INFINI_C __export infiniStatus_t infiniopDestroySumDescriptor(infiniopSumDescriptor_t desc);
-
-#endif

include/infiniop/ops/topk.h

-#ifndef __INFINIOP_TOPK_API_H__
-#define __INFINIOP_TOPK_API_H__
-
-#include "../operator_descriptor.h"
-#include <cstddef>
-#include <vector>
-typedef struct InfiniopDescriptor *infiniopTopKDescriptor_t;
-
-__INFINI_C __export infiniStatus_t infiniopCreateTopKDescriptor(infiniopHandle_t handle,
-                                                                infiniopTopKDescriptor_t *desc_ptr,
-                                                                infiniopTensorDescriptor_t values_output_desc,
-                                                                infiniopTensorDescriptor_t indices_output_desc,
-                                                                infiniopTensorDescriptor_t input_desc,
-                                                                size_t k,
-                                                                size_t dim,
-                                                                bool largest,
-                                                                bool sorted);
-
-__INFINI_C __export infiniStatus_t infiniopGetTopKWorkspaceSize(infiniopTopKDescriptor_t desc, size_t *size);
-
-__INFINI_C __export infiniStatus_t infiniopTopK(infiniopTopKDescriptor_t desc,
-                                                void *workspace,
-                                                size_t workspace_size,
-                                                void *values_output,
-                                                void *indices_output,
-                                                const void *input,
-                                                size_t k,
-                                                size_t dim,
-                                                bool largest,
-                                                bool sorted,
-                                                void *stream);
-
-__INFINI_C __export infiniStatus_t infiniopDestroyTopKDescriptor(infiniopTopKDescriptor_t desc);
-
-#endif