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

Remove benchmark::internal::Benchmark* from all benchmarks

Browse Source 
libeigen/eigen!2332

Co-authored-by: Rasmus Munk Larsen <rlarsen@nvidia.com>
This commit is contained in:
Rasmus Munk Larsen
2026-03-20 17:42:07 -07:00
parent 8115b45e50
commit 9d1e5f3915
32 changed files with 477 additions and 576 deletions
Download Patch File Download Diff File Expand all files Collapse all files

30
benchmarks/Core/bench_block_ops.cpp
View File

@@ -70,20 +70,16 @@ static void BM_LeftCols(benchmark::State& state) {
state.SetBytesProcessed(state.iterations() * n * k * sizeof(Scalar));
}
static void BlockSizes(::benchmark::Benchmark* b) {
// (matrix_size, block_size)
for (int n : {256, 512, 1024}) {
for (int bs : {16, 64, 128}) {
if (bs <= n) b->Args({n, bs});
}
}
}
BENCHMARK(BM_BlockRead<float>)->Apply(BlockSizes)->Name("BlockRead_float");
BENCHMARK(BM_BlockRead<double>)->Apply(BlockSizes)->Name("BlockRead_double");
BENCHMARK(BM_BlockWrite<float>)->Apply(BlockSizes)->Name("BlockWrite_float");
BENCHMARK(BM_BlockWrite<double>)->Apply(BlockSizes)->Name("BlockWrite_double");
BENCHMARK(BM_TopRows<float>)->Apply(BlockSizes)->Name("TopRows_float");
BENCHMARK(BM_TopRows<double>)->Apply(BlockSizes)->Name("TopRows_double");
BENCHMARK(BM_LeftCols<float>)->Apply(BlockSizes)->Name("LeftCols_float");
BENCHMARK(BM_LeftCols<double>)->Apply(BlockSizes)->Name("LeftCols_double");
// (matrix_size, block_size)
// clang-format off
#define BLOCK_SIZES ->ArgsProduct({{256, 512, 1024}, {16, 64, 128}})
BENCHMARK(BM_BlockRead<float>) BLOCK_SIZES ->Name("BlockRead_float");
BENCHMARK(BM_BlockRead<double>) BLOCK_SIZES ->Name("BlockRead_double");
BENCHMARK(BM_BlockWrite<float>) BLOCK_SIZES ->Name("BlockWrite_float");
BENCHMARK(BM_BlockWrite<double>) BLOCK_SIZES ->Name("BlockWrite_double");
BENCHMARK(BM_TopRows<float>) BLOCK_SIZES ->Name("TopRows_float");
BENCHMARK(BM_TopRows<double>) BLOCK_SIZES ->Name("TopRows_double");
BENCHMARK(BM_LeftCols<float>) BLOCK_SIZES ->Name("LeftCols_float");
BENCHMARK(BM_LeftCols<double>) BLOCK_SIZES ->Name("LeftCols_double");
#undef BLOCK_SIZES
// clang-format on

57
benchmarks/Core/bench_broadcasting.cpp
View File

@@ -157,36 +157,35 @@ static void BM_RowwiseBroadcastMul(benchmark::State& state) {
}
// --- Size configurations ---
static void BroadcastSizes(::benchmark::Benchmark* b) {
// Square matrices
for (int n : {64, 128, 256, 512, 1024}) b->Args({n, n});
// Tall-thin (many rows, few cols)
b->Args({10000, 32});
// Short-wide (few rows, many cols)
b->Args({32, 10000});
}
// clang-format off
// Square matrices; tall-thin (many rows, few cols); short-wide (few rows, many cols).
#define BROADCAST_SIZES \
->Args({64, 64})->Args({128, 128})->Args({256, 256})->Args({512, 512})->Args({1024, 1024}) \
->Args({10000, 32})->Args({32, 10000})
// --- Register: float ---
BENCHMARK(BM_ColwiseSum<float>)->Apply(BroadcastSizes)->Name("ColwiseSum_float");
BENCHMARK(BM_ColwiseMean<float>)->Apply(BroadcastSizes)->Name("ColwiseMean_float");
BENCHMARK(BM_ColwiseNorm<float>)->Apply(BroadcastSizes)->Name("ColwiseNorm_float");
BENCHMARK(BM_ColwiseMinCoeff<float>)->Apply(BroadcastSizes)->Name("ColwiseMinCoeff_float");
BENCHMARK(BM_ColwiseMaxCoeff<float>)->Apply(BroadcastSizes)->Name("ColwiseMaxCoeff_float");
BENCHMARK(BM_RowwiseSum<float>)->Apply(BroadcastSizes)->Name("RowwiseSum_float");
BENCHMARK(BM_RowwiseNorm<float>)->Apply(BroadcastSizes)->Name("RowwiseNorm_float");
BENCHMARK(BM_RowwiseBroadcastAdd<float>)->Apply(BroadcastSizes)->Name("RowwiseBroadcastAdd_float");
BENCHMARK(BM_ColwiseBroadcastAdd<float>)->Apply(BroadcastSizes)->Name("ColwiseBroadcastAdd_float");
BENCHMARK(BM_RowwiseBroadcastMul<float>)->Apply(BroadcastSizes)->Name("RowwiseBroadcastMul_float");
BENCHMARK(BM_ColwiseSum<float>) BROADCAST_SIZES ->Name("ColwiseSum_float");
BENCHMARK(BM_ColwiseMean<float>) BROADCAST_SIZES ->Name("ColwiseMean_float");
BENCHMARK(BM_ColwiseNorm<float>) BROADCAST_SIZES ->Name("ColwiseNorm_float");
BENCHMARK(BM_ColwiseMinCoeff<float>) BROADCAST_SIZES ->Name("ColwiseMinCoeff_float");
BENCHMARK(BM_ColwiseMaxCoeff<float>) BROADCAST_SIZES ->Name("ColwiseMaxCoeff_float");
BENCHMARK(BM_RowwiseSum<float>) BROADCAST_SIZES ->Name("RowwiseSum_float");
BENCHMARK(BM_RowwiseNorm<float>) BROADCAST_SIZES ->Name("RowwiseNorm_float");
BENCHMARK(BM_RowwiseBroadcastAdd<float>) BROADCAST_SIZES ->Name("RowwiseBroadcastAdd_float");
BENCHMARK(BM_ColwiseBroadcastAdd<float>) BROADCAST_SIZES ->Name("ColwiseBroadcastAdd_float");
BENCHMARK(BM_RowwiseBroadcastMul<float>) BROADCAST_SIZES ->Name("RowwiseBroadcastMul_float");
// --- Register: double ---
BENCHMARK(BM_ColwiseSum<double>)->Apply(BroadcastSizes)->Name("ColwiseSum_double");
BENCHMARK(BM_ColwiseMean<double>)->Apply(BroadcastSizes)->Name("ColwiseMean_double");
BENCHMARK(BM_ColwiseNorm<double>)->Apply(BroadcastSizes)->Name("ColwiseNorm_double");
BENCHMARK(BM_ColwiseMinCoeff<double>)->Apply(BroadcastSizes)->Name("ColwiseMinCoeff_double");
BENCHMARK(BM_ColwiseMaxCoeff<double>)->Apply(BroadcastSizes)->Name("ColwiseMaxCoeff_double");
BENCHMARK(BM_RowwiseSum<double>)->Apply(BroadcastSizes)->Name("RowwiseSum_double");
BENCHMARK(BM_RowwiseNorm<double>)->Apply(BroadcastSizes)->Name("RowwiseNorm_double");
BENCHMARK(BM_RowwiseBroadcastAdd<double>)->Apply(BroadcastSizes)->Name("RowwiseBroadcastAdd_double");
BENCHMARK(BM_ColwiseBroadcastAdd<double>)->Apply(BroadcastSizes)->Name("ColwiseBroadcastAdd_double");
BENCHMARK(BM_RowwiseBroadcastMul<double>)->Apply(BroadcastSizes)->Name("RowwiseBroadcastMul_double");
BENCHMARK(BM_ColwiseSum<double>) BROADCAST_SIZES ->Name("ColwiseSum_double");
BENCHMARK(BM_ColwiseMean<double>) BROADCAST_SIZES ->Name("ColwiseMean_double");
BENCHMARK(BM_ColwiseNorm<double>) BROADCAST_SIZES ->Name("ColwiseNorm_double");
BENCHMARK(BM_ColwiseMinCoeff<double>) BROADCAST_SIZES ->Name("ColwiseMinCoeff_double");
BENCHMARK(BM_ColwiseMaxCoeff<double>) BROADCAST_SIZES ->Name("ColwiseMaxCoeff_double");
BENCHMARK(BM_RowwiseSum<double>) BROADCAST_SIZES ->Name("RowwiseSum_double");
BENCHMARK(BM_RowwiseNorm<double>) BROADCAST_SIZES ->Name("RowwiseNorm_double");
BENCHMARK(BM_RowwiseBroadcastAdd<double>) BROADCAST_SIZES ->Name("RowwiseBroadcastAdd_double");
BENCHMARK(BM_ColwiseBroadcastAdd<double>) BROADCAST_SIZES ->Name("ColwiseBroadcastAdd_double");
BENCHMARK(BM_RowwiseBroadcastMul<double>) BROADCAST_SIZES ->Name("RowwiseBroadcastMul_double");
#undef BROADCAST_SIZES
// clang-format on

33
benchmarks/Core/bench_construction.cpp
View File

