issue/205 - 添加Sub算子的gguf测试用例

include/infiniop/ops/add.h

@@ -17,8 +17,8 @@ __C __export infiniStatus_t infiniopAdd(infiniopAddDescriptor_t desc,
                                         void *workspace,
                                         size_t workspace_size,
                                         void *c,
-                                        void const *a,
-                                        void const *b,
+                                        const void *a,
+                                        const void *b,
                                         void *stream);
 
 __C __export infiniStatus_t infiniopDestroyAddDescriptor(infiniopAddDescriptor_t desc);

include/infiniop/ops/sub.h

@@ -17,8 +17,8 @@ __C __export infiniStatus_t infiniopSub(infiniopSubDescriptor_t desc,
                                         void *workspace,
                                         size_t workspace_size,
                                         void *c,
-                                        void const *a,
-                                        void const *b,
+                                        const void *a,
+                                        const void *b,
                                         void *stream);
 
 __C __export infiniStatus_t infiniopDestroySubDescriptor(infiniopSubDescriptor_t desc);

src/infiniop-test/include/ops.hpp

@@ -5,15 +5,16 @@
 /*
  * Declare all the tests here
  */
+DECLARE_INFINIOP_TEST(add)
+DECLARE_INFINIOP_TEST(clip)
 DECLARE_INFINIOP_TEST(gemm)
+DECLARE_INFINIOP_TEST(mul)
 DECLARE_INFINIOP_TEST(random_sample)
+DECLARE_INFINIOP_TEST(rearrange)
 DECLARE_INFINIOP_TEST(rms_norm)
-DECLARE_INFINIOP_TEST(mul)
 DECLARE_INFINIOP_TEST(rope)
-DECLARE_INFINIOP_TEST(clip)
+DECLARE_INFINIOP_TEST(sub)
 DECLARE_INFINIOP_TEST(swiglu)
