Testing: Defer leading dimension calculation when not specified in YAML (#467)

Benchmarking: Fix run to run variation caused by memory bloating in case
lds not mentioned

The YAML parser's computeMaxMinLegalLD() pre-computed a single
worst-case leading dimension across all cartesian-product parameter
combinations. This over-allocated LD will cause memory bloating.
Replace the parse-time LD computation with a ld=-1 sentinel that
defers resolution to the point of use:
- Remove computeMaxMinLegalLD() from yaml_parser.cc,emit ld=-1
  when LDA/LDB/LDC are absent in YAML
- Update check_valid_params() in test_gemm.cc, test_batch_gemm.cc
  to resolve ld=-1 into the correct per-config minimum LD
  before validating constraints
- Add checkValidGemmParams() in bench_gemm.cc to validate configs
  before fixture allocation, skipping invalid cartesian combinations
  early and avoiding unnecessary Matrix construction
- Fixed testsuite segfaults being caused when negative ld's are passed
- Refactored unit tests to use new sentinel leading dimension = -1

The Matrix constructor handles leadingDim==-1 by computing
the correct value from rows/cols, so the sentinel flows cleanly
through both test and benchmark paths.

AMD-Internal: [CPUPL-8118] [CPUPL-8146]
Signed-off-by: Vishal A <Vishal.Akula@amd.com>

Author: vishal-amd

bench/bench_gemm.cc

@@ -119,6 +119,7 @@ class OptimizedGemmBenchmark : public ConcreteUAL
 
         const size_t alignment = 4096;
 
+        // Create matrices
         A_ = Matrix(a_rows, a_cols, a_type_, layout_, config.lda, transA_,
                     false, alignment);
         B_ = Matrix(b_rows, b_cols, b_type_, layout_, config.ldb, transB_,
@@ -271,6 +272,91 @@ class OptimizedGemmBenchmark : public ConcreteUAL
 // Typedef for DLP backend
 using OptimizedGemmBenchmarkDlp = OptimizedGemmBenchmark<UalDlp>;
 
+// ============================================================================
+// BENCHMARK PARAMETER VALIDATION
+// ============================================================================
+
+/**
+ * @brief Validate GEMM parameters before benchmark registration
+ *
+ * Checks dimension, layout, type, and leading dimension constraints to skip
+ * invalid configurations early, avoiding unnecessary fixture allocation.
+ * Logic mirrors UalRef::checkValidGemmParams but operates directly on
+ * GemmBenchConfig without requiring Matrix objects.
+ *
+ * @param config The benchmark configuration to validate
+ * @return true if parameters are valid, false otherwise
+ */
+static bool
+checkValidGemmParams(const GemmBenchConfig& config)
+{
+    md_t m = config.m;
+    md_t n = config.n;
+    md_t k = config.k;
+
+    // Validate dimensions
+    if (m <= 0 || n <= 0 || k <= 0) {
+        return false;
+    }
+
+    bool row_stored = (config.storage_format == MatrixLayout::ROW_MAJOR);
+    bool col_stored = (config.storage_format == MatrixLayout::COLUMN_MAJOR);
+
+    bool nota = !config.transA;
+    bool notb = !config.transB;
+    bool ta   = config.transA;
+    bool tb   = config.transB;
+
+    // Physical matrix dimensions
+    md_t a_rows = ta ? k : m;
+    md_t a_cols = ta ? m : k;
+    md_t b_rows = tb ? n : k;
+    md_t b_cols = tb ? k : n;
+
+    // LD = -1 means not specified in YAML; compute from dimensions.
+    // Row-major: LD = cols, Col-major: LD = rows.
+    md_t lda = config.lda;
+    md_t ldb = config.ldb;
+    md_t ldc = config.ldc;
+
+    if (lda == -1) {
+        lda = row_stored ? a_cols : a_rows;
+    }
+    if (ldb == -1) {
+        ldb = row_stored ? b_cols : b_rows;
+    }
+    if (ldc == -1) {
+        ldc = row_stored ? n : m;
+    }
+
+    // Validate leading dimensions
+    // Matrix A leading dimension checks
+    if (row_stored && ((nota && (lda < k)) || (ta && (lda < m)))) {
+        return false;
+    }
+    if (col_stored && ((nota && (lda < m)) || (ta && (lda < k)))) {
+        return false;
+    }
+
+    // Matrix B leading dimension checks
+    if (row_stored && ((notb && (ldb < n)) || (tb && (ldb < k)))) {
+        return false;
+    }
+    if (col_stored && ((notb && (ldb < k)) || (tb && (ldb < n)))) {
+        return false;
+    }
+
+    // Matrix C leading dimension checks
+    if (row_stored && (ldc < n)) {
+        return false;
+    }
+    if (col_stored && (ldc < m)) {
+        return false;
+    }
+
+    return true;
+}
+
 // ============================================================================
 // OPTIMIZED BENCHMARK REGISTRATION
 // ============================================================================
@@ -295,7 +381,16 @@ registerOptimizedBenchmarks(const std::vector<GemmBenchConfig>& configs)
         numa_node = std::atoi(numa_env);
     }
 
+    std::cerr << "================================================"
+              << std::endl;
     for (const auto& config : configs) {
+
+        if (!checkValidGemmParams(config)) {
+            std::cerr << "Skipping Invalid Configuration : " << config.name
+                      << std::endl;
+            continue;
+        }
+
         // Create fixture ONCE per benchmark
         auto fixture =
             std::make_unique<OptimizedGemmBenchmarkDlp>(config, numa_node);
@@ -311,6 +406,8 @@ registerOptimizedBenchmarks(const std::vector<GemmBenchConfig>& configs)
             ->Unit(benchmark::kMillisecond)
             ->MinTime(3.0);
     }
+    std::cerr << "================================================"
+              << std::endl;
 }
 
 // ============================================================================