@@ -99,27 +99,26 @@ static void BM_FixedSetIdentity(benchmark::State& state) {
// --- Size configurations ---
static void DynamicSizes(::benchmark::Benchmark* b) {
for (int n : {4, 8, 16, 32, 64, 128, 256, 512, 1024}) b->Arg(n);
}
static void VectorSizes(::benchmark::Benchmark* b) {
for (int n : {64, 256, 1024, 4096, 16384, 65536}) b->Arg(n);
}
// clang-format off
#define DYNAMIC_SIZES ->Arg(4)->Arg(8)->Arg(16)->Arg(32)->Arg(64)->Arg(128)->Arg(256)->Arg(512)->Arg(1024)
#define VECTOR_SIZES ->Arg(64)->Arg(256)->Arg(1024)->Arg(4096)->Arg(16384)->Arg(65536)
// --- Register: dynamic float ---
BENCHMARK(BM_SetZero<float>)->Apply(DynamicSizes)->Name("SetZero_float");
BENCHMARK(BM_SetRandom<float>)->Apply(DynamicSizes)->Name("SetRandom_float");
BENCHMARK(BM_SetIdentity<float>)->Apply(DynamicSizes)->Name("SetIdentity_float");
BENCHMARK(BM_SetConstant<float>)->Apply(DynamicSizes)->Name("SetConstant_float");
BENCHMARK(BM_LinSpaced<float>)->Apply(VectorSizes)->Name("LinSpaced_float");
BENCHMARK(BM_SetZero<float>) DYNAMIC_SIZES ->Name("SetZero_float");
BENCHMARK(BM_SetRandom<float>) DYNAMIC_SIZES ->Name("SetRandom_float");
BENCHMARK(BM_SetIdentity<float>) DYNAMIC_SIZES ->Name("SetIdentity_float");
BENCHMARK(BM_SetConstant<float>) DYNAMIC_SIZES ->Name("SetConstant_float");
BENCHMARK(BM_LinSpaced<float>) VECTOR_SIZES ->Name("LinSpaced_float");
// --- Register: dynamic double ---
BENCHMARK(BM_SetZero<double>)->Apply(DynamicSizes)->Name("SetZero_double");
BENCHMARK(BM_SetRandom<double>)->Apply(DynamicSizes)->Name("SetRandom_double");
BENCHMARK(BM_SetIdentity<double>)->Apply(DynamicSizes)->Name("SetIdentity_double");
BENCHMARK(BM_SetConstant<double>)->Apply(DynamicSizes)->Name("SetConstant_double");
BENCHMARK(BM_LinSpaced<double>)->Apply(VectorSizes)->Name("LinSpaced_double");
BENCHMARK(BM_SetZero<double>) DYNAMIC_SIZES ->Name("SetZero_double");
BENCHMARK(BM_SetRandom<double>) DYNAMIC_SIZES ->Name("SetRandom_double");
BENCHMARK(BM_SetIdentity<double>) DYNAMIC_SIZES ->Name("SetIdentity_double");
BENCHMARK(BM_SetConstant<double>) DYNAMIC_SIZES ->Name("SetConstant_double");
BENCHMARK(BM_LinSpaced<double>) VECTOR_SIZES ->Name("LinSpaced_double");
#undef DYNAMIC_SIZES
#undef VECTOR_SIZES
// --- Register: fixed-size float ---
BENCHMARK(BM_FixedSetZero<float, 2>)->Name("FixedSetZero_float_2x2");

144
benchmarks/Core/bench_cwise_math.cpp
View File

@@ -130,82 +130,84 @@ BENCH_CWISE_UNARY_COMPLEX(Square, a.square(), -10, 10)
BENCH_CWISE_BINARY_COMPLEX(Mul, a* b, -10, 10)
BENCH_CWISE_BINARY_COMPLEX(Div, a / b, -10, 10)
static void CwiseSizes(::benchmark::Benchmark* b) {
for (int n : {1024, 4096, 16384, 65536, 262144, 1048576}) b->Arg(n);
}
// clang-format off
#define CWISE_SIZES ->Arg(1024)->Arg(4096)->Arg(16384)->Arg(65536)->Arg(262144)->Arg(1048576)
// --- Register float ---
BENCHMARK(BM_Exp<float>)->Apply(CwiseSizes)->Name("Exp_float");
BENCHMARK(BM_Log<float>)->Apply(CwiseSizes)->Name("Log_float");
BENCHMARK(BM_Log1p<float>)->Apply(CwiseSizes)->Name("Log1p_float");
BENCHMARK(BM_Log2<float>)->Apply(CwiseSizes)->Name("Log2_float");
BENCHMARK(BM_Sqrt<float>)->Apply(CwiseSizes)->Name("Sqrt_float");
BENCHMARK(BM_Rsqrt<float>)->Apply(CwiseSizes)->Name("Rsqrt_float");
BENCHMARK(BM_Exp2<float>)->Apply(CwiseSizes)->Name("Exp2_float");
BENCHMARK(BM_Expm1<float>)->Apply(CwiseSizes)->Name("Expm1_float");
BENCHMARK(BM_Cbrt<float>)->Apply(CwiseSizes)->Name("Cbrt_float");
BENCHMARK(BM_Sin<float>)->Apply(CwiseSizes)->Name("Sin_float");
BENCHMARK(BM_Cos<float>)->Apply(CwiseSizes)->Name("Cos_float");
BENCHMARK(BM_Tan<float>)->Apply(CwiseSizes)->Name("Tan_float");
BENCHMARK(BM_Asin<float>)->Apply(CwiseSizes)->Name("Asin_float");
BENCHMARK(BM_Acos<float>)->Apply(CwiseSizes)->Name("Acos_float");
BENCHMARK(BM_Atan<float>)->Apply(CwiseSizes)->Name("Atan_float");
BENCHMARK(BM_Tanh<float>)->Apply(CwiseSizes)->Name("Tanh_float");
BENCHMARK(BM_Atanh<float>)->Apply(CwiseSizes)->Name("Atanh_float");
BENCHMARK(BM_Erf<float>)->Apply(CwiseSizes)->Name("Erf_float");
BENCHMARK(BM_Abs<float>)->Apply(CwiseSizes)->Name("Abs_float");
BENCHMARK(BM_Square<float>)->Apply(CwiseSizes)->Name("Square_float");
BENCHMARK(BM_Cube<float>)->Apply(CwiseSizes)->Name("Cube_float");
BENCHMARK(BM_Ceil<float>)->Apply(CwiseSizes)->Name("Ceil_float");
BENCHMARK(BM_Floor<float>)->Apply(CwiseSizes)->Name("Floor_float");
BENCHMARK(BM_Round<float>)->Apply(CwiseSizes)->Name("Round_float");
BENCHMARK(BM_Rint<float>)->Apply(CwiseSizes)->Name("Rint_float");
BENCHMARK(BM_Trunc<float>)->Apply(CwiseSizes)->Name("Trunc_float");
BENCHMARK(BM_Sigmoid<float>)->Apply(CwiseSizes)->Name("Sigmoid_float");
BENCHMARK(BM_Pow<float>)->Apply(CwiseSizes)->Name("Pow_float");
BENCHMARK(BM_Exp<float>) CWISE_SIZES ->Name("Exp_float");
BENCHMARK(BM_Log<float>) CWISE_SIZES ->Name("Log_float");
BENCHMARK(BM_Log1p<float>) CWISE_SIZES ->Name("Log1p_float");
BENCHMARK(BM_Log2<float>) CWISE_SIZES ->Name("Log2_float");
BENCHMARK(BM_Sqrt<float>) CWISE_SIZES ->Name("Sqrt_float");
BENCHMARK(BM_Rsqrt<float>) CWISE_SIZES ->Name("Rsqrt_float");
BENCHMARK(BM_Exp2<float>) CWISE_SIZES ->Name("Exp2_float");
BENCHMARK(BM_Expm1<float>) CWISE_SIZES ->Name("Expm1_float");
BENCHMARK(BM_Cbrt<float>) CWISE_SIZES ->Name("Cbrt_float");
BENCHMARK(BM_Sin<float>) CWISE_SIZES ->Name("Sin_float");
BENCHMARK(BM_Cos<float>) CWISE_SIZES ->Name("Cos_float");
BENCHMARK(BM_Tan<float>) CWISE_SIZES ->Name("Tan_float");
BENCHMARK(BM_Asin<float>) CWISE_SIZES ->Name("Asin_float");
BENCHMARK(BM_Acos<float>) CWISE_SIZES ->Name("Acos_float");
BENCHMARK(BM_Atan<float>) CWISE_SIZES ->Name("Atan_float");
BENCHMARK(BM_Tanh<float>) CWISE_SIZES ->Name("Tanh_float");
BENCHMARK(BM_Atanh<float>) CWISE_SIZES ->Name("Atanh_float");
BENCHMARK(BM_Erf<float>) CWISE_SIZES ->Name("Erf_float");
BENCHMARK(BM_Abs<float>) CWISE_SIZES ->Name("Abs_float");
BENCHMARK(BM_Square<float>) CWISE_SIZES ->Name("Square_float");
BENCHMARK(BM_Cube<float>) CWISE_SIZES ->Name("Cube_float");
BENCHMARK(BM_Ceil<float>) CWISE_SIZES ->Name("Ceil_float");
BENCHMARK(BM_Floor<float>) CWISE_SIZES ->Name("Floor_float");
BENCHMARK(BM_Round<float>) CWISE_SIZES ->Name("Round_float");
BENCHMARK(BM_Rint<float>) CWISE_SIZES ->Name("Rint_float");
BENCHMARK(BM_Trunc<float>) CWISE_SIZES ->Name("Trunc_float");
BENCHMARK(BM_Sigmoid<float>) CWISE_SIZES ->Name("Sigmoid_float");
BENCHMARK(BM_Pow<float>) CWISE_SIZES ->Name("Pow_float");
// --- Register double ---
BENCHMARK(BM_Exp<double>)->Apply(CwiseSizes)->Name("Exp_double");
BENCHMARK(BM_Log<double>)->Apply(CwiseSizes)->Name("Log_double");
BENCHMARK(BM_Log1p<double>)->Apply(CwiseSizes)->Name("Log1p_double");
BENCHMARK(BM_Log2<double>)->Apply(CwiseSizes)->Name("Log2_double");
BENCHMARK(BM_Sqrt<double>)->Apply(CwiseSizes)->Name("Sqrt_double");
BENCHMARK(BM_Rsqrt<double>)->Apply(CwiseSizes)->Name("Rsqrt_double");
BENCHMARK(BM_Exp2<double>)->Apply(CwiseSizes)->Name("Exp2_double");
BENCHMARK(BM_Expm1<double>)->Apply(CwiseSizes)->Name("Expm1_double");
BENCHMARK(BM_Cbrt<double>)->Apply(CwiseSizes)->Name("Cbrt_double");
BENCHMARK(BM_Sin<double>)->Apply(CwiseSizes)->Name("Sin_double");
BENCHMARK(BM_Cos<double>)->Apply(CwiseSizes)->Name("Cos_double");
BENCHMARK(BM_Tan<double>)->Apply(CwiseSizes)->Name("Tan_double");
BENCHMARK(BM_Asin<double>)->Apply(CwiseSizes)->Name("Asin_double");
BENCHMARK(BM_Acos<double>)->Apply(CwiseSizes)->Name("Acos_double");
BENCHMARK(BM_Atan<double>)->Apply(CwiseSizes)->Name("Atan_double");
BENCHMARK(BM_Tanh<double>)->Apply(CwiseSizes)->Name("Tanh_double");
BENCHMARK(BM_Atanh<double>)->Apply(CwiseSizes)->Name("Atanh_double");
BENCHMARK(BM_Erf<double>)->Apply(CwiseSizes)->Name("Erf_double");
BENCHMARK(BM_Abs<double>)->Apply(CwiseSizes)->Name("Abs_double");
BENCHMARK(BM_Square<double>)->Apply(CwiseSizes)->Name("Square_double");
BENCHMARK(BM_Cube<double>)->Apply(CwiseSizes)->Name("Cube_double");
BENCHMARK(BM_Ceil<double>)->Apply(CwiseSizes)->Name("Ceil_double");
BENCHMARK(BM_Floor<double>)->Apply(CwiseSizes)->Name("Floor_double");
BENCHMARK(BM_Round<double>)->Apply(CwiseSizes)->Name("Round_double");
BENCHMARK(BM_Rint<double>)->Apply(CwiseSizes)->Name("Rint_double");
BENCHMARK(BM_Trunc<double>)->Apply(CwiseSizes)->Name("Trunc_double");
BENCHMARK(BM_Sigmoid<double>)->Apply(CwiseSizes)->Name("Sigmoid_double");
BENCHMARK(BM_Pow<double>)->Apply(CwiseSizes)->Name("Pow_double");
BENCHMARK(BM_Exp<double>) CWISE_SIZES ->Name("Exp_double");
BENCHMARK(BM_Log<double>) CWISE_SIZES ->Name("Log_double");
BENCHMARK(BM_Log1p<double>) CWISE_SIZES ->Name("Log1p_double");
BENCHMARK(BM_Log2<double>) CWISE_SIZES ->Name("Log2_double");
BENCHMARK(BM_Sqrt<double>) CWISE_SIZES ->Name("Sqrt_double");
BENCHMARK(BM_Rsqrt<double>) CWISE_SIZES ->Name("Rsqrt_double");
BENCHMARK(BM_Exp2<double>) CWISE_SIZES ->Name("Exp2_double");
BENCHMARK(BM_Expm1<double>) CWISE_SIZES ->Name("Expm1_double");
BENCHMARK(BM_Cbrt<double>) CWISE_SIZES ->Name("Cbrt_double");
BENCHMARK(BM_Sin<double>) CWISE_SIZES ->Name("Sin_double");
BENCHMARK(BM_Cos<double>) CWISE_SIZES ->Name("Cos_double");
BENCHMARK(BM_Tan<double>) CWISE_SIZES ->Name("Tan_double");
BENCHMARK(BM_Asin<double>) CWISE_SIZES ->Name("Asin_double");
BENCHMARK(BM_Acos<double>) CWISE_SIZES ->Name("Acos_double");
BENCHMARK(BM_Atan<double>) CWISE_SIZES ->Name("Atan_double");
BENCHMARK(BM_Tanh<double>) CWISE_SIZES ->Name("Tanh_double");
BENCHMARK(BM_Atanh<double>) CWISE_SIZES ->Name("Atanh_double");
BENCHMARK(BM_Erf<double>) CWISE_SIZES ->Name("Erf_double");
BENCHMARK(BM_Abs<double>) CWISE_SIZES ->Name("Abs_double");
BENCHMARK(BM_Square<double>) CWISE_SIZES ->Name("Square_double");
BENCHMARK(BM_Cube<double>) CWISE_SIZES ->Name("Cube_double");
BENCHMARK(BM_Ceil<double>) CWISE_SIZES ->Name("Ceil_double");
BENCHMARK(BM_Floor<double>) CWISE_SIZES ->Name("Floor_double");
BENCHMARK(BM_Round<double>) CWISE_SIZES ->Name("Round_double");
BENCHMARK(BM_Rint<double>) CWISE_SIZES ->Name("Rint_double");
BENCHMARK(BM_Trunc<double>) CWISE_SIZES ->Name("Trunc_double");
BENCHMARK(BM_Sigmoid<double>) CWISE_SIZES ->Name("Sigmoid_double");
BENCHMARK(BM_Pow<double>) CWISE_SIZES ->Name("Pow_double");
// --- Register complex<float> ---
BENCHMARK(BM_Exp_complex<float>)->Apply(CwiseSizes)->Name("Exp_complexf");
BENCHMARK(BM_Log_complex<float>)->Apply(CwiseSizes)->Name("Log_complexf");
BENCHMARK(BM_Sqrt_complex<float>)->Apply(CwiseSizes)->Name("Sqrt_complexf");
BENCHMARK(BM_Square_complex<float>)->Apply(CwiseSizes)->Name("Square_complexf");
BENCHMARK(BM_Mul_complex<float>)->Apply(CwiseSizes)->Name("Mul_complexf");
BENCHMARK(BM_Div_complex<float>)->Apply(CwiseSizes)->Name("Div_complexf");
BENCHMARK(BM_Exp_complex<float>) CWISE_SIZES ->Name("Exp_complexf");
BENCHMARK(BM_Log_complex<float>) CWISE_SIZES ->Name("Log_complexf");
BENCHMARK(BM_Sqrt_complex<float>) CWISE_SIZES ->Name("Sqrt_complexf");
BENCHMARK(BM_Square_complex<float>) CWISE_SIZES ->Name("Square_complexf");
BENCHMARK(BM_Mul_complex<float>) CWISE_SIZES ->Name("Mul_complexf");
BENCHMARK(BM_Div_complex<float>) CWISE_SIZES ->Name("Div_complexf");
// --- Register complex<double> ---
BENCHMARK(BM_Exp_complex<double>)->Apply(CwiseSizes)->Name("Exp_complexd");
BENCHMARK(BM_Log_complex<double>)->Apply(CwiseSizes)->Name("Log_complexd");
BENCHMARK(BM_Sqrt_complex<double>)->Apply(CwiseSizes)->Name("Sqrt_complexd");
BENCHMARK(BM_Square_complex<double>)->Apply(CwiseSizes)->Name("Square_complexd");
BENCHMARK(BM_Mul_complex<double>)->Apply(CwiseSizes)->Name("Mul_complexd");
BENCHMARK(BM_Div_complex<double>)->Apply(CwiseSizes)->Name("Div_complexd");
BENCHMARK(BM_Exp_complex<double>) CWISE_SIZES ->Name("Exp_complexd");
BENCHMARK(BM_Log_complex<double>) CWISE_SIZES ->Name("Log_complexd");
BENCHMARK(BM_Sqrt_complex<double>) CWISE_SIZES ->Name("Sqrt_complexd");
BENCHMARK(BM_Square_complex<double>) CWISE_SIZES ->Name("Square_complexd");
BENCHMARK(BM_Mul_complex<double>) CWISE_SIZES ->Name("Mul_complexd");
BENCHMARK(BM_Div_complex<double>) CWISE_SIZES ->Name("Div_complexd");
#undef CWISE_SIZES
// clang-format on

24
benchmarks/Core/bench_diagonal.cpp
View File

@@ -67,15 +67,15 @@ static void BM_MatrixTimesDiagonal(benchmark::State& state) {
state.SetBytesProcessed(state.iterations() * 2 * n * n * sizeof(Scalar));
}
static void Sizes(::benchmark::Benchmark* b) {
for (int n : {32, 64, 128, 256, 512, 1024}) b->Arg(n);
}
BENCHMARK(BM_DiagonalExtract<float>)->Apply(Sizes)->Name("DiagonalExtract_float");
BENCHMARK(BM_DiagonalExtract<double>)->Apply(Sizes)->Name("DiagonalExtract_double");
BENCHMARK(BM_DiagonalTimesVector<float>)->Apply(Sizes)->Name("DiagonalTimesVector_float");
BENCHMARK(BM_DiagonalTimesVector<double>)->Apply(Sizes)->Name("DiagonalTimesVector_double");
BENCHMARK(BM_DiagonalTimesMatrix<float>)->Apply(Sizes)->Name("DiagonalTimesMatrix_float");
BENCHMARK(BM_DiagonalTimesMatrix<double>)->Apply(Sizes)->Name("DiagonalTimesMatrix_double");
BENCHMARK(BM_MatrixTimesDiagonal<float>)->Apply(Sizes)->Name("MatrixTimesDiagonal_float");
BENCHMARK(BM_MatrixTimesDiagonal<double>)->Apply(Sizes)->Name("MatrixTimesDiagonal_double");
// clang-format off
#define DIAG_SIZES ->Arg(32)->Arg(64)->Arg(128)->Arg(256)->Arg(512)->Arg(1024)
BENCHMARK(BM_DiagonalExtract<float>) DIAG_SIZES ->Name("DiagonalExtract_float");
BENCHMARK(BM_DiagonalExtract<double>) DIAG_SIZES ->Name("DiagonalExtract_double");
BENCHMARK(BM_DiagonalTimesVector<float>) DIAG_SIZES ->Name("DiagonalTimesVector_float");
BENCHMARK(BM_DiagonalTimesVector<double>) DIAG_SIZES ->Name("DiagonalTimesVector_double");
BENCHMARK(BM_DiagonalTimesMatrix<float>) DIAG_SIZES ->Name("DiagonalTimesMatrix_float");
BENCHMARK(BM_DiagonalTimesMatrix<double>) DIAG_SIZES ->Name("DiagonalTimesMatrix_double");
BENCHMARK(BM_MatrixTimesDiagonal<float>) DIAG_SIZES ->Name("MatrixTimesDiagonal_float");
BENCHMARK(BM_MatrixTimesDiagonal<double>) DIAG_SIZES ->Name("MatrixTimesDiagonal_double");
#undef DIAG_SIZES
// clang-format on

20
benchmarks/Core/bench_dot.cpp
View File

@@ -39,13 +39,13 @@ static void BM_SquaredNorm(benchmark::State& state) {
benchmark::Counter::kIs1000);
}
static void DotSizes(::benchmark::Benchmark* b) {
for (int n : {64, 256, 1024, 4096, 16384, 65536, 262144, 1048576}) b->Arg(n);
}
BENCHMARK(BM_Dot<float>)->Apply(DotSizes)->Name("Dot_float");
BENCHMARK(BM_Dot<double>)->Apply(DotSizes)->Name("Dot_double");
BENCHMARK(BM_Dot<std::complex<float>>)->Apply(DotSizes)->Name("Dot_cfloat");
BENCHMARK(BM_Dot<std::complex<double>>)->Apply(DotSizes)->Name("Dot_cdouble");
BENCHMARK(BM_SquaredNorm<float>)->Apply(DotSizes)->Name("SquaredNorm_float");
BENCHMARK(BM_SquaredNorm<double>)->Apply(DotSizes)->Name("SquaredNorm_double");
// clang-format off
#define DOT_SIZES ->Arg(64)->Arg(256)->Arg(1024)->Arg(4096)->Arg(16384)->Arg(65536)->Arg(262144)->Arg(1048576)
BENCHMARK(BM_Dot<float>) DOT_SIZES ->Name("Dot_float");
BENCHMARK(BM_Dot<double>) DOT_SIZES ->Name("Dot_double");
BENCHMARK(BM_Dot<std::complex<float>>) DOT_SIZES ->Name("Dot_cfloat");
BENCHMARK(BM_Dot<std::complex<double>>) DOT_SIZES ->Name("Dot_cdouble");
BENCHMARK(BM_SquaredNorm<float>) DOT_SIZES ->Name("SquaredNorm_float");
BENCHMARK(BM_SquaredNorm<double>) DOT_SIZES ->Name("SquaredNorm_double");
#undef DOT_SIZES
// clang-format on

