[T1-1-1] wawahejun

include/infiniop.h

@@ -4,6 +4,7 @@
 #include "infiniop/handle.h"
 #include "infiniop/ops/add.h"
 #include "infiniop/ops/attention.h"
+#include "infiniop/ops/cast.h"
 #include "infiniop/ops/causal_softmax.h"
 #include "infiniop/ops/clip.h"
 #include "infiniop/ops/conv.h"
@@ -16,6 +17,14 @@
 #include "infiniop/ops/rope.h"
 #include "infiniop/ops/sub.h"
 #include "infiniop/ops/swiglu.h"
+#include "infiniop/ops/exp.h"
+#include "infiniop/ops/sin.h"
+#include "infiniop/ops/cos.h"
+#include "infiniop/ops/tanh.h"
+#include "infiniop/ops/hardswish.h"
+#include "infiniop/ops/leaky_relu.h"
+#include "infiniop/ops/sigmoid_backward.h"
+#include "infiniop/ops/where.h"
 #include "infiniop/tensor_descriptor.h"
 
 #endif // __INFINIOP_API_H__

include/infiniop/ops/cast.h

@@ -0,0 +1,24 @@
+#ifndef __INFINIOP_CAST_API_H__
+#define __INFINIOP_CAST_API_H__
+
+#include "../operator_descriptor.h"
+
+typedef struct InfiniopDescriptor *infiniopCastDescriptor_t;
+
+__C __export infiniStatus_t infiniopCreateCastDescriptor(infiniopHandle_t handle,
+                                                        infiniopCastDescriptor_t *desc_ptr,
+                                                        infiniopTensorDescriptor_t output,
+                                                        infiniopTensorDescriptor_t input);
+
+__C __export infiniStatus_t infiniopGetCastWorkspaceSize(infiniopCastDescriptor_t desc, size_t *size);
+
+__C __export infiniStatus_t infiniopCast(infiniopCastDescriptor_t desc,
+                                        void *workspace,
+                                        size_t workspace_size,
+                                        void *output,
+                                        const void *input,
+                                        void *stream);
+
+__C __export infiniStatus_t infiniopDestroyCastDescriptor(infiniopCastDescriptor_t desc);
+
+#endif

include/infiniop/ops/cos.h

@@ -0,0 +1,24 @@
+#ifndef __INFINIOP_COS_API_H__
+#define __INFINIOP_COS_API_H__
+
+#include "../operator_descriptor.h"
+
+typedef struct InfiniopDescriptor *infiniopCosDescriptor_t;
+
+__C __export infiniStatus_t infiniopCreateCosDescriptor(infiniopHandle_t handle,
+                                                        infiniopCosDescriptor_t *desc_ptr,
+                                                        infiniopTensorDescriptor_t output,
+                                                        infiniopTensorDescriptor_t input);
+
+__C __export infiniStatus_t infiniopGetCosWorkspaceSize(infiniopCosDescriptor_t desc, size_t *size);
+
+__C __export infiniStatus_t infiniopCos(infiniopCosDescriptor_t desc,
+                                        void *workspace,
+                                        size_t workspace_size,
+                                        void *output,
+                                        const void *input,
+                                        void *stream);
+
+__C __export infiniStatus_t infiniopDestroyCosDescriptor(infiniopCosDescriptor_t desc);
+
+#endif

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/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/leaky_relu.h

@@ -0,0 +1,25 @@
+#ifndef __INFINIOP_LEAKY_RELU_API_H__
+#define __INFINIOP_LEAKY_RELU_API_H__
+
+#include "../operator_descriptor.h"
+
+typedef struct InfiniopDescriptor *infiniopLeakyReLUDescriptor_t;
+
+__C __export infiniStatus_t infiniopCreateLeakyReLUDescriptor(infiniopHandle_t handle,
+                                                        infiniopLeakyReLUDescriptor_t *desc_ptr,
+                                                        infiniopTensorDescriptor_t output,
+                                                        infiniopTensorDescriptor_t input,
+                                                        float negative_slope);
+
+__C __export infiniStatus_t infiniopGetLeakyReLUWorkspaceSize(infiniopLeakyReLUDescriptor_t desc, size_t *size);
+
+__C __export infiniStatus_t infiniopLeakyReLU(infiniopLeakyReLUDescriptor_t desc,
+                                        void *workspace,
+                                        size_t workspace_size,
+                                        void *output,
+                                        const void *input,
+                                        void *stream);
+
+__C __export infiniStatus_t infiniopDestroyLeakyReLUDescriptor(infiniopLeakyReLUDescriptor_t desc);
+
+#endif

include/infiniop/ops/sigmoid_backward.h

