- Computational complexity calculated in the same way for all gemm tests

- No hard-coded alpha and beta in static gemm tests
mkatliar · Aug 5, 2024 · e6e519b · e6e519b
1 parent 51bf00a
commit e6e519b
Show file tree

Hide file tree

Showing 12 changed files with 52 additions and 37 deletions.
diff --git a/bench/analysis/dgemm_performance.py b/bench/analysis/dgemm_performance.py
@@ -1,3 +1,5 @@
+import matplotlib
+matplotlib.use("Agg")
 import matplotlib.pyplot as plt
 import json
 

diff --git a/bench/analysis/dgemm_performance_ratio.py b/bench/analysis/dgemm_performance_ratio.py
@@ -1,3 +1,5 @@
+import matplotlib
+matplotlib.use('Agg')
 import matplotlib.pyplot as plt
 import json
 

diff --git a/bench/blas/Gemm.cpp b/bench/blas/Gemm.cpp
@@ -2,9 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-
-
-#include <benchmark/benchmark.h>
+#include <bench/Gemm.hpp>
 
 #include <blaze/Math.h>
 
@@ -31,10 +29,10 @@ namespace blast :: benchmark
         for (auto _ : state)
             gemm(C, trans(A), B, 1.0, 1.0);
 
-        state.counters["flops"] = Counter(2 * m * m * m, Counter::kIsIterationInvariantRate);
+        setCounters(state.counters, complexityGemm(m, m, m));
         state.counters["m"] = m;
     }
 
-    BENCHMARK_TEMPLATE(BM_gemm, double)->DenseRange(1, 50);
-    BENCHMARK_TEMPLATE(BM_gemm, float)->DenseRange(1, 50);
+    BENCHMARK_TEMPLATE(BM_gemm, double)->DenseRange(1, BENCHMARK_MAX_GEMM);
+    BENCHMARK_TEMPLATE(BM_gemm, float)->DenseRange(1, BENCHMARK_MAX_GEMM);
 }
diff --git a/bench/blasfeo/Gemm.cpp b/bench/blasfeo/Gemm.cpp
@@ -7,7 +7,6 @@
 #include <bench/Gemm.hpp>
 
 #include <random>
-#include <memory>
 
 
 namespace blast :: benchmark
@@ -53,7 +52,7 @@ namespace blast :: benchmark
         for (auto _ : state)
             gemm_nt(m, n, k, 1., A, 0, 0, B, 0, 0, 1., C, 0, 0, C, 0, 0);
 
-        state.counters["flops"] = Counter(2 * m * n * k + 3 * m * n, Counter::kIsIterationInvariantRate);
+        setCounters(state.counters, complexityGemm(m, n, k));
         state.counters["m"] = m;
     }
 

diff --git a/bench/blast/math/dense/DynamicGemm.cpp b/bench/blast/math/dense/DynamicGemm.cpp
@@ -4,14 +4,12 @@
 
 #include <blast/math/dense/Gemm.hpp>
 
+#include <bench/Gemm.hpp>
+
 #include <blaze/math/DynamicMatrix.h>
 
-#include <bench/Gemm.hpp>
 #include <test/Randomize.hpp>
 
-#include <random>
-#include <memory>
-
 
 namespace blast :: benchmark
 {
@@ -26,21 +24,24 @@ namespace blast :: benchmark
         DynamicMatrix<Real, columnMajor> B(N, K);
         DynamicMatrix<Real, columnMajor> C(M, N);
         DynamicMatrix<Real, columnMajor> D(M, N);
+        Real alpha, beta;
 
         randomize(A);
         randomize(B);
         randomize(C);
+        randomize(alpha);
+        randomize(beta);
 
         for (auto _ : state)
         {
-            gemm(1., A, trans(B), 1., C, D);
+            gemm(alpha, A, B, beta, C, D);
             DoNotOptimize(A);
             DoNotOptimize(B);
             DoNotOptimize(C);
             DoNotOptimize(D);
         }
 
-        state.counters["flops"] = Counter(2 * M * N * K, Counter::kIsIterationInvariantRate);
+        setCounters(state.counters, complexityGemm(M, N, K));
         state.counters["m"] = M;
     }
 