40
benchmarks/Core/bench_gemm.cpp
View File

@@ -34,19 +34,19 @@ static void BM_EigenGemm(benchmark::State& state) {
benchmark::Counter(2.0 * m * n * p, benchmark::Counter::kIsIterationInvariantRate, benchmark::Counter::kIs1000);
}
static void GemmSizes(::benchmark::Benchmark* b) {
for (int size : {8, 16, 32, 64, 96, 128, 160, 192, 224, 256, 288, 320, 384, 448, 512, 768, 1024, 1536, 2048, 4096}) {
b->Args({size, size, size});
}
// Non-square sizes
b->Args({64, 64, 1024});
b->Args({1024, 64, 64});
b->Args({64, 1024, 64});
b->Args({256, 256, 1024});
b->Args({1024, 256, 256});
}
BENCHMARK(BM_EigenGemm)->Apply(GemmSizes);
// clang-format off
BENCHMARK(BM_EigenGemm)
->Args({8, 8, 8})->Args({16, 16, 16})->Args({32, 32, 32})
->Args({64, 64, 64})->Args({96, 96, 96})->Args({128, 128, 128})
->Args({160, 160, 160})->Args({192, 192, 192})->Args({224, 224, 224})
->Args({256, 256, 256})->Args({288, 288, 288})->Args({320, 320, 320})
->Args({384, 384, 384})->Args({448, 448, 448})->Args({512, 512, 512})
->Args({768, 768, 768})->Args({1024, 1024, 1024})->Args({1536, 1536, 1536})
->Args({2048, 2048, 2048})->Args({4096, 4096, 4096})
// Non-square sizes
->Args({64, 64, 1024})->Args({1024, 64, 64})->Args({64, 1024, 64})
->Args({256, 256, 1024})->Args({1024, 256, 256});
// clang-format on
#ifdef HAVE_BLAS
extern "C" {
@@ -77,5 +77,17 @@ static void BM_BlasGemm(benchmark::State& state) {
state.counters["GFLOPS"] =
benchmark::Counter(2.0 * m * n * p, benchmark::Counter::kIsIterationInvariantRate, benchmark::Counter::kIs1000);
}
BENCHMARK(BM_BlasGemm)->Apply(GemmSizes);
// clang-format off
BENCHMARK(BM_BlasGemm)
->Args({8, 8, 8})->Args({16, 16, 16})->Args({32, 32, 32})
->Args({64, 64, 64})->Args({96, 96, 96})->Args({128, 128, 128})
->Args({160, 160, 160})->Args({192, 192, 192})->Args({224, 224, 224})
->Args({256, 256, 256})->Args({288, 288, 288})->Args({320, 320, 320})
->Args({384, 384, 384})->Args({448, 448, 448})->Args({512, 512, 512})
->Args({768, 768, 768})->Args({1024, 1024, 1024})->Args({1536, 1536, 1536})
->Args({2048, 2048, 2048})->Args({4096, 4096, 4096})
// Non-square sizes
->Args({64, 64, 1024})->Args({1024, 64, 64})->Args({64, 1024, 64})
->Args({256, 256, 1024})->Args({1024, 256, 256});
// clang-format on
#endif

49
benchmarks/Core/bench_gemv.cpp
View File

@@ -115,43 +115,28 @@ static void BM_GemvAdj(benchmark::State& state) {
// ---------- Size configurations ----------
// All sizes refer to the stored matrix A (m rows, n cols).
static void GemvSizes(::benchmark::Benchmark* b) {
// Square matrices: exercises balanced kernel behavior.
for (int size : {8, 32, 128, 512, 1024}) {
b->Args({size, size});
}
// Tall-thin (m >> n): in ColMajor kernel, the inner vectorized loop over rows
// is long while the outer column loop is short. In RowMajor kernel (transpose),
// there are many rows to process but short dot products.
for (int n : {1, 16}) {
for (int m : {256, 1024}) {
b->Args({m, n});
}
}
// Short-wide (m << n): in ColMajor kernel, the outer column loop is long but
// the inner vectorized loop over rows is short. In RowMajor kernel (transpose),
// there are few rows but long dot products.
for (int m : {1, 16}) {
for (int n : {256, 1024}) {
b->Args({m, n});
}
}
}
// ---------- Register benchmarks ----------
// clang-format off
// Square matrices; tall-thin (m >> n); short-wide (m << n).
#define GEMV_SIZES \
->Args({8, 8})->Args({32, 32})->Args({128, 128})->Args({512, 512})->Args({1024, 1024}) \
->Args({256, 1})->Args({1024, 1})->Args({256, 16})->Args({1024, 16}) \
->Args({1, 256})->Args({1, 1024})->Args({16, 256})->Args({16, 1024})
// Real types: Gemv and GemvTrans exercise the two kernel specializations.
// Conjugation is a no-op for real scalars.
BENCHMARK(BM_Gemv<float>)->Apply(GemvSizes)->Name("Gemv_float");
BENCHMARK(BM_Gemv<double>)->Apply(GemvSizes)->Name("Gemv_double");
BENCHMARK(BM_GemvTrans<float>)->Apply(GemvSizes)->Name("GemvTrans_float");
BENCHMARK(BM_GemvTrans<double>)->Apply(GemvSizes)->Name("GemvTrans_double");
BENCHMARK(BM_Gemv<float>) GEMV_SIZES ->Name("Gemv_float");
BENCHMARK(BM_Gemv<double>) GEMV_SIZES ->Name("Gemv_double");
BENCHMARK(BM_GemvTrans<float>) GEMV_SIZES ->Name("GemvTrans_float");
BENCHMARK(BM_GemvTrans<double>) GEMV_SIZES ->Name("GemvTrans_double");
// Complex types: all four variants exercise distinct kernel code paths.
// Only cfloat is benchmarked since cdouble exercises the same paths but slower.
BENCHMARK(BM_Gemv<std::complex<float>>) GEMV_SIZES ->Name("Gemv_cfloat");
BENCHMARK(BM_GemvTrans<std::complex<float>>) GEMV_SIZES ->Name("GemvTrans_cfloat");
BENCHMARK(BM_GemvConj<std::complex<float>>) GEMV_SIZES ->Name("GemvConj_cfloat");
BENCHMARK(BM_GemvAdj<std::complex<float>>) GEMV_SIZES ->Name("GemvAdj_cfloat");
BENCHMARK(BM_Gemv<std::complex<float>>)->Apply(GemvSizes)->Name("Gemv_cfloat");
BENCHMARK(BM_GemvTrans<std::complex<float>>)->Apply(GemvSizes)->Name("GemvTrans_cfloat");
BENCHMARK(BM_GemvConj<std::complex<float>>)->Apply(GemvSizes)->Name("GemvConj_cfloat");
BENCHMARK(BM_GemvAdj<std::complex<float>>)->Apply(GemvSizes)->Name("GemvAdj_cfloat");
#undef GEMV_SIZES
// clang-format on

32
benchmarks/Core/bench_map.cpp
View File

@@ -83,21 +83,17 @@ static void BM_OwnedGemv(benchmark::State& state) {
benchmark::Counter(2.0 * n * n, benchmark::Counter::kIsIterationInvariantRate, benchmark::Counter::kIs1000);
}
static void SumSizes(::benchmark::Benchmark* b) {
for (int n : {256, 1024, 4096, 16384, 65536, 262144, 1048576}) b->Arg(n);
}
static void GemvSizes(::benchmark::Benchmark* b) {
for (int n : {32, 128, 512, 1024}) b->Arg(n);
}
BENCHMARK(BM_MapContiguousSum<float>)->Apply(SumSizes)->Name("MapContiguousSum_float");
BENCHMARK(BM_MapStridedSum<float>)->Apply(SumSizes)->Name("MapStridedSum_float");
BENCHMARK(BM_OwnedSum<float>)->Apply(SumSizes)->Name("OwnedSum_float");
BENCHMARK(BM_MapContiguousSum<double>)->Apply(SumSizes)->Name("MapContiguousSum_double");
BENCHMARK(BM_MapStridedSum<double>)->Apply(SumSizes)->Name("MapStridedSum_double");
BENCHMARK(BM_OwnedSum<double>)->Apply(SumSizes)->Name("OwnedSum_double");
BENCHMARK(BM_MapGemv<float>)->Apply(GemvSizes)->Name("MapGemv_float");
BENCHMARK(BM_OwnedGemv<float>)->Apply(GemvSizes)->Name("OwnedGemv_float");
BENCHMARK(BM_MapGemv<double>)->Apply(GemvSizes)->Name("MapGemv_double");
BENCHMARK(BM_OwnedGemv<double>)->Apply(GemvSizes)->Name("OwnedGemv_double");
// clang-format off
#define SUM_SIZES ->Arg(256)->Arg(1024)->Arg(4096)->Arg(16384)->Arg(65536)->Arg(262144)->Arg(1048576)
BENCHMARK(BM_MapContiguousSum<float>) SUM_SIZES ->Name("MapContiguousSum_float");
BENCHMARK(BM_MapStridedSum<float>) SUM_SIZES ->Name("MapStridedSum_float");
BENCHMARK(BM_OwnedSum<float>) SUM_SIZES ->Name("OwnedSum_float");
BENCHMARK(BM_MapContiguousSum<double>) SUM_SIZES ->Name("MapContiguousSum_double");
BENCHMARK(BM_MapStridedSum<double>) SUM_SIZES ->Name("MapStridedSum_double");
BENCHMARK(BM_OwnedSum<double>) SUM_SIZES ->Name("OwnedSum_double");
#undef SUM_SIZES
BENCHMARK(BM_MapGemv<float>)->Arg(32)->Arg(128)->Arg(512)->Arg(1024)->Name("MapGemv_float");
BENCHMARK(BM_OwnedGemv<float>)->Arg(32)->Arg(128)->Arg(512)->Arg(1024)->Name("OwnedGemv_float");
BENCHMARK(BM_MapGemv<double>)->Arg(32)->Arg(128)->Arg(512)->Arg(1024)->Name("MapGemv_double");
BENCHMARK(BM_OwnedGemv<double>)->Arg(32)->Arg(128)->Arg(512)->Arg(1024)->Name("OwnedGemv_double");
// clang-format on

58
benchmarks/Core/bench_reductions.cpp
View File

@@ -138,36 +138,36 @@ static void BM_MatrixNorm(benchmark::State& state) {
// --- Size configurations ---
static void VectorSizes(::benchmark::Benchmark* b) {
for (int n : {64, 256, 1024, 4096, 16384, 65536, 262144, 1048576}) b->Arg(n);
}
static void MatrixSizes(::benchmark::Benchmark* b) {
for (int n : {8, 32, 64, 128, 256, 512, 1024}) b->Arg(n);
}
// clang-format off
#define VECTOR_SIZES ->Arg(64)->Arg(256)->Arg(1024)->Arg(4096)->Arg(16384)->Arg(65536)->Arg(262144)->Arg(1048576)
#define MATRIX_SIZES ->Arg(8)->Arg(32)->Arg(64)->Arg(128)->Arg(256)->Arg(512)->Arg(1024)
// --- Register: float ---
BENCHMARK(BM_VectorSum<float>)->Apply(VectorSizes)->Name("VectorSum_float");
BENCHMARK(BM_VectorProd<float>)->Apply(VectorSizes)->Name("VectorProd_float");
BENCHMARK(BM_VectorMinCoeff<float>)->Apply(VectorSizes)->Name("VectorMinCoeff_float");
BENCHMARK(BM_VectorMaxCoeff<float>)->Apply(VectorSizes)->Name("VectorMaxCoeff_float");
BENCHMARK(BM_VectorMean<float>)->Apply(VectorSizes)->Name("VectorMean_float");
BENCHMARK(BM_VectorSquaredNorm<float>)->Apply(VectorSizes)->Name("VectorSquaredNorm_float");
BENCHMARK(BM_VectorNorm<float>)->Apply(VectorSizes)->Name("VectorNorm_float");
BENCHMARK(BM_VectorLpNorm1<float>)->Apply(VectorSizes)->Name("VectorLpNorm1_float");
BENCHMARK(BM_VectorLpNormInf<float>)->Apply(VectorSizes)->Name("VectorLpNormInf_float");
BENCHMARK(BM_MatrixSum<float>)->Apply(MatrixSizes)->Name("MatrixSum_float");
BENCHMARK(BM_MatrixNorm<float>)->Apply(MatrixSizes)->Name("MatrixNorm_float");
BENCHMARK(BM_VectorSum<float>) VECTOR_SIZES ->Name("VectorSum_float");
BENCHMARK(BM_VectorProd<float>) VECTOR_SIZES ->Name("VectorProd_float");
BENCHMARK(BM_VectorMinCoeff<float>) VECTOR_SIZES ->Name("VectorMinCoeff_float");
BENCHMARK(BM_VectorMaxCoeff<float>) VECTOR_SIZES ->Name("VectorMaxCoeff_float");
BENCHMARK(BM_VectorMean<float>) VECTOR_SIZES ->Name("VectorMean_float");
BENCHMARK(BM_VectorSquaredNorm<float>) VECTOR_SIZES ->Name("VectorSquaredNorm_float");
BENCHMARK(BM_VectorNorm<float>) VECTOR_SIZES ->Name("VectorNorm_float");
BENCHMARK(BM_VectorLpNorm1<float>) VECTOR_SIZES ->Name("VectorLpNorm1_float");
BENCHMARK(BM_VectorLpNormInf<float>) VECTOR_SIZES ->Name("VectorLpNormInf_float");
BENCHMARK(BM_MatrixSum<float>) MATRIX_SIZES ->Name("MatrixSum_float");
BENCHMARK(BM_MatrixNorm<float>) MATRIX_SIZES ->Name("MatrixNorm_float");
// --- Register: double ---
BENCHMARK(BM_VectorSum<double>)->Apply(VectorSizes)->Name("VectorSum_double");
BENCHMARK(BM_VectorProd<double>)->Apply(VectorSizes)->Name("VectorProd_double");
BENCHMARK(BM_VectorMinCoeff<double>)->Apply(VectorSizes)->Name("VectorMinCoeff_double");
BENCHMARK(BM_VectorMaxCoeff<double>)->Apply(VectorSizes)->Name("VectorMaxCoeff_double");
BENCHMARK(BM_VectorMean<double>)->Apply(VectorSizes)->Name("VectorMean_double");
BENCHMARK(BM_VectorSquaredNorm<double>)->Apply(VectorSizes)->Name("VectorSquaredNorm_double");
BENCHMARK(BM_VectorNorm<double>)->Apply(VectorSizes)->Name("VectorNorm_double");
BENCHMARK(BM_VectorLpNorm1<double>)->Apply(VectorSizes)->Name("VectorLpNorm1_double");
BENCHMARK(BM_VectorLpNormInf<double>)->Apply(VectorSizes)->Name("VectorLpNormInf_double");
BENCHMARK(BM_MatrixSum<double>)->Apply(MatrixSizes)->Name("MatrixSum_double");
BENCHMARK(BM_MatrixNorm<double>)->Apply(MatrixSizes)->Name("MatrixNorm_double");
BENCHMARK(BM_VectorSum<double>) VECTOR_SIZES ->Name("VectorSum_double");
BENCHMARK(BM_VectorProd<double>) VECTOR_SIZES ->Name("VectorProd_double");
BENCHMARK(BM_VectorMinCoeff<double>) VECTOR_SIZES ->Name("VectorMinCoeff_double");
BENCHMARK(BM_VectorMaxCoeff<double>) VECTOR_SIZES ->Name("VectorMaxCoeff_double");
BENCHMARK(BM_VectorMean<double>) VECTOR_SIZES ->Name("VectorMean_double");
BENCHMARK(BM_VectorSquaredNorm<double>) VECTOR_SIZES ->Name("VectorSquaredNorm_double");
BENCHMARK(BM_VectorNorm<double>) VECTOR_SIZES ->Name("VectorNorm_double");
BENCHMARK(BM_VectorLpNorm1<double>) VECTOR_SIZES ->Name("VectorLpNorm1_double");
BENCHMARK(BM_VectorLpNormInf<double>) VECTOR_SIZES ->Name("VectorLpNormInf_double");
BENCHMARK(BM_MatrixSum<double>) MATRIX_SIZES ->Name("MatrixSum_double");
BENCHMARK(BM_MatrixNorm<double>) MATRIX_SIZES ->Name("MatrixNorm_double");
#undef VECTOR_SIZES
#undef MATRIX_SIZES
// clang-format on

26
benchmarks/Core/bench_selfadjoint_product.cpp
View File

@@ -58,21 +58,11 @@ static void BM_RankUpdate(benchmark::State& state) {
benchmark::Counter(1.0 * n * n * k, benchmark::Counter::kIsIterationInvariantRate, benchmark::Counter::kIs1000);
}
static void SymmSizes(::benchmark::Benchmark* b) {
for (int n : {64, 128, 256, 512, 1024}) b->Arg(n);
}
static void RankUpdateSizes(::benchmark::Benchmark* b) {
for (int n : {64, 128, 256, 512}) {
for (int k : {16, 64, 256}) {
b->Args({n, k});
}
}
}
BENCHMARK(BM_SYMM_Left<float>)->Apply(SymmSizes)->Name("SYMM_Left_float");
BENCHMARK(BM_SYMM_Left<double>)->Apply(SymmSizes)->Name("SYMM_Left_double");
BENCHMARK(BM_SYMM_Right<float>)->Apply(SymmSizes)->Name("SYMM_Right_float");
BENCHMARK(BM_SYMM_Right<double>)->Apply(SymmSizes)->Name("SYMM_Right_double");
BENCHMARK(BM_RankUpdate<float>)->Apply(RankUpdateSizes)->Name("RankUpdate_float");
BENCHMARK(BM_RankUpdate<double>)->Apply(RankUpdateSizes)->Name("RankUpdate_double");
// clang-format off
BENCHMARK(BM_SYMM_Left<float>)->Arg(64)->Arg(128)->Arg(256)->Arg(512)->Arg(1024)->Name("SYMM_Left_float");
BENCHMARK(BM_SYMM_Left<double>)->Arg(64)->Arg(128)->Arg(256)->Arg(512)->Arg(1024)->Name("SYMM_Left_double");
BENCHMARK(BM_SYMM_Right<float>)->Arg(64)->Arg(128)->Arg(256)->Arg(512)->Arg(1024)->Name("SYMM_Right_float");
BENCHMARK(BM_SYMM_Right<double>)->Arg(64)->Arg(128)->Arg(256)->Arg(512)->Arg(1024)->Name("SYMM_Right_double");
BENCHMARK(BM_RankUpdate<float>)->ArgsProduct({{64, 128, 256, 512}, {16, 64, 256}})->Name("RankUpdate_float");
BENCHMARK(BM_RankUpdate<double>)->ArgsProduct({{64, 128, 256, 512}, {16, 64, 256}})->Name("RankUpdate_double");
// clang-format on

16
benchmarks/Core/bench_symv.cpp
View File

@@ -52,11 +52,11 @@ static void BM_SYMV_Upper(benchmark::State& state) {
benchmark::Counter::kIs1000);
}
static void SymvSizes(::benchmark::Benchmark* b) {
for (int n : {8, 16, 32, 64, 128, 256, 512, 1024, 2048}) b->Arg(n);
}
BENCHMARK(BM_SYMV_Lower<float>)->Apply(SymvSizes)->Name("SYMV_Lower_float");
BENCHMARK(BM_SYMV_Lower<double>)->Apply(SymvSizes)->Name("SYMV_Lower_double");
BENCHMARK(BM_SYMV_Upper<float>)->Apply(SymvSizes)->Name("SYMV_Upper_float");
BENCHMARK(BM_SYMV_Upper<double>)->Apply(SymvSizes)->Name("SYMV_Upper_double");
// clang-format off
#define SYMV_SIZES ->Arg(8)->Arg(16)->Arg(32)->Arg(64)->Arg(128)->Arg(256)->Arg(512)->Arg(1024)->Arg(2048)
BENCHMARK(BM_SYMV_Lower<float>) SYMV_SIZES ->Name("SYMV_Lower_float");
BENCHMARK(BM_SYMV_Lower<double>) SYMV_SIZES ->Name("SYMV_Lower_double");
BENCHMARK(BM_SYMV_Upper<float>) SYMV_SIZES ->Name("SYMV_Upper_float");
BENCHMARK(BM_SYMV_Upper<double>) SYMV_SIZES ->Name("SYMV_Upper_double");
#undef SYMV_SIZES
// clang-format on

14
benchmarks/Core/bench_syr.cpp
View File

@@ -49,11 +49,9 @@ static void BM_SYR_Upper(benchmark::State& state) {
benchmark::Counter::kIs1000);
}
static void SyrSizes(::benchmark::Benchmark* b) {
for (int n : {8, 16, 32, 64, 128, 256, 512, 1024, 2048}) b->Arg(n);
}
BENCHMARK(BM_SYR_Lower<float>)->Apply(SyrSizes)->Name("SYR_Lower_float");
BENCHMARK(BM_SYR_Lower<double>)->Apply(SyrSizes)->Name("SYR_Lower_double");
BENCHMARK(BM_SYR_Upper<float>)->Apply(SyrSizes)->Name("SYR_Upper_float");
BENCHMARK(BM_SYR_Upper<double>)->Apply(SyrSizes)->Name("SYR_Upper_double");
// clang-format off
BENCHMARK(BM_SYR_Lower<float>)->Arg(8)->Arg(16)->Arg(32)->Arg(64)->Arg(128)->Arg(256)->Arg(512)->Arg(1024)->Arg(2048)->Name("SYR_Lower_float");
BENCHMARK(BM_SYR_Lower<double>)->Arg(8)->Arg(16)->Arg(32)->Arg(64)->Arg(128)->Arg(256)->Arg(512)->Arg(1024)->Arg(2048)->Name("SYR_Lower_double");
BENCHMARK(BM_SYR_Upper<float>)->Arg(8)->Arg(16)->Arg(32)->Arg(64)->Arg(128)->Arg(256)->Arg(512)->Arg(1024)->Arg(2048)->Name("SYR_Upper_float");
BENCHMARK(BM_SYR_Upper<double>)->Arg(8)->Arg(16)->Arg(32)->Arg(64)->Arg(128)->Arg(256)->Arg(512)->Arg(1024)->Arg(2048)->Name("SYR_Upper_double");
// clang-format on

16
benchmarks/Core/bench_syr2.cpp
View File

@@ -51,11 +51,11 @@ static void BM_SYR2_Upper(benchmark::State& state) {
benchmark::Counter::kIs1000);
}
static void Syr2Sizes(::benchmark::Benchmark* b) {
for (int n : {8, 16, 32, 64, 128, 256, 512, 1024, 2048}) b->Arg(n);
}
BENCHMARK(BM_SYR2_Lower<float>)->Apply(Syr2Sizes)->Name("SYR2_Lower_float");
BENCHMARK(BM_SYR2_Lower<double>)->Apply(Syr2Sizes)->Name("SYR2_Lower_double");
BENCHMARK(BM_SYR2_Upper<float>)->Apply(Syr2Sizes)->Name("SYR2_Upper_float");
BENCHMARK(BM_SYR2_Upper<double>)->Apply(Syr2Sizes)->Name("SYR2_Upper_double");
// clang-format off
#define SYR2_SIZES ->Arg(8)->Arg(16)->Arg(32)->Arg(64)->Arg(128)->Arg(256)->Arg(512)->Arg(1024)->Arg(2048)
BENCHMARK(BM_SYR2_Lower<float>) SYR2_SIZES ->Name("SYR2_Lower_float");
BENCHMARK(BM_SYR2_Lower<double>) SYR2_SIZES ->Name("SYR2_Lower_double");
BENCHMARK(BM_SYR2_Upper<float>) SYR2_SIZES ->Name("SYR2_Upper_float");
BENCHMARK(BM_SYR2_Upper<double>) SYR2_SIZES ->Name("SYR2_Upper_double");
#undef SYR2_SIZES
// clang-format on