@@ -336,10 +433,10 @@ main(int argc, char** argv)
     std::string yaml_file = parser.getYamlFile();
     if (yaml_file.empty()) {
         yaml_file = BENCH_CONFIG_DIR "/gemm_bench_f32_basic_config.yaml";
-        std::cout << "Using default YAML configuration file: " << yaml_file
+        std::cerr << "Using default YAML configuration file: " << yaml_file
                   << std::endl;
     } else {
-        std::cout << "Using YAML configuration file: " << yaml_file
+        std::cerr << "Using YAML configuration file: " << yaml_file
                   << std::endl;
     }
 
@@ -361,27 +458,27 @@ main(int argc, char** argv)
         return 1;
     }
 
-    std::cout << "=== AOCL-DLP Benchmark ===" << std::endl;
-    std::cout << "Configuration file: " << yaml_file << std::endl;
-    std::cout << "Loaded " << configs.size() << " configurations" << std::endl;
+    std::cerr << "=== AOCL-DLP Benchmark ===" << std::endl;
+    std::cerr << "Configuration file: " << yaml_file << std::endl;
+    std::cerr << "Loaded " << configs.size() << " configurations" << std::endl;
 
 #ifdef DLP_ENABLE_OPENMP
-    std::cout << "OpenMP: Enabled" << std::endl;
-    std::cout << "  OMP_NUM_THREADS = " << omp_get_max_threads() << std::endl;
+    std::cerr << "OpenMP: Enabled" << std::endl;
+    std::cerr << "  OMP_NUM_THREADS = " << omp_get_max_threads() << std::endl;
     char* omp_proc_bind = std::getenv("OMP_PROC_BIND");
     if (omp_proc_bind) {
-        std::cout << "  OMP_PROC_BIND   = " << omp_proc_bind << std::endl;
+        std::cerr << "  OMP_PROC_BIND   = " << omp_proc_bind << std::endl;
     } else {
-        std::cout << "  OMP_PROC_BIND   = (not set)" << std::endl;
+        std::cerr << "  OMP_PROC_BIND   = (not set)" << std::endl;
     }
     char* omp_places = std::getenv("OMP_PLACES");
     if (omp_places) {
-        std::cout << "  OMP_PLACES      = " << omp_places << std::endl;
+        std::cerr << "  OMP_PLACES      = " << omp_places << std::endl;
     } else {
-        std::cout << "  OMP_PLACES      = (not set)" << std::endl;
+        std::cerr << "  OMP_PLACES      = (not set)" << std::endl;
     }
 #else
