remove sparse logic in sgemm_tcu

I will add a new test called sgemm_tcu_sparse

Author: EricSongXinLe

tests/regression/sgemm_tcu/main.cpp

@@ -26,7 +26,6 @@
 using namespace vortex;
 namespace vt = tensor;
 
-static bool g_enable_sparse = false;
 ///////////////////////////////////////////////////////////////////////////////
 
 static void convert_row_to_col_major_4bit(uint8_t *dst, uint32_t width, uint32_t height, const uint8_t *src) {
@@ -603,14 +602,6 @@ using cfg = vt::wmma_config_t<NUM_THREADS, vt::ITYPE, vt::OTYPE>;
 using itype_t = typename vt::ITYPE::dtype;
 using otype_t = typename vt::OTYPE::dtype;
 
-struct SparseMat {
-  std::vector<itype_t> values;   // non-zeros
-  std::vector<uint8_t> meta;     // Array of row-masks: 1 byte marks the columns
-                                  // of the 4 elements in the block that are non-zero.
-                                  // e.g. 0b0101 means 2nd and 4th elements are non-zero.
-
-  uint32_t rows, cols;           // original A dims (M × K)
-};
 
 static void matmul_cpu(otype_t *C, const itype_t *A, const itype_t *B, uint32_t M, uint32_t N, uint32_t K) {
   uint32_t subbytes = 8 / vt::ITYPE::bits;
@@ -628,54 +619,6 @@ 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";
@@ -696,8 +639,7 @@ std::string last_build_options;
 
 static void show_usage() {
   std::cout << "Vortex Sgemm TCU Test." << std::endl;
-  std::cout << "Usage: [-m: m] [-n N] [-k: K] [-s] [-h: help]" << std::endl;
-  std::cout << "  -s  Enable 2:4 structured sparsity " << std::endl;
+  std::cout << "Usage: [-m: m] [-n N] [-k: K] [-h: help]" << std::endl;
 }
 
 static void parse_args(int argc, char **argv) {
@@ -713,10 +655,6 @@ static void parse_args(int argc, char **argv) {
     case 'k':
       xk = atoi(optarg);
       break;
-    case 's':
-      g_enable_sparse = true;
-      std::cout << "Sparse mode enabled (-s)" << std::endl;
-      break;
     case 'h':
       show_usage();
       exit(0);
@@ -740,73 +678,12 @@ void cleanup() {
 }
 
 
-static SparseMat pruneAndCompressMatrixA(const std::vector<itype_t>& denseA,
-                                         uint32_t M, uint32_t K) {
-  SparseMat out;
-  out.rows = M;
-  out.cols = K;
-  out.values.reserve(M * K / 2); // Select 2 values every 4 values
-  out.meta.reserve(M * K / 4); // 1 byte for every 4 values
-
-  const itype_t* src = denseA.data();
-
-  for (uint32_t r = 0; r < M; ++r) {
-    for (uint32_t c = 0; c < K; c += 4) {
-      itype_t blk[4] = {src[r * K + c],
-                        src[r * K + c + 1],
-                        src[r * K + c + 2],
-                        src[r * K + c + 3]};
-
-      uint32_t idx[4] = {0, 1, 2, 3};
-      std::sort(idx, idx + 4,
-        [&](uint32_t a, uint32_t b) {
-          return std::abs((int)blk[a]) < std::abs((int)blk[b]);
-        }); //Sort the 4 elements by absolute value, ascending order
-
-      uint8_t keep0 = idx[3];
-      uint8_t keep1 = idx[2]; //idx of largest 2 elements
-
-      out.values.push_back(blk[keep0]);
-      out.values.push_back(blk[keep1]);
-
-      uint8_t m = (1u << keep0) | (1u << keep1);  // e.g. 0b0101
-      out.meta.push_back(m);
-    }
-  }
-  return out;
-}
-
-void test_pruneA() {
-  const uint32_t M = 4, K = 8;
-  std::vector<itype_t> denseA(M * K);
-  for (auto& v : denseA) v = Comparator<vt::ITYPE>::generate();
-
-  auto spA = pruneAndCompressMatrixA(denseA, M, K);
-
-  std::vector<itype_t> recovered(M * K, 0);
-  size_t v_idx = 0, m_idx = 0;
-  for (uint32_t r = 0; r < M; ++r)
-    for (uint32_t c = 0; c < K; c += 4) {
-      uint8_t m = spA.meta[m_idx++];
-      for (uint32_t i = 0; i < 4; ++i)
-        if (m & (1u << i))
-          recovered[r * K + c + i] = spA.values[v_idx++];
-    }
-
-  for (uint32_t i = 0; i < M * K; ++i)
-    assert(recovered[i] == denseA[i] || recovered[i] == 0); //Either the value is preserved or pruned
-  std::cout << "pruneAndCompressMatrixA passed\n";
-}
 
 
 int main(int argc, char *argv[]) {
   // parse command arguments
   parse_args(argc, argv);
 
-  if(g_enable_sparse) {
-    test_pruneA(); // Test the pruning function
-  }
-
   std::srand(50);
 
   // open device connection