25
benchmarks/Core/bench_triangular_product.cpp
View File

@@ -39,18 +39,17 @@ static void BM_TRMM_Right(benchmark::State& state) {
benchmark::Counter(1.0 * n * n * n, benchmark::Counter::kIsIterationInvariantRate, benchmark::Counter::kIs1000);
}
static void TrmmSizes(::benchmark::Benchmark* b) {
for (int n : {64, 128, 256, 512, 1024}) b->Arg(n);
}
// clang-format off
#define TRMM_SIZES ->Arg(64)->Arg(128)->Arg(256)->Arg(512)->Arg(1024)
// Left product
BENCHMARK(BM_TRMM_Left<float, Lower>)->Apply(TrmmSizes)->Name("TRMM_Left_float_Lower");
BENCHMARK(BM_TRMM_Left<float, Upper>)->Apply(TrmmSizes)->Name("TRMM_Left_float_Upper");
BENCHMARK(BM_TRMM_Left<double, Lower>)->Apply(TrmmSizes)->Name("TRMM_Left_double_Lower");
BENCHMARK(BM_TRMM_Left<double, Upper>)->Apply(TrmmSizes)->Name("TRMM_Left_double_Upper");
BENCHMARK(BM_TRMM_Left<float, Lower>) TRMM_SIZES ->Name("TRMM_Left_float_Lower");
BENCHMARK(BM_TRMM_Left<float, Upper>) TRMM_SIZES ->Name("TRMM_Left_float_Upper");
BENCHMARK(BM_TRMM_Left<double, Lower>) TRMM_SIZES ->Name("TRMM_Left_double_Lower");
BENCHMARK(BM_TRMM_Left<double, Upper>) TRMM_SIZES ->Name("TRMM_Left_double_Upper");
// Right product
BENCHMARK(BM_TRMM_Right<float, Lower>)->Apply(TrmmSizes)->Name("TRMM_Right_float_Lower");
BENCHMARK(BM_TRMM_Right<float, Upper>)->Apply(TrmmSizes)->Name("TRMM_Right_float_Upper");
BENCHMARK(BM_TRMM_Right<double, Lower>)->Apply(TrmmSizes)->Name("TRMM_Right_double_Lower");
BENCHMARK(BM_TRMM_Right<double, Upper>)->Apply(TrmmSizes)->Name("TRMM_Right_double_Upper");
BENCHMARK(BM_TRMM_Right<float, Lower>) TRMM_SIZES ->Name("TRMM_Right_float_Lower");
BENCHMARK(BM_TRMM_Right<float, Upper>) TRMM_SIZES ->Name("TRMM_Right_float_Upper");
BENCHMARK(BM_TRMM_Right<double, Lower>) TRMM_SIZES ->Name("TRMM_Right_double_Lower");
BENCHMARK(BM_TRMM_Right<double, Upper>) TRMM_SIZES ->Name("TRMM_Right_double_Upper");
#undef TRMM_SIZES
// clang-format on