-DECLARE_INFINIOP_TEST(add)
-DECLARE_INFINIOP_TEST(rearrange)
 
 #define REGISTER_INFINIOP_TEST(name)                      \
     {                                                     \
@@ -30,15 +31,16 @@ DECLARE_INFINIOP_TEST(rearrange)
  */
 #define TEST_BUILDER_MAPPINGS                 \
     {                                         \
-        REGISTER_INFINIOP_TEST(gemm)          \
-        REGISTER_INFINIOP_TEST(random_sample) \
         REGISTER_INFINIOP_TEST(add)           \
-        REGISTER_INFINIOP_TEST(mul)           \
         REGISTER_INFINIOP_TEST(clip)          \
-        REGISTER_INFINIOP_TEST(swiglu)        \
-        REGISTER_INFINIOP_TEST(rope)          \
-        REGISTER_INFINIOP_TEST(rms_norm)      \
+        REGISTER_INFINIOP_TEST(gemm)          \
+        REGISTER_INFINIOP_TEST(mul)           \
+        REGISTER_INFINIOP_TEST(random_sample) \
         REGISTER_INFINIOP_TEST(rearrange)     \
+        REGISTER_INFINIOP_TEST(rms_norm)      \
+        REGISTER_INFINIOP_TEST(rope)          \
+        REGISTER_INFINIOP_TEST(sub)           \
+        REGISTER_INFINIOP_TEST(swiglu)        \
     }
 
 namespace infiniop_test {

src/infiniop-test/src/ops/sub.cpp

+#include "ops.hpp"
+#include "utils.hpp"
+#include <infinirt.h>
+#include <iomanip>
+#include <iostream>
+
+namespace infiniop_test::sub {
+struct Test::Attributes {
+    std::shared_ptr<Tensor> a;
+    std::shared_ptr<Tensor> b;
+    std::shared_ptr<Tensor> c;
+    std::shared_ptr<Tensor> ans;
+};
+
+std::shared_ptr<Test> Test::build(
+    std::unordered_map<std::string, std::vector<uint8_t>> attributes,
+    std::unordered_map<std::string, std::shared_ptr<Tensor>> tensors,
+    double rtol, double atol) {
+    auto test = std::shared_ptr<Test>(new Test(rtol, atol));
+    test->_attributes = new Attributes();
+    if (tensors.find("a") == tensors.end()
+        || tensors.find("b") == tensors.end()
+        || tensors.find("c") == tensors.end()
+        || tensors.find("ans") == tensors.end()) {
+        throw std::runtime_error("Invalid Test");
+    }
+
+    test->_attributes->a = tensors["a"];
+    test->_attributes->b = tensors["b"];
+    test->_attributes->c = tensors["c"];
+    test->_attributes->ans = tensors["ans"];
+
+    return test;
+}
+
+std::shared_ptr<infiniop_test::Result> Test::run(
+    infiniopHandle_t handle, infiniDevice_t device, int device_id, size_t warm_ups, size_t iterations) {
+    infiniopSubDescriptor_t op_desc;
+    auto a = _attributes->a->to(device, device_id);
+    auto b = _attributes->b->to(device, device_id);
+    auto c = _attributes->c->to(device, device_id);
+    CHECK_OR(infiniopCreateSubDescriptor(handle, &op_desc,
+                                         c->desc(),
+                                         a->desc(),
+                                         b->desc()),
+             return TEST_FAILED(OP_CREATION_FAILED, "Failed to create op descriptor."));
+    size_t workspace_size;
+    CHECK_OR(infiniopGetSubWorkspaceSize(op_desc, &workspace_size),
+             return TEST_FAILED(OP_CREATION_FAILED, "Failed to get workspace size."));
+    void *workspace;
+    CHECK_OR(infinirtMalloc(&workspace, workspace_size),
+             return TEST_FAILED(OP_CREATION_FAILED, "Failed to allocate workspace."));
+    CHECK_OR(infiniopSub(op_desc, workspace, workspace_size,
+                         c->data(),
+                         a->data(),
+                         b->data(),
+                         nullptr),
+             return TEST_FAILED(OP_EXECUTION_FAILED, "Failed during execution."));
+
+    try {
+        allClose(c, _attributes->ans, _rtol, _atol);
+    } catch (const std::exception &e) {
+        return TEST_FAILED(RESULT_INCORRECT, e.what());
+    }
+
+    double elapsed_time = 0.;
+
+    elapsed_time = benchmark(
+        [=]() {
+            infiniopSub(
+                op_desc, workspace, workspace_size,
+                c->data(),
+                a->data(),
+                b->data(),
+                nullptr);
+        },
+        warm_ups, iterations);
+
+    return TEST_PASSED(elapsed_time);
+}
+
+std::vector<std::string> Test::attribute_names() {
+    return {};
+}
+
+std::vector<std::string> Test::tensor_names() {
+    return {"a", "b", "c", "ans"};
+}
+
+std::vector<std::string> Test::output_names() {
+    return {"c"};
+}
+
+std::string Test::toString() const {
+    std::ostringstream oss;
+    oss << op_name() << std::endl;
+    oss << "- a: " << _attributes->a->info() << std::endl;
+    oss << "- b: " << _attributes->b->info() << std::endl;
+    oss << "- c: " << _attributes->c->info() << std::endl;
+    oss << std::scientific << std::setprecision(2);
+    oss << "- rtol=" << _rtol << ", atol=" << _atol << std::endl;
+    return oss.str();
+}
+
+Test::~Test() {
+    delete _attributes;
+}
+
+} // namespace infiniop_test::sub

test/infiniop-test/test_generate/testcases/sub.py

+from ast import List
+import numpy as np
+import gguf
+from typing import List
+from numpy.lib.stride_tricks import as_strided
+
+from .. import (
+    InfiniopTestWriter,
+    InfiniopTestCase,
+    np_dtype_to_ggml,
+    gguf_strides,
+    contiguous_gguf_strides,
+    process_zero_stride_tensor,
+)
+
+
+def sub(
+    a: np.ndarray,
+    b: np.ndarray,
+):
+    return a - b
+
+
+class SubTestCase(InfiniopTestCase):
+    def __init__(
+        self,
+        a: np.ndarray,
+        shape_a: List[int] | None,
+        stride_a: List[int] | None,
+        b: np.ndarray,
+        shape_b: List[int] | None,
+        stride_b: List[int] | None,
+        c: np.ndarray,
+        shape_c: List[int] | None,
+        stride_c: List[int] | None,
+    ):
+        super().__init__("sub")
+        self.a = a
+        self.shape_a = shape_a
+        self.stride_a = stride_a
+        self.b = b
+        self.shape_b = shape_b
+        self.stride_b = stride_b
+        self.c = c
+        self.shape_c = shape_c
+        self.stride_c = stride_c
+
+    def write_test(self, test_writer: "InfiniopTestWriter"):
+        super().write_test(test_writer)
+        if self.shape_a is not None:
+            test_writer.add_array(test_writer.gguf_key("a.shape"), self.shape_a)
+        if self.shape_b is not None:
+            test_writer.add_array(test_writer.gguf_key("b.shape"), self.shape_b)
+        if self.shape_c is not None:
+            test_writer.add_array(test_writer.gguf_key("c.shape"), self.shape_c)
+        if self.stride_a is not None:
+            test_writer.add_array(
+                test_writer.gguf_key("a.strides"), gguf_strides(*self.stride_a)
+            )
+        if self.stride_b is not None:
+            test_writer.add_array(
+                test_writer.gguf_key("b.strides"), gguf_strides(*self.stride_b)
+            )
+        test_writer.add_array(
+            test_writer.gguf_key("c.strides"),
+            gguf_strides(
+                *(
+                    self.stride_c
+                    if self.stride_c is not None
+                    else contiguous_gguf_strides(self.shape_c)
+                )
+            ),
+        )
+        test_writer.add_tensor(
+            test_writer.gguf_key("a"), self.a, raw_dtype=np_dtype_to_ggml(self.a.dtype)
+        )
+        test_writer.add_tensor(
+            test_writer.gguf_key("b"), self.b, raw_dtype=np_dtype_to_ggml(self.b.dtype)
+        )
+        test_writer.add_tensor(
+            test_writer.gguf_key("c"), self.c, raw_dtype=np_dtype_to_ggml(self.c.dtype)
+        )
+        ans = sub(
+            self.a.astype(np.float64),
+            self.b.astype(np.float64),
+        )
+        test_writer.add_tensor(
+            test_writer.gguf_key("ans"), ans, raw_dtype=gguf.GGMLQuantizationType.F64
+        )
+
+
+if __name__ == "__main__":
+    test_writer = InfiniopTestWriter("sub.gguf")
+    test_cases = []
+    # ==============================================================================
+    #  Configuration (Internal Use Only)
+    # ==============================================================================
+    # These are not meant to be imported from other modules
+    _TEST_CASES_ = [
+        # shape, a_stride, b_stride, c_stride
+        ((13, 4), None, None, None),
+        ((13, 4), (10, 1), (10, 1), (10, 1)),
+        ((13, 4), (0, 1), None, None),
+        ((13, 4, 4), None, None, None),
+        ((13, 4, 4), (20, 4, 1), (20, 4, 1), (20, 4, 1)),
+        ((13, 4, 4), (4, 0, 1), (0, 4, 1), None),
+        ((16, 5632), None, None, None),
+        ((16, 5632), (13312, 1), (13312, 1), (13312, 1)),
+        ((4, 4, 5632), None, None, None),
+        ((4, 4, 5632), (45056, 5632, 1), (45056, 5632, 1), (45056, 5632, 1)),
+    ]
+    _TENSOR_DTYPES_ = [np.float32, np.float16]
+    for dtype in _TENSOR_DTYPES_:
+        for shape, stride_a, stride_b, stride_c in _TEST_CASES_:
+            a = np.random.rand(*shape).astype(dtype)
+            b = np.random.rand(*shape).astype(dtype)
+            c = np.empty(tuple(0 for _ in shape), dtype=dtype)
+            a = process_zero_stride_tensor(a, stride_a)
+            b = process_zero_stride_tensor(b, stride_b)
+            test_case = SubTestCase(
+                a=a,
+                shape_a=shape,
+                stride_a=stride_a,
+                b=b,
+                shape_b=shape,
+                stride_b=stride_b,
+                c=c,
+                shape_c=shape,
+                stride_c=stride_c,
+            )
+            test_cases.append(test_case)
+
+    test_writer.add_tests(test_cases)
+    test_writer.save()