feat: testing tensor ops

Author: Integer-Ctrl

.vscode/settings.json

@@ -100,7 +100,8 @@
         "NVCOMPILER",
         "pnacl",
         "relu",
-        "xtensor"
+        "xtensor",
+        "linalg"
     ],
 
     // Include Paths

CMakeLists.txt

@@ -298,7 +298,7 @@ add_executable(tests "${SOURCE_FILEPATHS}" "${TEST_FILEPATHS}")
 if(SAVE_JITS_TO_FILE)
 target_compile_definitions(tests PUBLIC SAVE_JITS_TO_FILE)
 endif(SAVE_JITS_TO_FILE)
-target_link_libraries(tests PRIVATE Catch2::Catch2WithMain xtensor)
+target_link_libraries(tests PRIVATE Catch2::Catch2WithMain xtensor xtensor-blas)
 
 add_executable(benchmarks "${SOURCE_FILEPATHS}" "${BENCH_FILEPATHS}")
 target_link_libraries(benchmarks benchmark::benchmark_main)

src/test/BaseGeneration.test.h

@@ -23,21 +23,22 @@ class GenerationTest
   float *matrix_c_verify;
   mini_jit::Brgemm::kernel_t kernel = nullptr;
 
+public:
   /**
    * @brief Fills the given matrix with random values.
    *
    * @param matrix The matrix to fill.
    * @param size The total size of the matrix.
    */
-  void fill_random_matrix(float *matrix, uint32_t size);
+  static void fill_random_matrix(float *matrix, uint32_t size);
 
   /**
    * @brief Fills the given matrix with counting values starting from 0.
    *
    * @param matrix The matrix to fill.
    * @param size The total size of the matrix.
    */
-  void fill_counting_matrix(float *matrix, uint32_t size);
+  static void fill_counting_matrix(float *matrix, uint32_t size);
 
   /**
    * @brief Does a naive matmul for verification usage.
@@ -61,9 +62,8 @@ class GenerationTest
    * @param result The actual matrix values.
    * @param size The total size of the matrix.
    */
-  void verify_matmul(const float *__restrict__ expected, const float *__restrict__ result, uint32_t size);
+  static void verify_matmul(const float *__restrict__ expected, const float *__restrict__ result, uint32_t size);
 
-public:
   GenerationTest() = delete;
   GenerationTest(uint32_t M, uint32_t N, uint32_t K);
   GenerationTest(uint32_t M, uint32_t N, uint32_t K, uint32_t lda, uint32_t ldb, uint32_t ldc);

src/test/TensorOperation.test.cpp

@@ -1,4 +1,5 @@
 #include "../main/TensorOperation.h"
+#include "BaseGeneration.test.h"
 #include <catch2/catch_test_macros.hpp>
 #include <catch2/generators/catch_generators.hpp>
 #include <catch2/generators/catch_generators_range.hpp>
@@ -7,6 +8,7 @@
 #include <cmath>
 #include <cstdint>
 #include <span>
+#include <xtensor-blas/xlinalg.hpp>
 #include <xtensor/containers/xtensor.hpp>
 #include <xtensor/generators/xrandom.hpp>
 
@@ -102,8 +104,6 @@ TEST_CASE("Test tensor operation with main kernel: gemm", "[tensor_operation][ge
   xt::xtensor<float, 2> tensorOutVerify({64, 64});
   std::copy(tensorOut.begin(), tensorOut.end(), tensorOutVerify.begin());
 
-  std::cout << tensorIn0[0] << " " << tensorIn1[0] << " " << tensorOutVerify[0] << " " << tensorOut[0] << std::endl;
-
   mini_jit::TensorOperation tensor_op;
   TensorOperation::error_t err =
     tensor_op.setup(TensorOperation::dtype_t::fp32, TensorOperation::prim_t::none, TensorOperation::prim_t::gemm,
@@ -112,14 +112,14 @@ TEST_CASE("Test tensor operation with main kernel: gemm", "[tensor_operation][ge
 
   REQUIRE(err == TensorOperation::error_t::success);
 
-  tensor_op.execute(tensorIn0.data(), tensorIn1.data(), tensorOut.data());
+  // tensorOut += xt::linalg::dot(tensorIn0, tensorIn1);
 
-  std::cout << tensorOutVerify[0] << " " << tensorOut[0] << std::endl;
+  GenerationTest generatorTest(64, 64, 64);
+  generatorTest.naive_matmul_M_N_K_Batch(tensorIn0.data(), tensorIn1.data(), tensorOutVerify.data(), 64, 64, 64, 1, 1);
 
-  // TODO: Implement the verification logic for naive gemm operation
+  tensor_op.execute(tensorIn0.data(), tensorIn1.data(), tensorOut.data());
 
   verify_tensor(tensorOutVerify.data(), tensorOut.data(), tensorOut.size());
-  FAIL();
 }
 
 TEST_CASE("Test tensor operation with main kernel: brgemm", "[tensor_operation][brgemm][correctness]")
@@ -131,8 +131,8 @@ TEST_CASE("Test tensor operation with main kernel: brgemm", "[tensor_operation][
   constexpr TensorOperation::exec_t exec_types[]{TensorOperation::exec_t::prim, TensorOperation::exec_t::prim,
                                                  TensorOperation::exec_t::prim, TensorOperation::exec_t::prim};
   constexpr int64_t dim_sizes[]{64, 64, 64, 64};
-  constexpr int64_t strides_in0[]{64, 1, 0, 64};
-  constexpr int64_t strides_in1[]{64, 0, 64, 1};
+  constexpr int64_t strides_in0[]{64 * 64, 1, 0, 64};
+  constexpr int64_t strides_in1[]{64 * 64, 0, 64, 1};
   constexpr int64_t strides_out[]{0, 1, 64, 0};
 
   xt::random::seed(Catch::rngSeed());
@@ -156,7 +156,8 @@ TEST_CASE("Test tensor operation with main kernel: brgemm", "[tensor_operation][
 
   tensor_op.execute(tensorIn0.data(), tensorIn1.data(), tensorOut.data());
 
-  // TODO: Implement the verification logic for naive brgemm operation
+  GenerationTest generatorTest(64, 64, 64, 64);
+  generatorTest.naive_matmul_M_N_K_Batch(tensorIn0.data(), tensorIn1.data(), tensorOutVerify.data(), 64, 64, 64, 64 * 64, 64 * 64);
 
   verify_tensor(tensorOutVerify.data(), tensorOut.data(), tensorOut.size());
 }