24
benchmarks/Core/bench_trmv.cpp
View File

@@ -32,15 +32,15 @@ static void BM_TRMV(benchmark::State& state) {
benchmark::Counter::kIs1000);
}
static void TrmvSizes(::benchmark::Benchmark* b) {
for (int n : {8, 16, 32, 64, 128, 256, 512, 1024, 2048}) b->Arg(n);
}
BENCHMARK(BM_TRMV<float, Lower>)->Apply(TrmvSizes)->Name("TRMV_float_Lower");
BENCHMARK(BM_TRMV<float, Upper>)->Apply(TrmvSizes)->Name("TRMV_float_Upper");
BENCHMARK(BM_TRMV<float, UnitLower>)->Apply(TrmvSizes)->Name("TRMV_float_UnitLower");
BENCHMARK(BM_TRMV<float, UnitUpper>)->Apply(TrmvSizes)->Name("TRMV_float_UnitUpper");
BENCHMARK(BM_TRMV<double, Lower>)->Apply(TrmvSizes)->Name("TRMV_double_Lower");
BENCHMARK(BM_TRMV<double, Upper>)->Apply(TrmvSizes)->Name("TRMV_double_Upper");
BENCHMARK(BM_TRMV<double, UnitLower>)->Apply(TrmvSizes)->Name("TRMV_double_UnitLower");
BENCHMARK(BM_TRMV<double, UnitUpper>)->Apply(TrmvSizes)->Name("TRMV_double_UnitUpper");
// clang-format off
#define TRMV_SIZES ->Arg(8)->Arg(16)->Arg(32)->Arg(64)->Arg(128)->Arg(256)->Arg(512)->Arg(1024)->Arg(2048)
BENCHMARK(BM_TRMV<float, Lower>) TRMV_SIZES ->Name("TRMV_float_Lower");
BENCHMARK(BM_TRMV<float, Upper>) TRMV_SIZES ->Name("TRMV_float_Upper");
BENCHMARK(BM_TRMV<float, UnitLower>) TRMV_SIZES ->Name("TRMV_float_UnitLower");
BENCHMARK(BM_TRMV<float, UnitUpper>) TRMV_SIZES ->Name("TRMV_float_UnitUpper");
BENCHMARK(BM_TRMV<double, Lower>) TRMV_SIZES ->Name("TRMV_double_Lower");
BENCHMARK(BM_TRMV<double, Upper>) TRMV_SIZES ->Name("TRMV_double_Upper");
BENCHMARK(BM_TRMV<double, UnitLower>) TRMV_SIZES ->Name("TRMV_double_UnitLower");
BENCHMARK(BM_TRMV<double, UnitUpper>) TRMV_SIZES ->Name("TRMV_double_UnitUpper");
#undef TRMV_SIZES
// clang-format on

30
benchmarks/Core/bench_trsm.cpp
View File