@@ -0,0 +1,26 @@
+#ifndef __INFINIOP_SIGMOID_BACKWARD_API_H__
+#define __INFINIOP_SIGMOID_BACKWARD_API_H__
+
+#include "../operator_descriptor.h"
+
+typedef struct InfiniopDescriptor *infiniopSigmoidBackwardDescriptor_t;
+
+__C __export infiniStatus_t infiniopCreateSigmoidBackwardDescriptor(infiniopHandle_t handle,
+                                                                   infiniopSigmoidBackwardDescriptor_t *desc_ptr,
+                                                                   infiniopTensorDescriptor_t grad_input,
+                                                                   infiniopTensorDescriptor_t input,
+                                                                   infiniopTensorDescriptor_t grad_output);
+
+__C __export infiniStatus_t infiniopGetSigmoidBackwardWorkspaceSize(infiniopSigmoidBackwardDescriptor_t desc, size_t *size);
+
+__C __export infiniStatus_t infiniopSigmoidBackward(infiniopSigmoidBackwardDescriptor_t desc,
+                                                   void *workspace,
+                                                   size_t workspace_size,
+                                                   void *grad_input,
+                                                   const void *input,
+                                                   const void *grad_output,
+                                                   void *stream);
+
+__C __export infiniStatus_t infiniopDestroySigmoidBackwardDescriptor(infiniopSigmoidBackwardDescriptor_t desc);
+
+#endif

include/infiniop/ops/sin.h

@@ -0,0 +1,24 @@
+#ifndef __INFINIOP_SIN_API_H__
+#define __INFINIOP_SIN_API_H__
+
+#include "../operator_descriptor.h"
+
+typedef struct InfiniopDescriptor *infiniopSinDescriptor_t;
+
+__C __export infiniStatus_t infiniopCreateSinDescriptor(infiniopHandle_t handle,
+                                                        infiniopSinDescriptor_t *desc_ptr,
+                                                        infiniopTensorDescriptor_t output,
+                                                        infiniopTensorDescriptor_t input);
+
+__C __export infiniStatus_t infiniopGetSinWorkspaceSize(infiniopSinDescriptor_t desc, size_t *size);
+
+__C __export infiniStatus_t infiniopSin(infiniopSinDescriptor_t desc,
+                                        void *workspace,
+                                        size_t workspace_size,
+                                        void *output,
+                                        const void *input,
+                                        void *stream);
+
+__C __export infiniStatus_t infiniopDestroySinDescriptor(infiniopSinDescriptor_t desc);
+
+#endif

include/infiniop/ops/tanh.h

@@ -0,0 +1,24 @@
+#ifndef __INFINIOP_TANH_API_H__
+#define __INFINIOP_TANH_API_H__
+
+#include "../operator_descriptor.h"
+
+typedef struct InfiniopDescriptor *infiniopTanhDescriptor_t;
+
+__C __export infiniStatus_t infiniopCreateTanhDescriptor(infiniopHandle_t handle,
+                                                        infiniopTanhDescriptor_t *desc_ptr,
+                                                        infiniopTensorDescriptor_t output,
+                                                        infiniopTensorDescriptor_t input);
+
+__C __export infiniStatus_t infiniopGetTanhWorkspaceSize(infiniopTanhDescriptor_t desc, size_t *size);
+
+__C __export infiniStatus_t infiniopTanh(infiniopTanhDescriptor_t desc,
+                                        void *workspace,
+                                        size_t workspace_size,
+                                        void *output,
+                                        const void *input,
+                                        void *stream);
+
+__C __export infiniStatus_t infiniopDestroyTanhDescriptor(infiniopTanhDescriptor_t desc);
+
+#endif

include/infiniop/ops/where.h

@@ -0,0 +1,28 @@
+#ifndef __INFINIOP_WHERE_API_H__
+#define __INFINIOP_WHERE_API_H__
+
+#include "../operator_descriptor.h"
+
+typedef struct InfiniopDescriptor *infiniopWhereDescriptor_t;
+
+__C __export infiniStatus_t infiniopCreateWhereDescriptor(infiniopHandle_t handle,
+                                                        infiniopWhereDescriptor_t *desc_ptr,
+                                                        infiniopTensorDescriptor_t condition,
+                                                        infiniopTensorDescriptor_t a,
+                                                        infiniopTensorDescriptor_t b,
+                                                        infiniopTensorDescriptor_t c);
+
+__C __export infiniStatus_t infiniopGetWhereWorkspaceSize(infiniopWhereDescriptor_t desc, size_t *size);
+
+__C __export infiniStatus_t infiniopWhere(infiniopWhereDescriptor_t desc,
+                                        void *workspace,
+                                        size_t workspace_size,
+                                        const void *condition,
+                                        const void *a,
+                                        const void *b,
+                                        void *c,
+                                        void *stream);
+
+__C __export infiniStatus_t infiniopDestroyWhereDescriptor(infiniopWhereDescriptor_t desc);
+
+#endif

scripts/python_test.py

