devtools/eigen
1
0
Fork 0
mirror of https://gitlab.com/libeigen/eigen.git synced 2026-04-10 11:34:33 +08:00
Code Issues Packages Projects Releases Wiki Activity

Migrate Eigen benchmarks to the Google benchmark framework

Browse Source 
libeigen/eigen!2132

Closes #3025

Co-authored-by: Rasmus Munk Larsen <rmlarsen@gmail.com>
This commit is contained in:
Rasmus Munk Larsen
2026-02-17 20:51:36 -08:00
parent 740cac97b4
commit 3108f6360e
23 changed files with 1632 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

76
benchmarks/benchmark_blocking_sizes.cpp Normal file
View File

@@ -0,0 +1,76 @@
#include <benchmark/benchmark.h>
#include <cstdint>
bool eigen_use_specific_block_size;
int eigen_block_size_k, eigen_block_size_m, eigen_block_size_n;
#define EIGEN_TEST_SPECIFIC_BLOCKING_SIZES eigen_use_specific_block_size
#define EIGEN_TEST_SPECIFIC_BLOCKING_SIZE_K eigen_block_size_k
#define EIGEN_TEST_SPECIFIC_BLOCKING_SIZE_M eigen_block_size_m
#define EIGEN_TEST_SPECIFIC_BLOCKING_SIZE_N eigen_block_size_n
#include <Eigen/Core>
using namespace Eigen;
typedef MatrixXf MatrixType;
typedef MatrixType::Scalar Scalar;
static void BM_GemmDefaultBlocking(benchmark::State& state) {
int k = state.range(0);
int m = state.range(1);
int n = state.range(2);
eigen_use_specific_block_size = false;
MatrixType lhs = MatrixType::Random(m, k);
MatrixType rhs = MatrixType::Random(k, n);
MatrixType dst = MatrixType::Zero(m, n);
for (auto _ : state) {
dst.noalias() = lhs * rhs;
benchmark::DoNotOptimize(dst.data());
}
state.counters["GFLOPS"] =
benchmark::Counter(2.0 * k * m * n, benchmark::Counter::kIsIterationInvariantRate, benchmark::Counter::kIs1000);
}
static void BM_GemmCustomBlocking(benchmark::State& state) {
int k = state.range(0);
int m = state.range(1);
int n = state.range(2);
int bk = state.range(3);
int bm = state.range(4);
int bn = state.range(5);
eigen_use_specific_block_size = true;
eigen_block_size_k = bk;
eigen_block_size_m = bm;
eigen_block_size_n = bn;
MatrixType lhs = MatrixType::Random(m, k);
MatrixType rhs = MatrixType::Random(k, n);
MatrixType dst = MatrixType::Zero(m, n);
for (auto _ : state) {
dst.noalias() = lhs * rhs;
benchmark::DoNotOptimize(dst.data());
}
state.counters["GFLOPS"] =
benchmark::Counter(2.0 * k * m * n, benchmark::Counter::kIsIterationInvariantRate, benchmark::Counter::kIs1000);
}
static void DefaultBlockingSizes(::benchmark::Benchmark* b) {
for (int s : {64, 128, 256, 512, 1024, 2048}) {
b->Args({s, s, s});
}
}
static void CustomBlockingSizes(::benchmark::Benchmark* b) {
// Test a few product sizes with varying block sizes
for (int s : {256, 512, 1024}) {
for (int bk : {16, 32, 64, 128, 256}) {
if (bk > s) continue;
for (int bm : {16, 32, 64, 128, 256}) {
if (bm > s) continue;
b->Args({s, s, s, bk, bm, s});
}
}
}
}
BENCHMARK(BM_GemmDefaultBlocking)->Apply(DefaultBlockingSizes);
BENCHMARK(BM_GemmCustomBlocking)->Apply(CustomBlockingSizes);