@@ -61,34 +61,20 @@ static void BM_TRSM_Right(benchmark::State& state) {
state.SetItemsProcessed(state.iterations() * n * n * nrhs);
}
// ---------- Size configurations ----------
static void TrsvSizes(::benchmark::Benchmark* b) {
for (int n : {32, 128, 512}) {
b->Args({n});
}
}
static void TrsmSizes(::benchmark::Benchmark* b) {
for (int n : {64, 256, 512}) {
for (int nrhs : {1, 16, 64}) {
b->Args({n, nrhs});
}
}
}
// ---------- TRSV benchmarks ----------
// Only Lower is benchmarked; Upper exercises the same kernel via transposed storage.
BENCHMARK(BM_TRSV<float, Lower>)->Apply(TrsvSizes)->Name("TRSV_float_Lower");
BENCHMARK(BM_TRSV<double, Lower>)->Apply(TrsvSizes)->Name("TRSV_double_Lower");
BENCHMARK(BM_TRSV<float, Lower>)->Arg(32)->Arg(128)->Arg(512)->Name("TRSV_float_Lower");
BENCHMARK(BM_TRSV<double, Lower>)->Arg(32)->Arg(128)->Arg(512)->Name("TRSV_double_Lower");
// ---------- TRSM Left benchmarks ----------
BENCHMARK(BM_TRSM_Left<float, Lower>)->Apply(TrsmSizes)->Name("TRSM_Left_float_Lower");
BENCHMARK(BM_TRSM_Left<double, Lower>)->Apply(TrsmSizes)->Name("TRSM_Left_double_Lower");
// clang-format off
BENCHMARK(BM_TRSM_Left<float, Lower>)->ArgsProduct({{64, 256, 512}, {1, 16, 64}})->Name("TRSM_Left_float_Lower");
BENCHMARK(BM_TRSM_Left<double, Lower>)->ArgsProduct({{64, 256, 512}, {1, 16, 64}})->Name("TRSM_Left_double_Lower");
// ---------- TRSM Right benchmarks ----------
BENCHMARK(BM_TRSM_Right<float, Lower>)->Apply(TrsmSizes)->Name("TRSM_Right_float_Lower");
BENCHMARK(BM_TRSM_Right<double, Lower>)->Apply(TrsmSizes)->Name("TRSM_Right_double_Lower");
BENCHMARK(BM_TRSM_Right<float, Lower>)->ArgsProduct({{64, 256, 512}, {1, 16, 64}})->Name("TRSM_Right_float_Lower");
BENCHMARK(BM_TRSM_Right<double, Lower>)->ArgsProduct({{64, 256, 512}, {1, 16, 64}})->Name("TRSM_Right_double_Lower");
// clang-format on

32
benchmarks/FFT/bench_fft.cpp
View File

@@ -33,20 +33,18 @@ static void BM_FFT(benchmark::State& state) {
benchmark::Counter(mflops_per_iter, benchmark::Counter::kIsIterationInvariantRate, benchmark::Counter::kIs1000);
}
static void FFTSizes(::benchmark::Benchmark* b) {
for (int n : {64, 128, 256, 512, 1024, 2048, 4096, 8192, 16384, 65536}) {
b->Arg(n);
}
// Non-power-of-2 sizes.
b->Arg(1000);
b->Arg(5000);
}
BENCHMARK(BM_FFT<std::complex<float>, true>)->Apply(FFTSizes);
BENCHMARK(BM_FFT<std::complex<float>, false>)->Apply(FFTSizes);
BENCHMARK(BM_FFT<float, true>)->Apply(FFTSizes);
BENCHMARK(BM_FFT<float, false>)->Apply(FFTSizes);
BENCHMARK(BM_FFT<std::complex<double>, true>)->Apply(FFTSizes);
BENCHMARK(BM_FFT<std::complex<double>, false>)->Apply(FFTSizes);
BENCHMARK(BM_FFT<double, true>)->Apply(FFTSizes);
BENCHMARK(BM_FFT<double, false>)->Apply(FFTSizes);
// clang-format off
#define FFT_SIZES \
->Arg(64)->Arg(128)->Arg(256)->Arg(512)->Arg(1024)->Arg(2048) \
->Arg(4096)->Arg(8192)->Arg(16384)->Arg(65536) \
->Arg(1000)->Arg(5000)
BENCHMARK(BM_FFT<std::complex<float>, true>) FFT_SIZES;
BENCHMARK(BM_FFT<std::complex<float>, false>) FFT_SIZES;
BENCHMARK(BM_FFT<float, true>) FFT_SIZES;
BENCHMARK(BM_FFT<float, false>) FFT_SIZES;
BENCHMARK(BM_FFT<std::complex<double>, true>) FFT_SIZES;
BENCHMARK(BM_FFT<std::complex<double>, false>) FFT_SIZES;
BENCHMARK(BM_FFT<double, true>) FFT_SIZES;
BENCHMARK(BM_FFT<double, false>) FFT_SIZES;
#undef FFT_SIZES
// clang-format on

23
benchmarks/Geometry/bench_geometry.cpp
View File