-    std::cout << "OpenMP: Disabled" << std::endl;
+    std::cerr << "OpenMP: Disabled" << std::endl;
 #endif
 
     // Register all benchmarks

tests/classic/test_batch_gemm.cc

@@ -145,9 +145,9 @@ makeF32Group(md_t         m,
         md_t b_rows = transB ? n : k;
         md_t b_cols = transB ? k : n;
 
-        Matrix A(a_rows, a_cols, MatrixType::f32, layoutA, 0, transA);
-        Matrix B(b_rows, b_cols, MatrixType::f32, layoutB, 0, transB);
-        Matrix C(m, n, MatrixType::f32, layoutC, 0, false);
+        Matrix A(a_rows, a_cols, MatrixType::f32, layoutA, -1, transA);
+        Matrix B(b_rows, b_cols, MatrixType::f32, layoutB, -1, transB);
+        Matrix C(m, n, MatrixType::f32, layoutC, -1, false);
 
         A.fillRandom(static_cast<uint32_t>(42 + seed_offset + i));
         B.fillRandom(static_cast<uint32_t>(142 + seed_offset + i));
@@ -588,6 +588,24 @@ check_valid_batch_params(const BatchGemmTestConfig& config)
             }
         }
 
+        // Physical matrix dimensions
+        md_t a_rows = transA ? k : m;
+        md_t a_cols = transA ? m : k;
+        md_t b_rows = transB ? n : k;
+        md_t b_cols = transB ? k : n;
+
+        // LD < 0 means not specified in YAML; compute from dimensions.
+        // Row-major: LD = cols, Col-major: LD = rows.
+        if (lda == -1) {
+            lda = row_stored ? a_cols : a_rows;
+        }
+        if (ldb == -1) {
+            ldb = row_stored ? b_cols : b_rows;
+        }
+        if (ldc == -1) {
+            ldc = row_stored ? n : m;
+        }
+
         // Leading dimension checks for matrix A
         // Skip for reordered matrices as they have custom layouts
         if (!reorderA) {

tests/classic/test_comprehensive_postops.cc

@@ -256,11 +256,11 @@ TEST_F(ComprehensivePostOpsTest, PostOpsWithGemmIntegrationTest)
         std::cout << "=== PostOps GEMM Integration Test ===" << std::endl;
 
         // Create matrices for testing
-        Matrix A(10, 10, MatrixType::f32, MatrixLayout::ROW_MAJOR, 0, false);
-        Matrix B(10, 10, MatrixType::f32, MatrixLayout::ROW_MAJOR, 0, false);
-        Matrix C_dlp(10, 10, MatrixType::f32, MatrixLayout::ROW_MAJOR, 0,
+        Matrix A(10, 10, MatrixType::f32, MatrixLayout::ROW_MAJOR, -1, false);
+        Matrix B(10, 10, MatrixType::f32, MatrixLayout::ROW_MAJOR, -1, false);
+        Matrix C_dlp(10, 10, MatrixType::f32, MatrixLayout::ROW_MAJOR, -1,
                      false);
-        Matrix C_ref(10, 10, MatrixType::f32, MatrixLayout::ROW_MAJOR, 0,
+        Matrix C_ref(10, 10, MatrixType::f32, MatrixLayout::ROW_MAJOR, -1,
                      false);
 
         // Initialize matrices
@@ -382,9 +382,9 @@ TEST_F(ComprehensivePostOpsTest, BackwardCompatibilityTest)
         std::cout << "  PostOps: CORRECTLY ABSENT" << std::endl;
 
         // Test normal GEMM operation
-        Matrix A(4, 4, MatrixType::f32, MatrixLayout::ROW_MAJOR, 0, false);
-        Matrix B(4, 4, MatrixType::f32, MatrixLayout::ROW_MAJOR, 0, false);
-        Matrix C(4, 4, MatrixType::f32, MatrixLayout::ROW_MAJOR, 0, false);
+        Matrix A(4, 4, MatrixType::f32, MatrixLayout::ROW_MAJOR, -1, false);
+        Matrix B(4, 4, MatrixType::f32, MatrixLayout::ROW_MAJOR, -1, false);
+        Matrix C(4, 4, MatrixType::f32, MatrixLayout::ROW_MAJOR, -1, false);
 
         A.fillValue(0.5f);
         B.fillValue(0.2f);