minor update to sgemm_tcu

Author: tinebp

tests/regression/sgemm_tcu/main.cpp

@@ -235,6 +235,24 @@ class Comparator<vt::bf16> {
   }
 };
 
+template <>
+class Comparator<vt::tf32> {
+public:
+  static uint32_t generate() {
+    auto fvalue = float(rand()) / RAND_MAX;
+    return rv_ftox_s(bit_cast<uint32_t>(fvalue), 8, 10, 0, nullptr);
+  }
+  static bool compare(uint32_t a, uint32_t b, int index, int errors) {
+    if (a != b) {
+      if (errors < MAX_ERRORS) {
+        printf("*** error: [%d] expected=0x%x, actual=0x%x\n", index, b, a);
+      }
+      return false;
+    }
+    return true;
+  }
+};
+
 template <>
 class Comparator<vt::fp32> {
 public:
@@ -311,6 +329,15 @@ struct muladd_t<vt::bf16, vt::bf16> {
   }
 };
 
+template <>
+struct muladd_t<vt::tf32, vt::fp32> {
+  static float eval(uint32_t a, uint32_t b, float c) {
+    auto fa = bit_cast<float>(rv_xtof_s(a, 8, 10, 0, nullptr));
+    auto fb = bit_cast<float>(rv_xtof_s(b, 8, 10, 0, nullptr));
+    return fa * fb + c;
+  }
+};
+
 template <>
 struct muladd_t<vt::int4, vt::int32> {
   static int32_t eval(uint8_t a, uint8_t b, int32_t c) {
@@ -367,61 +394,13 @@ static void matmul_cpu(otype_t *C, const itype_t *A, const itype_t *B, uint32_t
   }
 }
 
-/*
-static void matmul_cpu_sparseA(
-      otype_t*               C,      // [M × N]   output
-      const SparseMat&       A,      // sparse-A
-      const itype_t*         B,      // [K × N]   dense-B
-      uint32_t               N)      // number of columns of B/C
-{
-  const uint32_t M = A.rows;
-  const uint32_t K = A.cols;
-
-  const uint32_t subbytes = 8 / vt::ITYPE::bits;
-
-  // --- helper lambdas to index sparse arrays by row ---
-  auto row_values = [&](uint32_t m) {
-      return A.values.data() + m * (K / 2);   // two kept per block
-  };
-  auto row_meta   = [&](uint32_t m) {
-      return A.meta  .data() + m * (K / 4);
-  };
-
-  for (uint32_t m = 0; m < M; ++m) {
-
-    const itype_t* Avals = row_values(m);
-    const uint8_t* Ameta = row_meta  (m);
-    size_t         v_idx = 0;                 // cursor inside values[]
-
-    for (uint32_t n = 0; n < N; ++n) {
-      otype_t sum(0);
-      for (uint32_t blk = 0; blk < K; blk += 4) {
-        uint8_t mask = *(Ameta++);
-        assert(mask);
-        for (uint32_t i = 0; i < 4; ++i) {
-          if (mask & (1u << i)) {
-            auto a_val = Avals[v_idx++];
-            uint32_t k  = blk + i;                  // logical K index
-            uint32_t kk = subbytes ? k * subbytes   // packed-layout idx
-                                   : k;
-            auto b_val = data_accessor_t<vt::ITYPE>::read(
-                            B, kk * N + n);
-            sum = muladd_t<vt::ITYPE, vt::OTYPE>::eval(a_val, b_val, sum);
-          }
-        }
-      }
-      data_accessor_t<vt::OTYPE>::write(C, m * N + n, sum);
-    }
-  }
-}*/
-
 ///////////////////////////////////////////////////////////////////////////////
 
 const char *kernel_file = "kernel.vxbin";
 
-uint32_t xm = 4;
-uint32_t xn = 8;
-uint32_t xk = 2;
+uint32_t xm = 32;
+uint32_t xn = 32;
+uint32_t xk = 32;
 
 vx_device_h device = nullptr;
 vx_buffer_h A_buffer = nullptr;
@@ -568,9 +547,9 @@ int main(int argc, char *argv[]) {
     return -1;
   }
 
-  uint32_t M = xm * cfg::tileM;
-  uint32_t N = xn * cfg::tileN;
-  uint32_t K = xk = cfg::tileK;
+  uint32_t M = xm;
+  uint32_t N = xn;
+  uint32_t K = xk;
 
   if ((M % cfg::tileM) != 0) {
     std::cout << "Error: M must be a multiple of tensor tileM!" << std::endl;