diff --git a/bench/blast/math/dense/StaticGemm.cpp b/bench/blast/math/dense/StaticGemm.cpp
@@ -4,9 +4,10 @@
 
 #include <blast/math/dense/Gemm.hpp>
 
+#include <bench/Gemm.hpp>
+
 #include <blaze/math/StaticMatrix.h>
 
-#include <bench/Gemm.hpp>
 #include <test/Randomize.hpp>
 
 
@@ -39,7 +40,7 @@ namespace blast :: benchmark
             DoNotOptimize(D);
         }
 
-        state.counters["flops"] = Counter(2 * M * N * K + 3 * M * N, Counter::kIsIterationInvariantRate);
+        setCounters(state.counters, complexityGemm(M, N, K));
         state.counters["m"] = M;
     }
 

diff --git a/bench/blast/math/panel/DynamicGemm.cpp b/bench/blast/math/panel/DynamicGemm.cpp
@@ -2,11 +2,11 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-#include "blast/math/StorageOrder.hpp"
 #include <blast/math/DynamicPanelMatrix.hpp>
 #include <blast/math/panel/Gemm.hpp>
 
 #include <bench/Gemm.hpp>
+
 #include <test/Randomize.hpp>
 
 
@@ -40,7 +40,7 @@ namespace blast :: benchmark
             DoNotOptimize(D);
         }
 
-        state.counters["flops"] = Counter(2 * M * N * K, Counter::kIsIterationInvariantRate);
+        setCounters(state.counters, complexityGemm(M, N, K));
         state.counters["m"] = M;
     }
 

diff --git a/bench/blast/math/panel/StaticGemm.cpp b/bench/blast/math/panel/StaticGemm.cpp
@@ -2,12 +2,11 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-#include "blast/math/StorageOrder.hpp"
 #include <blast/math/StaticPanelMatrix.hpp>
 #include <blast/math/panel/Gemm.hpp>
 
 #include <bench/Gemm.hpp>
-#include <blaze/util/Random.h>
+
 #include <test/Randomize.hpp>
 
 
@@ -40,7 +39,7 @@ namespace blast :: benchmark
             DoNotOptimize(D);
         }
 
-        state.counters["flops"] = Counter(2 * M * N * K, Counter::kIsIterationInvariantRate);
+        setCounters(state.counters, complexityGemm(M, N, K));
         state.counters["m"] = M;
     }
 

diff --git a/bench/blaze/Gemm.cpp b/bench/blaze/Gemm.cpp
@@ -34,7 +34,7 @@ namespace blast :: benchmark
             DoNotOptimize(C);
         }
 
-        state.counters["flops"] = Counter(2 * M * N * K, Counter::kIsIterationInvariantRate);
+        setCounters(state.counters, complexityGemm(M, N, K));
         state.counters["m"] = M;
         state.counters["n"] = N;
         state.counters["k"] = K;
@@ -63,7 +63,7 @@ namespace blast :: benchmark
             DoNotOptimize(C);
         }
 
-        state.counters["flops"] = Counter(2 * m * m * m, Counter::kIsIterationInvariantRate);
+        setCounters(state.counters, complexityGemm(m, m, m));
         state.counters["m"] = m;
     }
 
@@ -90,7 +90,7 @@ namespace blast :: benchmark
                 }
         }
 
-        state.counters["flops"] = Counter(2 * m * m * m, Counter::kIsIterationInvariantRate);
+        setCounters(state.counters, complexityGemm(m, m, m));
         state.counters["m"] = m;
     }
 
@@ -123,7 +123,7 @@ namespace blast :: benchmark
                 }
         }
 
-        state.counters["flops"] = Counter(2 * m * m * m, Counter::kIsIterationInvariantRate);
+        setCounters(state.counters, complexityGemm(m, m, m));
         state.counters["m"] = m;
     }
 