@@ -14,16 +14,25 @@ def run_tests(args):
     for test in [
         "add.py",
         "attention.py",
+        "cast.py",
         "causal_softmax.py",
         "clip.py",
+        "cos.py",
+        "exp.py",
         "gemm.py",
+        "hardswish.py",
+        "leaky_relu.py",
         "mul.py",
         "random_sample.py",
         "rearrange.py",
         "rms_norm.py",
         "rope.py",
+        "sigmoid_backward.py",
+        "sin.py",
         "sub.py",
         "swiglu.py",
+        "tanh.py",
+        "where.py",
     ]:
         result = subprocess.run(
             f"python {test} {args} --debug", text=True, encoding="utf-8", shell=True

src/infiniop-test/include/ops.hpp

@@ -13,9 +13,18 @@ DECLARE_INFINIOP_TEST(rope)
 DECLARE_INFINIOP_TEST(clip)
 DECLARE_INFINIOP_TEST(swiglu)
 DECLARE_INFINIOP_TEST(add)
+DECLARE_INFINIOP_TEST(cast)
 DECLARE_INFINIOP_TEST(causal_softmax)
 DECLARE_INFINIOP_TEST(rearrange)
 DECLARE_INFINIOP_TEST(sub)
+DECLARE_INFINIOP_TEST(exp)
+DECLARE_INFINIOP_TEST(sin)
+DECLARE_INFINIOP_TEST(cos)
+DECLARE_INFINIOP_TEST(tanh)
+DECLARE_INFINIOP_TEST(hardswish)
+DECLARE_INFINIOP_TEST(sigmoid_backward)
+DECLARE_INFINIOP_TEST(leaky_relu)
+DECLARE_INFINIOP_TEST(where)
 
 #define REGISTER_INFINIOP_TEST(name)                      \
     {                                                     \
@@ -35,6 +44,7 @@ DECLARE_INFINIOP_TEST(sub)
         REGISTER_INFINIOP_TEST(gemm)           \
         REGISTER_INFINIOP_TEST(random_sample)  \
         REGISTER_INFINIOP_TEST(add)            \
+        REGISTER_INFINIOP_TEST(cast)           \
         REGISTER_INFINIOP_TEST(mul)            \
         REGISTER_INFINIOP_TEST(clip)           \
         REGISTER_INFINIOP_TEST(swiglu)         \
@@ -43,6 +53,14 @@ DECLARE_INFINIOP_TEST(sub)
         REGISTER_INFINIOP_TEST(causal_softmax) \
         REGISTER_INFINIOP_TEST(rearrange)      \
         REGISTER_INFINIOP_TEST(sub)            \
+        REGISTER_INFINIOP_TEST(exp)            \
+        REGISTER_INFINIOP_TEST(sin)            \
+        REGISTER_INFINIOP_TEST(cos)            \
+        REGISTER_INFINIOP_TEST(tanh)           \
+        REGISTER_INFINIOP_TEST(hardswish)      \
+        REGISTER_INFINIOP_TEST(sigmoid_backward) \
+        REGISTER_INFINIOP_TEST(leaky_relu)       \
+        REGISTER_INFINIOP_TEST(where)             \
     }
 
 namespace infiniop_test {

src/infiniop-test/include/tensor.hpp

@@ -27,6 +27,15 @@ inline infiniDtype_t ggmlTypeToInfiniType(GGML_TYPE type) {
     }
 }
 
+// Special handling for bool type in GGUF files
+inline infiniDtype_t ggmlTypeToInfiniTypeWithBool(GGML_TYPE type) {
+    if (type == GGML_TYPE_I8) {
+        // For where operator, I8 in GGUF should be treated as BOOL in InfiniCore
+        return INFINI_DTYPE_BOOL;
+    }
+    return ggmlTypeToInfiniType(type);
+}
+
 namespace infiniop_test {
 class Memory {
 private:
@@ -69,6 +78,11 @@ class Tensor {
     infiniopTensorDescriptor_t desc() const { return _desc; }
     std::vector<size_t> shape() const { return std::vector<size_t>(_shape); }
     std::vector<ptrdiff_t> strides() const { return std::vector<ptrdiff_t>(_strides); }
+    // Method to override tensor descriptor type for special cases like bool conversion
+    void overrideDescriptorType(infiniDtype_t new_type) {
+        infiniopDestroyTensorDescriptor(_desc);
+        infiniopCreateTensorDescriptor(&_desc, _shape.size(), _shape.data(), _strides.data(), new_type);
+    }
     GGML_TYPE ggml_type() const { return _ggml_type; }
     void *data() const;
     std::shared_ptr<Tensor> to(infiniDevice_t device, int device_id = 0) const;

src/infiniop-test/include/utils.hpp

@@ -11,6 +11,8 @@ inline double getVal(void *ptr, GGML_TYPE ggml_type) {
     switch (ggml_type) {
     case GGML_TYPE_F16:
         return utils::cast<double>(*(fp16_t *)ptr);
+    case GGML_TYPE_BF16:
+        return utils::cast<double>(*(bf16_t *)ptr);
     case GGML_TYPE_F32:
         return *(float *)ptr;
     case GGML_TYPE_F64:
@@ -32,6 +34,8 @@ inline size_t ggmlSizeOf(GGML_TYPE ggml_type) {
     switch (ggml_type) {
     case GGML_TYPE_F16:
         return sizeof(fp16_t);
+    case GGML_TYPE_BF16:
+        return sizeof(bf16_t);
     case GGML_TYPE_F32:
         return sizeof(float);
     case GGML_TYPE_F64: