Merge branch 'master' into compare_commit_performance

mkatliar · Aug 13, 2024 · 7934dfe · 7934dfe
2 parents 64fae3c + 1b0925d
commit 7934dfe
Show file tree

Hide file tree

Showing 99 changed files with 1,289 additions and 968 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
 import glob

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,9 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+#include <bench/Gemm.hpp>
 
-
-#include <benchmark/benchmark.h>
+#include <test/Randomize.hpp>
 
 #include <blaze/Math.h>
 
@@ -28,13 +28,17 @@ namespace blast :: benchmark
         blaze::DynamicMatrix<Real, blaze::columnMajor> C(m, m);
         randomize(C);
 
+        Real alpha, beta;
+        randomize(alpha);
+        randomize(beta);
+
         for (auto _ : state)
-            gemm(C, trans(A), B, 1.0, 1.0);
+            gemm(C, trans(A), B, alpha, beta);
 
-        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/blas/Iamax.cpp b/bench/blas/Iamax.cpp
@@ -43,7 +43,7 @@ namespace blast :: benchmark
     static void BM_iamax(State& state)
     {
         size_t const N = state.range(0);
-        DynamicVector<Real> x(N);
+        blaze::DynamicVector<Real> x(N);
         randomize(x);
 
         for (auto _ : state)

diff --git a/bench/blas/Syrk.cpp b/bench/blas/Syrk.cpp
@@ -5,7 +5,7 @@
 
 
 #include <bench/Benchmark.hpp>
-#include <bench/Complexity.hpp>
+#include <bench/Syrk.hpp>
 
 #include <blaze/Math.h>
 

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/blasfeo/Syrk.cpp b/bench/blasfeo/Syrk.cpp
@@ -4,10 +4,8 @@
 
 #include <blasfeo/Blasfeo.hpp>
 
-
-
 #include <bench/Benchmark.hpp>
-#include <bench/Complexity.hpp>
+#include <bench/Syrk.hpp>
 
 
 namespace blast :: benchmark

diff --git a/bench/blast/math/dense/DynamicGemm.cpp b/bench/blast/math/dense/DynamicGemm.cpp
@@ -3,14 +3,12 @@
 // license that can be found in the LICENSE file.
 
 #include <blast/math/dense/Gemm.hpp>
-
-#include <blaze/math/DynamicMatrix.h>
+#include <blast/math/Matrix.hpp>
+#include <blast/blaze/Math.hpp>
 
 #include <bench/Gemm.hpp>
-#include <test/Randomize.hpp>
 
-#include <random>
-#include <memory>
+#include <test/Randomize.hpp>
 
 
 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, trans(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/DynamicSyrk.cpp b/bench/blast/math/dense/DynamicSyrk.cpp
@@ -7,13 +7,10 @@
 #include <blaze/math/DynamicMatrix.h>
 
 #include <bench/Benchmark.hpp>
-#include <bench/Complexity.hpp>
+#include <bench/Syrk.hpp>
 
 #include <test/Randomize.hpp>
 
-#include <random>
-#include <memory>
-
 
 namespace blast :: benchmark
 {

diff --git a/bench/blast/math/dense/StaticGemm.cpp b/bench/blast/math/dense/StaticGemm.cpp
@@ -3,14 +3,12 @@
 // license that can be found in the LICENSE file.
 
 #include <blast/math/dense/Gemm.hpp>
-
-#include <blaze/math/StaticMatrix.h>
+#include <blast/math/Matrix.hpp>
+#include <blast/blaze/Math.hpp>
 
 #include <bench/Gemm.hpp>
-#include <test/Randomize.hpp>
 
-#include <random>
-#include <memory>
+#include <test/Randomize.hpp>
 
 
 namespace blast :: benchmark
@@ -22,24 +20,27 @@ namespace blast :: benchmark
         size_t constexpr K = M;
 
         StaticMatrix<Real, M, K, columnMajor> A;
-        StaticMatrix<Real, N, K, columnMajor> B;
+        StaticMatrix<Real, K, N, columnMajor> B;
         StaticMatrix<Real, M, N, columnMajor> C;
         StaticMatrix<Real, M, N, columnMajor> D;
+        Real alpha, beta;
 
         randomize(A);
         randomize(B);
         randomize(C);
+        randomize(alpha);
+        randomize(beta);
 
         for (auto _ : state)
         {
-            gemm(0.5, A, B, 0.1, C, D);
+            gemm(alpha, A, trans(B), beta, C, D);
             DoNotOptimize(A);
             DoNotOptimize(B);
             DoNotOptimize(C);
             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/dense/StaticIamax.cpp b/bench/blast/math/dense/StaticIamax.cpp
@@ -14,7 +14,7 @@
 
 #include <blast/math/dense/Iamax.hpp>
 
-#include <blaze/math/DynamicVector.h>
+#include <blast/blaze/Math.hpp>
 
 #include <bench/Iamax.hpp>
 #include <bench/Complexity.hpp>

diff --git a/bench/blast/math/dense/StaticSyrk.cpp b/bench/blast/math/dense/StaticSyrk.cpp
@@ -7,10 +7,9 @@
 #include <blaze/math/StaticMatrix.h>
 
 #include <bench/Benchmark.hpp>
-#include <bench/Complexity.hpp>
+#include <bench/Syrk.hpp>
 
-#include <random>
-#include <memory>
+#include <test/Randomize.hpp>
 
 
 namespace blast :: benchmark

diff --git a/bench/blast/math/dense/StaticTrmm.cpp b/bench/blast/math/dense/StaticTrmm.cpp
@@ -3,15 +3,12 @@
 // license that can be found in the LICENSE file.
 
 #include <blast/math/dense/Trmm.hpp>
-
-#include <blaze/math/StaticMatrix.h>
+#include <blast/math/Matrix.hpp>
+#include <blast/blaze/Math.hpp>
 
 #include <bench/Gemm.hpp>
 #include <test/Randomize.hpp>
 
-#include <random>
-#include <memory>
-
 
 namespace blast :: benchmark
 {

diff --git a/bench/blast/math/panel/DynamicGemm.cpp b/bench/blast/math/panel/DynamicGemm.cpp
@@ -6,10 +6,8 @@
 #include <blast/math/panel/Gemm.hpp>
 
 #include <bench/Gemm.hpp>
-#include <test/Randomize.hpp>
 
-#include <random>
-#include <memory>
+#include <test/Randomize.hpp>
 
 
 namespace blast :: benchmark
@@ -21,25 +19,28 @@ namespace blast :: benchmark
         size_t const N = M;
         size_t const K = M;
 
-        DynamicPanelMatrix<Real> A(M, K);
-        DynamicPanelMatrix<Real> B(N, K);
-        DynamicPanelMatrix<Real> C(M, N);
-        DynamicPanelMatrix<Real> D(M, N);
+        DynamicPanelMatrix<Real, columnMajor> A(M, K);
+        DynamicPanelMatrix<Real, columnMajor> B(N, K);
+        DynamicPanelMatrix<Real, columnMajor> C(M, N);
+        DynamicPanelMatrix<Real, columnMajor> D(M, N);
+        Real alpha, beta;
 
         randomize(A);
         randomize(B);
         randomize(C);
+        randomize(alpha);
+        randomize(beta);
 
         for (auto _ : state)
         {
-            gemm_nt(A, B, C, D);
+            gemm(alpha, A, trans(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/panel/StaticGemm.cpp b/bench/blast/math/panel/StaticGemm.cpp
@@ -3,13 +3,13 @@
 // license that can be found in the LICENSE file.
 
 #include <blast/math/StaticPanelMatrix.hpp>
+#include <blast/math/Matrix.hpp>
 #include <blast/math/panel/Gemm.hpp>
+#include <blast/blaze/Math.hpp>
 
 #include <bench/Gemm.hpp>
-#include <test/Randomize.hpp>
 
-#include <random>
-#include <memory>
+#include <test/Randomize.hpp>
 
 
 namespace blast :: benchmark
@@ -20,25 +20,28 @@ namespace blast :: benchmark
         size_t constexpr N = M;
         size_t constexpr K = M;
 
-        StaticPanelMatrix<Real, M, K> A;
-        StaticPanelMatrix<Real, N, K> B;
-        StaticPanelMatrix<Real, M, N> C;
-        StaticPanelMatrix<Real, M, N> D;
+        StaticPanelMatrix<Real, M, K, columnMajor> A;
+        StaticPanelMatrix<Real, N, K, columnMajor> B;
+        StaticPanelMatrix<Real, M, N, columnMajor> C;
+        StaticPanelMatrix<Real, M, N, columnMajor> D;
+        Real alpha, beta;
 
         randomize(A);
         randomize(B);
         randomize(C);
+        randomize(alpha);
+        randomize(beta);
 
         for (auto _ : state)
         {
-            gemm_nt(A, B, C, D);
+            gemm(alpha, A, trans(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/simd/Load.cpp b/bench/blast/math/simd/Load.cpp
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+#include <blast/math/RegisterMatrix.hpp>
 #include <blast/math/DynamicPanelMatrix.hpp>
 #include <blast/math/dense/DynamicMatrixPointer.hpp>
 #include <blast/math/dense/StaticMatrixPointer.hpp>
@@ -92,4 +93,4 @@ namespace blast :: benchmark
     BENCHMARK_TEMPLATE(BM_RegisterMatrix_load_static_dense, double, 8, 4, columnMajor);
     BENCHMARK_TEMPLATE(BM_RegisterMatrix_load_static_dense, double, 12, 4, columnMajor);
     BENCHMARK_TEMPLATE(BM_RegisterMatrix_load_static_dense, double, 8, 8, columnMajor);
-}
+}
diff --git a/bench/blast/math/simd/Store.cpp b/bench/blast/math/simd/Store.cpp
@@ -5,6 +5,7 @@
 #include <blast/math/DynamicPanelMatrix.hpp>
 #include <blast/math/dense/DynamicMatrixPointer.hpp>
 #include <blast/math/dense/StaticMatrixPointer.hpp>
+#include <blast/math/RegisterMatrix.hpp>
 
 #include <bench/Benchmark.hpp>
 
@@ -98,4 +99,4 @@ namespace blast :: benchmark
     BENCHMARK_TEMPLATE(BM_RegisterMatrix_store_static_dense, double, 8, 4, columnMajor);
     BENCHMARK_TEMPLATE(BM_RegisterMatrix_store_static_dense, double, 12, 4, columnMajor);
     BENCHMARK_TEMPLATE(BM_RegisterMatrix_store_static_dense, double, 8, 8, columnMajor);
-}
+}
diff --git a/bench/blast/math/simd/Trmm.cpp b/bench/blast/math/simd/Trmm.cpp
@@ -2,14 +2,14 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-#include <blast/math/dense/StaticMatrixPointer.hpp>
+#include <blast/math/Matrix.hpp>
 #include <blast/math/RegisterMatrix.hpp>
 
 #include <bench/Benchmark.hpp>
 
 #include <test/Randomize.hpp>
 
-#include <blaze/math/StaticMatrix.h>
+#include <blast/blaze/Math.hpp>
 
 
 namespace blast :: benchmark
@@ -81,4 +81,4 @@ namespace blast :: benchmark
     BENCHMARK_TEMPLATE(BM_RegisterMatrix_trmmRightLower, float, 24, 4, columnMajor);
     BENCHMARK_TEMPLATE(BM_RegisterMatrix_trmmRightLower, float, 16, 5, columnMajor);
     BENCHMARK_TEMPLATE(BM_RegisterMatrix_trmmRightLower, float, 16, 6, columnMajor);
-}
+}