diff --git a/bench/eigen/Gemm.cpp b/bench/eigen/Gemm.cpp
@@ -12,8 +12,6 @@
 
 #include <bench/Gemm.hpp>
 
-#include <vector>
-
 
 namespace blast :: benchmark
 {
@@ -43,7 +41,7 @@ namespace blast :: benchmark
             ::benchmark::DoNotOptimize(C);
         }
 
-        state.counters["flops"] = Counter(2 * M * N * K, Counter::kIsIterationInvariantRate);
+        setCounters(state.counters, complexityGemm(M, N, K));
         state.counters["m"] = M;
         state.counters["n"] = N;
         state.counters["k"] = K;
@@ -72,12 +70,12 @@ namespace blast :: benchmark
             ::benchmark::DoNotOptimize(C);
         }
 
-        state.counters["flops"] = Counter(2 * m * m * m, Counter::kIsIterationInvariantRate);
+        setCounters(state.counters, complexityGemm(m, m, m));
         state.counters["m"] = m;
     }
 
 
-    BENCHMARK_TEMPLATE(BM_gemm_dynamic, double)->DenseRange(1, 50);
+    BENCHMARK_TEMPLATE(BM_gemm_dynamic, double)->DenseRange(1, BENCHMARK_MAX_GEMM);
 
 
 #define BOOST_PP_LOCAL_LIMITS (1, BENCHMARK_MAX_GEMM)

diff --git a/bench/libxsmm/Gemm.cpp b/bench/libxsmm/Gemm.cpp
@@ -2,7 +2,8 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-#include <bench/Benchmark.hpp>
+#include <bench/Gemm.hpp>
+
 #include <test/Randomize.hpp>
 
 #include <libxsmm.h>
@@ -39,7 +40,7 @@ namespace blast :: benchmark
         for (auto _ : state)
             kernel(a.data(), b.data(), c.data());
 
-        state.counters["flops"] = Counter(m * n * k, Counter::kIsIterationInvariantRate);
+        setCounters(state.counters, complexityGemm(m, n, k));
         state.counters["m"] = m;
     }
 
@@ -69,14 +70,14 @@ namespace blast :: benchmark
         for (auto _ : state)
             kernel(a.data(), b.data(), c.data());
 
-        state.counters["flops"] = Counter(2 * m * n * k, Counter::kIsIterationInvariantRate);
+        setCounters(state.counters, complexityGemm(m, n, k));
         state.counters["m"] = m;
     }
 
 
-    BENCHMARK_TEMPLATE(BM_gemm_nn, double)->DenseRange(1, 50);
-    BENCHMARK_TEMPLATE(BM_gemm_nt, double)->DenseRange(1, 50);
+    BENCHMARK_TEMPLATE(BM_gemm_nn, double)->DenseRange(1, BENCHMARK_MAX_GEMM);
+    BENCHMARK_TEMPLATE(BM_gemm_nt, double)->DenseRange(1, BENCHMARK_MAX_GEMM);
 
-    BENCHMARK_TEMPLATE(BM_gemm_nn, float)->DenseRange(1, 50);
-    BENCHMARK_TEMPLATE(BM_gemm_nt, float)->DenseRange(1, 50);
+    BENCHMARK_TEMPLATE(BM_gemm_nn, float)->DenseRange(1, BENCHMARK_MAX_GEMM);
+    BENCHMARK_TEMPLATE(BM_gemm_nt, float)->DenseRange(1, BENCHMARK_MAX_GEMM);
 }
diff --git a/include/bench/Gemm.hpp b/include/bench/Gemm.hpp
@@ -5,5 +5,19 @@
 #pragma once
 
 #include <bench/Benchmark.hpp>
+#include <bench/Complexity.hpp>
 
 #define BENCHMARK_MAX_GEMM 50
+
+
+namespace blast :: benchmark
+{
+    /// @brief Algorithmic complexity of gemm
+    inline Complexity complexityGemm(std::size_t m, std::size_t n, std::size_t k)
+    {
+        return {
+            {"add", (m * n) * (k + 2)},
+            {"mul", (m * n) * (k + 1)},
+        };
+    }
+}