@@ -14,18 +14,27 @@ struct TransformDim<Matrix<Scalar, Rows, Cols, Options, MaxRows, MaxCols>> {
static constexpr int value = Rows;
};
// Initialize a Transform from a random affine matrix.
template <typename T>
static void initTransformation(T& t) {
constexpr int Dim = TransformDim<T>::value;
Matrix<typename T::Scalar, Dim, Dim + 1> mat;
mat.setRandom();
t = T(mat);
}
// Specialization for plain matrices: just call setRandom().
template <typename Scalar, int Rows, int Cols, int Options, int MaxRows, int MaxCols>
static void initTransformation(Matrix<Scalar, Rows, Cols, Options, MaxRows, MaxCols>& t) {
t.setRandom();
}
template <typename Transformation, int N>
static void BM_TransformData(benchmark::State& state) {
typedef typename Transformation::Scalar Scalar;
constexpr int Dim = TransformDim<Transformation>::value;
Transformation t;
if constexpr (std::is_same_v<Transformation, Matrix<Scalar, Dim, Dim>>) {
t.setRandom();
} else {
Matrix<Scalar, Dim, Dim + 1> mat;
mat.setRandom();
t = Transformation(mat);
}
initTransformation(t);
Matrix<Scalar, Dim, N> data;
data.setRandom();
for (auto _ : state) {

38
benchmarks/LU/bench_lu.cpp
View File

@@ -113,27 +113,17 @@ static void BM_FullPivLU_Solve(benchmark::State& state) {
// --- Size configurations ---
static void SquareSizes(::benchmark::Benchmark* b) {
for (int n : {8, 32, 64, 128, 256, 512, 1024}) b->Arg(n);
}
static void SolveSizes(::benchmark::Benchmark* b) {
for (int n : {32, 128, 512, 1024}) {
for (int nrhs : {1, 16, 64}) {
b->Args({n, nrhs});
}
}
}
BENCHMARK(BM_PartialPivLU_Compute<float>)->Apply(SquareSizes)->Name("PartialPivLU_Compute_float");
BENCHMARK(BM_PartialPivLU_Compute<double>)->Apply(SquareSizes)->Name("PartialPivLU_Compute_double");
BENCHMARK(BM_PartialPivLU_Solve<float>)->Apply(SolveSizes)->Name("PartialPivLU_Solve_float");
BENCHMARK(BM_PartialPivLU_Solve<double>)->Apply(SolveSizes)->Name("PartialPivLU_Solve_double");
BENCHMARK(BM_PartialPivLU_Inverse<float>)->Apply(SquareSizes)->Name("PartialPivLU_Inverse_float");
BENCHMARK(BM_PartialPivLU_Inverse<double>)->Apply(SquareSizes)->Name("PartialPivLU_Inverse_double");
BENCHMARK(BM_PartialPivLU_Determinant<float>)->Apply(SquareSizes)->Name("PartialPivLU_Determinant_float");
BENCHMARK(BM_PartialPivLU_Determinant<double>)->Apply(SquareSizes)->Name("PartialPivLU_Determinant_double");
BENCHMARK(BM_FullPivLU_Compute<float>)->Apply(SquareSizes)->Name("FullPivLU_Compute_float");
BENCHMARK(BM_FullPivLU_Compute<double>)->Apply(SquareSizes)->Name("FullPivLU_Compute_double");
BENCHMARK(BM_FullPivLU_Solve<float>)->Apply(SolveSizes)->Name("FullPivLU_Solve_float");
BENCHMARK(BM_FullPivLU_Solve<double>)->Apply(SolveSizes)->Name("FullPivLU_Solve_double");
// clang-format off
BENCHMARK(BM_PartialPivLU_Compute<float>)->Arg(8)->Arg(32)->Arg(64)->Arg(128)->Arg(256)->Arg(512)->Arg(1024)->Name("PartialPivLU_Compute_float");
BENCHMARK(BM_PartialPivLU_Compute<double>)->Arg(8)->Arg(32)->Arg(64)->Arg(128)->Arg(256)->Arg(512)->Arg(1024)->Name("PartialPivLU_Compute_double");
BENCHMARK(BM_PartialPivLU_Solve<float>)->ArgsProduct({{32, 128, 512, 1024}, {1, 16, 64}})->Name("PartialPivLU_Solve_float");
BENCHMARK(BM_PartialPivLU_Solve<double>)->ArgsProduct({{32, 128, 512, 1024}, {1, 16, 64}})->Name("PartialPivLU_Solve_double");
BENCHMARK(BM_PartialPivLU_Inverse<float>)->Arg(8)->Arg(32)->Arg(64)->Arg(128)->Arg(256)->Arg(512)->Arg(1024)->Name("PartialPivLU_Inverse_float");
BENCHMARK(BM_PartialPivLU_Inverse<double>)->Arg(8)->Arg(32)->Arg(64)->Arg(128)->Arg(256)->Arg(512)->Arg(1024)->Name("PartialPivLU_Inverse_double");
BENCHMARK(BM_PartialPivLU_Determinant<float>)->Arg(8)->Arg(32)->Arg(64)->Arg(128)->Arg(256)->Arg(512)->Arg(1024)->Name("PartialPivLU_Determinant_float");
BENCHMARK(BM_PartialPivLU_Determinant<double>)->Arg(8)->Arg(32)->Arg(64)->Arg(128)->Arg(256)->Arg(512)->Arg(1024)->Name("PartialPivLU_Determinant_double");
BENCHMARK(BM_FullPivLU_Compute<float>)->Arg(8)->Arg(32)->Arg(64)->Arg(128)->Arg(256)->Arg(512)->Arg(1024)->Name("FullPivLU_Compute_float");
BENCHMARK(BM_FullPivLU_Compute<double>)->Arg(8)->Arg(32)->Arg(64)->Arg(128)->Arg(256)->Arg(512)->Arg(1024)->Name("FullPivLU_Compute_double");
BENCHMARK(BM_FullPivLU_Solve<float>)->ArgsProduct({{32, 128, 512, 1024}, {1, 16, 64}})->Name("FullPivLU_Solve_float");
BENCHMARK(BM_FullPivLU_Solve<double>)->ArgsProduct({{32, 128, 512, 1024}, {1, 16, 64}})->Name("FullPivLU_Solve_double");
// clang-format on

18
benchmarks/LU/bench_rcond.cpp
View File

@@ -67,13 +67,11 @@ static void BM_LLT_Rcond(benchmark::State& state) {
// --- Size configurations ---
static void SquareSizes(::benchmark::Benchmark* b) {
for (int n : {8, 32, 64, 128, 256, 512, 1024}) b->Arg(n);
}
BENCHMARK(BM_PartialPivLU_Rcond<float>)->Apply(SquareSizes)->Name("PartialPivLU_Rcond_float");
BENCHMARK(BM_PartialPivLU_Rcond<double>)->Apply(SquareSizes)->Name("PartialPivLU_Rcond_double");
BENCHMARK(BM_FullPivLU_Rcond<float>)->Apply(SquareSizes)->Name("FullPivLU_Rcond_float");
BENCHMARK(BM_FullPivLU_Rcond<double>)->Apply(SquareSizes)->Name("FullPivLU_Rcond_double");
BENCHMARK(BM_LLT_Rcond<float>)->Apply(SquareSizes)->Name("LLT_Rcond_float");
BENCHMARK(BM_LLT_Rcond<double>)->Apply(SquareSizes)->Name("LLT_Rcond_double");
// clang-format off
BENCHMARK(BM_PartialPivLU_Rcond<float>)->Arg(8)->Arg(32)->Arg(64)->Arg(128)->Arg(256)->Arg(512)->Arg(1024)->Name("PartialPivLU_Rcond_float");
BENCHMARK(BM_PartialPivLU_Rcond<double>)->Arg(8)->Arg(32)->Arg(64)->Arg(128)->Arg(256)->Arg(512)->Arg(1024)->Name("PartialPivLU_Rcond_double");
BENCHMARK(BM_FullPivLU_Rcond<float>)->Arg(8)->Arg(32)->Arg(64)->Arg(128)->Arg(256)->Arg(512)->Arg(1024)->Name("FullPivLU_Rcond_float");
BENCHMARK(BM_FullPivLU_Rcond<double>)->Arg(8)->Arg(32)->Arg(64)->Arg(128)->Arg(256)->Arg(512)->Arg(1024)->Name("FullPivLU_Rcond_double");
BENCHMARK(BM_LLT_Rcond<float>)->Arg(8)->Arg(32)->Arg(64)->Arg(128)->Arg(256)->Arg(512)->Arg(1024)->Name("LLT_Rcond_float");
BENCHMARK(BM_LLT_Rcond<double>)->Arg(8)->Arg(32)->Arg(64)->Arg(128)->Arg(256)->Arg(512)->Arg(1024)->Name("LLT_Rcond_double");
// clang-format on

37
benchmarks/QR/bench_qr.cpp
View File

@@ -98,26 +98,25 @@ static void BM_HouseholderQR_Solve(benchmark::State& state) {
// --- Size configurations ---
static void QrSizes(::benchmark::Benchmark* b) {
// Square
for (int n : {32, 64, 128, 256, 512, 1024}) b->Args({n, n});
// Tall-thin
b->Args({1000, 32});
b->Args({1000, 100});
b->Args({10000, 32});
b->Args({10000, 100});
}
// clang-format off
// Square sizes + tall-thin sizes.
#define QR_SIZES \
->Args({32, 32})->Args({64, 64})->Args({128, 128})->Args({256, 256})->Args({512, 512})->Args({1024, 1024}) \
->Args({1000, 32})->Args({1000, 100})->Args({10000, 32})->Args({10000, 100})
// Register: float
BENCHMARK(BM_HouseholderQR<float>)->Apply(QrSizes)->Name("HouseholderQR_float");
BENCHMARK(BM_ColPivHouseholderQR<float>)->Apply(QrSizes)->Name("ColPivHouseholderQR_float");
BENCHMARK(BM_FullPivHouseholderQR<float>)->Apply(QrSizes)->Name("FullPivHouseholderQR_float");
BENCHMARK(BM_COD<float>)->Apply(QrSizes)->Name("COD_float");
BENCHMARK(BM_HouseholderQR_Solve<float>)->Apply(QrSizes)->Name("HouseholderQR_Solve_float");
BENCHMARK(BM_HouseholderQR<float>) QR_SIZES ->Name("HouseholderQR_float");
BENCHMARK(BM_ColPivHouseholderQR<float>) QR_SIZES ->Name("ColPivHouseholderQR_float");
BENCHMARK(BM_FullPivHouseholderQR<float>) QR_SIZES ->Name("FullPivHouseholderQR_float");
BENCHMARK(BM_COD<float>) QR_SIZES ->Name("COD_float");
BENCHMARK(BM_HouseholderQR_Solve<float>) QR_SIZES ->Name("HouseholderQR_Solve_float");
// Register: double
BENCHMARK(BM_HouseholderQR<double>)->Apply(QrSizes)->Name("HouseholderQR_double");
BENCHMARK(BM_ColPivHouseholderQR<double>)->Apply(QrSizes)->Name("ColPivHouseholderQR_double");
BENCHMARK(BM_FullPivHouseholderQR<double>)->Apply(QrSizes)->Name("FullPivHouseholderQR_double");
BENCHMARK(BM_COD<double>)->Apply(QrSizes)->Name("COD_double");
BENCHMARK(BM_HouseholderQR_Solve<double>)->Apply(QrSizes)->Name("HouseholderQR_Solve_double");
BENCHMARK(BM_HouseholderQR<double>) QR_SIZES ->Name("HouseholderQR_double");
BENCHMARK(BM_ColPivHouseholderQR<double>) QR_SIZES ->Name("ColPivHouseholderQR_double");
BENCHMARK(BM_FullPivHouseholderQR<double>) QR_SIZES ->Name("FullPivHouseholderQR_double");
BENCHMARK(BM_COD<double>) QR_SIZES ->Name("COD_double");
BENCHMARK(BM_HouseholderQR_Solve<double>) QR_SIZES ->Name("HouseholderQR_Solve_double");
#undef QR_SIZES
// clang-format on

24
benchmarks/SVD/bench_jacobi_sweep.cpp
View File

@@ -40,23 +40,23 @@ static void BM_JacobiSVD(benchmark::State& state) {
state.SetItemsProcessed(state.iterations());
}
static void Sizes(::benchmark::Benchmark* b) {
for (int s : {32, 64, 128, 192, 256, 384, 512}) b->Args({s});
}
// clang-format off
#define JACOBI_SWEEP_SIZES ->Arg(32)->Arg(64)->Arg(128)->Arg(192)->Arg(256)->Arg(384)->Arg(512)
// float ValuesOnly
BENCHMARK(BM_JacobiSVD<float, 0>)->Apply(Sizes)->Name("Jacobi_float_VO");
BENCHMARK(BM_JacobiSVD<float, 0>) JACOBI_SWEEP_SIZES ->Name("Jacobi_float_VO");
// float ThinUV
BENCHMARK(BM_JacobiSVD<float, ComputeThinU | ComputeThinV>)->Apply(Sizes)->Name("Jacobi_float_UV");
BENCHMARK(BM_JacobiSVD<float, ComputeThinU | ComputeThinV>) JACOBI_SWEEP_SIZES ->Name("Jacobi_float_UV");
// double ValuesOnly
BENCHMARK(BM_JacobiSVD<double, 0>)->Apply(Sizes)->Name("Jacobi_double_VO");
BENCHMARK(BM_JacobiSVD<double, 0>) JACOBI_SWEEP_SIZES ->Name("Jacobi_double_VO");
// double ThinUV
BENCHMARK(BM_JacobiSVD<double, ComputeThinU | ComputeThinV>)->Apply(Sizes)->Name("Jacobi_double_UV");
BENCHMARK(BM_JacobiSVD<double, ComputeThinU | ComputeThinV>) JACOBI_SWEEP_SIZES ->Name("Jacobi_double_UV");
// complex<float> ValuesOnly
BENCHMARK(BM_JacobiSVD<std::complex<float>, 0>)->Apply(Sizes)->Name("Jacobi_cfloat_VO");
BENCHMARK(BM_JacobiSVD<std::complex<float>, 0>) JACOBI_SWEEP_SIZES ->Name("Jacobi_cfloat_VO");
// complex<float> ThinUV
BENCHMARK((BM_JacobiSVD<std::complex<float>, ComputeThinU | ComputeThinV>))->Apply(Sizes)->Name("Jacobi_cfloat_UV");
BENCHMARK((BM_JacobiSVD<std::complex<float>, ComputeThinU | ComputeThinV>)) JACOBI_SWEEP_SIZES ->Name("Jacobi_cfloat_UV");
// complex<double> ValuesOnly
BENCHMARK(BM_JacobiSVD<std::complex<double>, 0>)->Apply(Sizes)->Name("Jacobi_cdouble_VO");
BENCHMARK(BM_JacobiSVD<std::complex<double>, 0>) JACOBI_SWEEP_SIZES ->Name("Jacobi_cdouble_VO");
// complex<double> ThinUV
BENCHMARK((BM_JacobiSVD<std::complex<double>, ComputeThinU | ComputeThinV>))->Apply(Sizes)->Name("Jacobi_cdouble_UV");
BENCHMARK((BM_JacobiSVD<std::complex<double>, ComputeThinU | ComputeThinV>)) JACOBI_SWEEP_SIZES ->Name("Jacobi_cdouble_UV");
#undef JACOBI_SWEEP_SIZES
// clang-format on

57
benchmarks/SVD/bench_svd.cpp
View File

@@ -48,46 +48,41 @@ static void BM_BDCSVD(benchmark::State& state) {
// ---------- Size configurations ----------
// Sizes suitable for JacobiSVD (O(n^2 p), expensive for large n).
static void JacobiSizes(::benchmark::Benchmark* b) {
// Square
for (int s : {4, 8, 16, 32, 64, 128, 256, 512}) b->Args({s, s});
// Tall-skinny
b->Args({100, 4});
b->Args({1000, 4});
b->Args({1000, 10});
}
// Sizes suitable for BDCSVD (divide-and-conquer, faster for large matrices).
static void BDCSizes(::benchmark::Benchmark* b) {
// Square
for (int s : {4, 8, 16, 32, 64, 128, 256, 512, 1024}) b->Args({s, s});
// Tall-skinny (triggers R-bidiagonalization when aspect ratio > 4)
b->Args({100, 4});
b->Args({1000, 4});
b->Args({1000, 10});
b->Args({1000, 100});
b->Args({10000, 10});
b->Args({10000, 100});
}
// ---------- Register benchmarks ----------
// clang-format off
// JacobiSVD sizes: square + tall-skinny (expensive for large n).
#define JACOBI_SIZES \
->Args({4, 4})->Args({8, 8})->Args({16, 16})->Args({32, 32})->Args({64, 64}) \
->Args({128, 128})->Args({256, 256})->Args({512, 512}) \
->Args({100, 4})->Args({1000, 4})->Args({1000, 10})
// BDCSVD sizes: square + tall-skinny (triggers R-bidiagonalization when aspect ratio > 4).
#define BDC_SIZES \
->Args({4, 4})->Args({8, 8})->Args({16, 16})->Args({32, 32})->Args({64, 64}) \
->Args({128, 128})->Args({256, 256})->Args({512, 512})->Args({1024, 1024}) \
->Args({100, 4})->Args({1000, 4})->Args({1000, 10})->Args({1000, 100}) \
->Args({10000, 10})->Args({10000, 100})
// JacobiSVD — float
BENCHMARK(BM_JacobiSVD<float, ComputeThinU | ComputeThinV>)->Apply(JacobiSizes)->Name("JacobiSVD_float_ThinUV");
BENCHMARK(BM_JacobiSVD<float, 0>)->Apply(JacobiSizes)->Name("JacobiSVD_float_ValuesOnly");
BENCHMARK(BM_JacobiSVD<float, ComputeThinU | ComputeThinV>) JACOBI_SIZES ->Name("JacobiSVD_float_ThinUV");
BENCHMARK(BM_JacobiSVD<float, 0>) JACOBI_SIZES ->Name("JacobiSVD_float_ValuesOnly");
// JacobiSVD — double
BENCHMARK(BM_JacobiSVD<double, ComputeThinU | ComputeThinV>)->Apply(JacobiSizes)->Name("JacobiSVD_double_ThinUV");
BENCHMARK(BM_JacobiSVD<double, 0>)->Apply(JacobiSizes)->Name("JacobiSVD_double_ValuesOnly");
BENCHMARK(BM_JacobiSVD<double, ComputeThinU | ComputeThinV>) JACOBI_SIZES ->Name("JacobiSVD_double_ThinUV");
BENCHMARK(BM_JacobiSVD<double, 0>) JACOBI_SIZES ->Name("JacobiSVD_double_ValuesOnly");
// BDCSVD — float
BENCHMARK(BM_BDCSVD<float, ComputeThinU | ComputeThinV>)->Apply(BDCSizes)->Name("BDCSVD_float_ThinUV");
BENCHMARK(BM_BDCSVD<float, 0>)->Apply(BDCSizes)->Name("BDCSVD_float_ValuesOnly");
BENCHMARK(BM_BDCSVD<float, ComputeThinU | ComputeThinV>) BDC_SIZES ->Name("BDCSVD_float_ThinUV");
BENCHMARK(BM_BDCSVD<float, 0>) BDC_SIZES ->Name("BDCSVD_float_ValuesOnly");
// BDCSVD — double
BENCHMARK(BM_BDCSVD<double, ComputeThinU | ComputeThinV>)->Apply(BDCSizes)->Name("BDCSVD_double_ThinUV");
BENCHMARK(BM_BDCSVD<double, 0>)->Apply(BDCSizes)->Name("BDCSVD_double_ValuesOnly");
BENCHMARK(BM_BDCSVD<double, ComputeThinU | ComputeThinV>) BDC_SIZES ->Name("BDCSVD_double_ThinUV");
BENCHMARK(BM_BDCSVD<double, 0>) BDC_SIZES ->Name("BDCSVD_double_ValuesOnly");
#undef JACOBI_SIZES
#undef BDC_SIZES
// clang-format on
// JacobiSVD — QR preconditioner comparison (double, 64x64, ThinUV)
BENCHMARK(BM_JacobiSVD<double, ComputeThinU | ComputeThinV | ColPivHouseholderQRPreconditioner>)

37
benchmarks/Solvers/bench_dense_solvers.cpp
View File

@@ -141,27 +141,16 @@ static void BM_BDCSVD(benchmark::State& state) {
}
}
static void DenseSolverSizes(::benchmark::Benchmark* b) {
// Square sizes
for (int s : {8, 100, 1000}) {
b->Args({s, s});
}
// Tall-skinny sizes
b->Args({10000, 8});
b->Args({10000, 100});
}
BENCHMARK(BM_LLT)->Apply(DenseSolverSizes);
BENCHMARK(BM_LDLT)->Apply(DenseSolverSizes);
BENCHMARK(BM_PartialPivLU)->Apply(DenseSolverSizes);
BENCHMARK(BM_FullPivLU)->Apply(DenseSolverSizes);
BENCHMARK(BM_HouseholderQR)->Apply(DenseSolverSizes);
BENCHMARK(BM_ColPivHouseholderQR)->Apply(DenseSolverSizes);
BENCHMARK(BM_COD)->Apply(DenseSolverSizes);
BENCHMARK(BM_FullPivHouseholderQR)->Apply(DenseSolverSizes);
BENCHMARK(BM_JacobiSVD)->Apply([](::benchmark::Benchmark* b) {
// JacobiSVD is very slow for large matrices
for (int s : {8, 100}) b->Args({s, s});
b->Args({10000, 8});
});
BENCHMARK(BM_BDCSVD)->Apply(DenseSolverSizes);
// clang-format off
BENCHMARK(BM_LLT)->Args({8, 8})->Args({100, 100})->Args({1000, 1000})->Args({10000, 8})->Args({10000, 100});
BENCHMARK(BM_LDLT)->Args({8, 8})->Args({100, 100})->Args({1000, 1000})->Args({10000, 8})->Args({10000, 100});
BENCHMARK(BM_PartialPivLU)->Args({8, 8})->Args({100, 100})->Args({1000, 1000})->Args({10000, 8})->Args({10000, 100});
BENCHMARK(BM_FullPivLU)->Args({8, 8})->Args({100, 100})->Args({1000, 1000})->Args({10000, 8})->Args({10000, 100});
BENCHMARK(BM_HouseholderQR)->Args({8, 8})->Args({100, 100})->Args({1000, 1000})->Args({10000, 8})->Args({10000, 100});
BENCHMARK(BM_ColPivHouseholderQR)->Args({8, 8})->Args({100, 100})->Args({1000, 1000})->Args({10000, 8})->Args({10000, 100});
BENCHMARK(BM_COD)->Args({8, 8})->Args({100, 100})->Args({1000, 1000})->Args({10000, 8})->Args({10000, 100});
BENCHMARK(BM_FullPivHouseholderQR)->Args({8, 8})->Args({100, 100})->Args({1000, 1000})->Args({10000, 8})->Args({10000, 100});
// JacobiSVD is very slow for large matrices
BENCHMARK(BM_JacobiSVD)->Args({8, 8})->Args({100, 100})->Args({10000, 8});
BENCHMARK(BM_BDCSVD)->Args({8, 8})->Args({100, 100})->Args({1000, 1000})->Args({10000, 8})->Args({10000, 100});
// clang-format on

28
benchmarks/Sparse/bench_sparse_solvers.cpp
View File

@@ -158,25 +158,9 @@ static void BM_BiCGSTAB(benchmark::State& state) {
state.counters["iterations"] = solver.iterations();
}
static void DirectSolverSizes(::benchmark::Benchmark* b) {
for (int n : {1000, 5000, 10000, 50000}) {
for (int bw : {5, 20}) {
b->Args({n, bw});
}
}
}
static void IterativeSolverSizes(::benchmark::Benchmark* b) {
for (int n : {1000, 10000, 50000}) {
for (int bw : {5, 20}) {
b->Args({n, bw});
}
}
}
BENCHMARK(BM_SimplicialLLT)->Apply(DirectSolverSizes);
BENCHMARK(BM_SimplicialLDLT)->Apply(DirectSolverSizes);
BENCHMARK(BM_SparseLU)->Apply(DirectSolverSizes);
BENCHMARK(BM_SparseQR)->Apply(DirectSolverSizes);
BENCHMARK(BM_CG)->Apply(IterativeSolverSizes);
BENCHMARK(BM_BiCGSTAB)->Apply(IterativeSolverSizes);
BENCHMARK(BM_SimplicialLLT)->ArgsProduct({{1000, 5000, 10000, 50000}, {5, 20}});
BENCHMARK(BM_SimplicialLDLT)->ArgsProduct({{1000, 5000, 10000, 50000}, {5, 20}});
BENCHMARK(BM_SparseLU)->ArgsProduct({{1000, 5000, 10000, 50000}, {5, 20}});
BENCHMARK(BM_SparseQR)->ArgsProduct({{1000, 5000, 10000, 50000}, {5, 20}});
BENCHMARK(BM_CG)->ArgsProduct({{1000, 10000, 50000}, {5, 20}});
BENCHMARK(BM_BiCGSTAB)->ArgsProduct({{1000, 10000, 50000}, {5, 20}});

12
benchmarks/Sparse/bench_sparse_transpose.cpp
View File

@@ -33,13 +33,5 @@ static void BM_SparseTranspose(benchmark::State& state) {
state.counters["density%"] = density * 100;
}
static void TransposeSizes(::benchmark::Benchmark* b) {
// Args: {size, density*10000}
for (int n : {1000, 10000}) {
for (int d : {100, 50, 10, 4}) { // 1%, 0.5%, 0.1%, 0.04%
b->Args({n, d});
}
}
}
BENCHMARK(BM_SparseTranspose)->Apply(TransposeSizes);
// Args: {size, density*10000}: 1%, 0.5%, 0.1%, 0.04%
BENCHMARK(BM_SparseTranspose)->ArgsProduct({{1000, 10000}, {100, 50, 10, 4}});

10
benchmarks/Sparse/bench_spmm.cpp
View File

@@ -38,12 +38,4 @@ static void BM_SparseMM(benchmark::State& state) {
state.counters["nnz_B"] = sm2.nonZeros();
}
static void SpMMSizes(::benchmark::Benchmark* b) {
for (int n : {1000, 10000}) {
for (int nnz : {4, 6, 10}) {
b->Args({n, nnz});
}
}
}
BENCHMARK(BM_SparseMM)->Apply(SpMMSizes);
BENCHMARK(BM_SparseMM)->ArgsProduct({{1000, 10000}, {4, 6, 10}});

12
benchmarks/Sparse/bench_spmv.cpp
View File

@@ -52,13 +52,5 @@ static void BM_SpMV_Transpose(benchmark::State& state) {
state.counters["nnz"] = sm.nonZeros();
}
static void SpMVSizes(::benchmark::Benchmark* b) {
for (int n : {1000, 10000, 100000}) {
for (int nnz : {7, 20, 50}) {
b->Args({n, nnz});
}
}
}
BENCHMARK(BM_SpMV)->Apply(SpMVSizes);
BENCHMARK(BM_SpMV_Transpose)->Apply(SpMVSizes);
BENCHMARK(BM_SpMV)->ArgsProduct({{1000, 10000, 100000}, {7, 20, 50}});
BENCHMARK(BM_SpMV_Transpose)->ArgsProduct({{1000, 10000, 100000}, {7, 20, 50}});

22
benchmarks/Tuning/bench_aocl.cpp
View File

@@ -71,18 +71,16 @@ static void BM_VectorTanh(benchmark::State& state) {
state.SetBytesProcessed(state.iterations() * n * sizeof(double));
}
static void VectorSizes(::benchmark::Benchmark* b) {
for (int n : {10000, 100000, 1000000, 5000000}) {
b->Arg(n);
}
}
BENCHMARK(BM_VectorExp)->Apply(VectorSizes);
BENCHMARK(BM_VectorSin)->Apply(VectorSizes);
BENCHMARK(BM_VectorCos)->Apply(VectorSizes);
BENCHMARK(BM_VectorSqrt)->Apply(VectorSizes);
BENCHMARK(BM_VectorLog)->Apply(VectorSizes);
BENCHMARK(BM_VectorTanh)->Apply(VectorSizes);
// clang-format off
#define VECTOR_SIZES ->Arg(10000)->Arg(100000)->Arg(1000000)->Arg(5000000)
BENCHMARK(BM_VectorExp) VECTOR_SIZES;
BENCHMARK(BM_VectorSin) VECTOR_SIZES;
BENCHMARK(BM_VectorCos) VECTOR_SIZES;
BENCHMARK(BM_VectorSqrt) VECTOR_SIZES;
BENCHMARK(BM_VectorLog) VECTOR_SIZES;
BENCHMARK(BM_VectorTanh) VECTOR_SIZES;
#undef VECTOR_SIZES
// clang-format on
static void BM_DGEMM(benchmark::State& state) {
int n = state.range(0);

20
benchmarks/Tuning/bench_blas_gemm.cpp
View File

@@ -58,16 +58,14 @@ static void BM_CblasGemm(benchmark::State& state) {
}
#endif
static void GemmSizes(::benchmark::Benchmark* b) {
for (int s : {32, 64, 128, 256, 512, 1024, 2048}) {
b->Args({s, s, s});
}
// Rectangular
b->Args({1000, 100, 1000});
b->Args({100, 1000, 100});
}
BENCHMARK(BM_EigenGemm)->Apply(GemmSizes);
// clang-format off
#define GEMM_SIZES \
->Args({32, 32, 32})->Args({64, 64, 64})->Args({128, 128, 128}) \
->Args({256, 256, 256})->Args({512, 512, 512})->Args({1024, 1024, 1024})->Args({2048, 2048, 2048}) \
->Args({1000, 100, 1000})->Args({100, 1000, 100})
BENCHMARK(BM_EigenGemm) GEMM_SIZES;
#ifdef HAVE_BLAS
BENCHMARK(BM_CblasGemm)->Apply(GemmSizes);
BENCHMARK(BM_CblasGemm) GEMM_SIZES;
#endif
#undef GEMM_SIZES
// clang-format on

45
benchmarks/Tuning/bench_blocking_sizes.cpp
View File

@@ -53,24 +53,29 @@ static void BM_GemmCustomBlocking(benchmark::State& state) {
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});
}
}
// clang-format off
BENCHMARK(BM_GemmDefaultBlocking)
->Args({64, 64, 64})->Args({128, 128, 128})->Args({256, 256, 256})
->Args({512, 512, 512})->Args({1024, 1024, 1024})->Args({2048, 2048, 2048});
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);
// {k, m, n, bk, bm, bn} — all bk/bm values ≤ 256 ≤ min(s), so no filtering needed.
BENCHMARK(BM_GemmCustomBlocking)
// s = 256
->Args({256,256,256,16,16,256})->Args({256,256,256,16,32,256})->Args({256,256,256,16,64,256})->Args({256,256,256,16,128,256})->Args({256,256,256,16,256,256})
->Args({256,256,256,32,16,256})->Args({256,256,256,32,32,256})->Args({256,256,256,32,64,256})->Args({256,256,256,32,128,256})->Args({256,256,256,32,256,256})
->Args({256,256,256,64,16,256})->Args({256,256,256,64,32,256})->Args({256,256,256,64,64,256})->Args({256,256,256,64,128,256})->Args({256,256,256,64,256,256})
->Args({256,256,256,128,16,256})->Args({256,256,256,128,32,256})->Args({256,256,256,128,64,256})->Args({256,256,256,128,128,256})->Args({256,256,256,128,256,256})
->Args({256,256,256,256,16,256})->Args({256,256,256,256,32,256})->Args({256,256,256,256,64,256})->Args({256,256,256,256,128,256})->Args({256,256,256,256,256,256})
// s = 512
->Args({512,512,512,16,16,512})->Args({512,512,512,16,32,512})->Args({512,512,512,16,64,512})->Args({512,512,512,16,128,512})->Args({512,512,512,16,256,512})
->Args({512,512,512,32,16,512})->Args({512,512,512,32,32,512})->Args({512,512,512,32,64,512})->Args({512,512,512,32,128,512})->Args({512,512,512,32,256,512})
->Args({512,512,512,64,16,512})->Args({512,512,512,64,32,512})->Args({512,512,512,64,64,512})->Args({512,512,512,64,128,512})->Args({512,512,512,64,256,512})
->Args({512,512,512,128,16,512})->Args({512,512,512,128,32,512})->Args({512,512,512,128,64,512})->Args({512,512,512,128,128,512})->Args({512,512,512,128,256,512})
->Args({512,512,512,256,16,512})->Args({512,512,512,256,32,512})->Args({512,512,512,256,64,512})->Args({512,512,512,256,128,512})->Args({512,512,512,256,256,512})
// s = 1024
->Args({1024,1024,1024,16,16,1024})->Args({1024,1024,1024,16,32,1024})->Args({1024,1024,1024,16,64,1024})->Args({1024,1024,1024,16,128,1024})->Args({1024,1024,1024,16,256,1024})
->Args({1024,1024,1024,32,16,1024})->Args({1024,1024,1024,32,32,1024})->Args({1024,1024,1024,32,64,1024})->Args({1024,1024,1024,32,128,1024})->Args({1024,1024,1024,32,256,1024})
->Args({1024,1024,1024,64,16,1024})->Args({1024,1024,1024,64,32,1024})->Args({1024,1024,1024,64,64,1024})->Args({1024,1024,1024,64,128,1024})->Args({1024,1024,1024,64,256,1024})
->Args({1024,1024,1024,128,16,1024})->Args({1024,1024,1024,128,32,1024})->Args({1024,1024,1024,128,64,1024})->Args({1024,1024,1024,128,128,1024})->Args({1024,1024,1024,128,256,1024})
->Args({1024,1024,1024,256,16,1024})->Args({1024,1024,1024,256,32,1024})->Args({1024,1024,1024,256,64,1024})->Args({1024,1024,1024,256,128,1024})->Args({1024,1024,1024,256,256,1024});
// clang-format on