From 9d1e5f391545167e59664f6f49e6c4cf8049852d Mon Sep 17 00:00:00 2001
From: Rasmus Munk Larsen <4643818-rmlarsen1@users.noreply.gitlab.com>
Date: Fri, 20 Mar 2026 17:42:07 -0700
Subject: [PATCH] Remove benchmark::internal::Benchmark* from all benchmarks

libeigen/eigen!2332

Co-authored-by: Rasmus Munk Larsen <rlarsen@nvidia.com>
---
 benchmarks/Core/bench_block_ops.cpp           |  30 ++--
 benchmarks/Core/bench_broadcasting.cpp        |  57 ++++---
 benchmarks/Core/bench_construction.cpp        |  33 ++--
 benchmarks/Core/bench_cwise_math.cpp          | 144 +++++++++---------
 benchmarks/Core/bench_diagonal.cpp            |  24 +--
 benchmarks/Core/bench_dot.cpp                 |  20 +--
 benchmarks/Core/bench_gemm.cpp                |  40 +++--
 benchmarks/Core/bench_gemv.cpp                |  49 +++---
 benchmarks/Core/bench_map.cpp                 |  32 ++--
 benchmarks/Core/bench_reductions.cpp          |  58 +++----
 benchmarks/Core/bench_selfadjoint_product.cpp |  26 +---
 benchmarks/Core/bench_symv.cpp                |  16 +-
 benchmarks/Core/bench_syr.cpp                 |  14 +-
 benchmarks/Core/bench_syr2.cpp                |  16 +-
 benchmarks/Core/bench_triangular_product.cpp  |  25 ++-
 benchmarks/Core/bench_trmv.cpp                |  24 +--
 benchmarks/Core/bench_trsm.cpp                |  30 +---
 benchmarks/FFT/bench_fft.cpp                  |  32 ++--
 benchmarks/Geometry/bench_geometry.cpp        |  23 ++-
 benchmarks/LU/bench_lu.cpp                    |  38 ++---
 benchmarks/LU/bench_rcond.cpp                 |  18 +--
 benchmarks/QR/bench_qr.cpp                    |  37 +++--
 benchmarks/SVD/bench_jacobi_sweep.cpp         |  24 +--
 benchmarks/SVD/bench_svd.cpp                  |  57 ++++---
 benchmarks/Solvers/bench_dense_solvers.cpp    |  37 ++---
 benchmarks/Sparse/bench_sparse_solvers.cpp    |  28 +---
 benchmarks/Sparse/bench_sparse_transpose.cpp  |  12 +-
 benchmarks/Sparse/bench_spmm.cpp              |  10 +-
 benchmarks/Sparse/bench_spmv.cpp              |  12 +-
 benchmarks/Tuning/bench_aocl.cpp              |  22 ++-
 benchmarks/Tuning/bench_blas_gemm.cpp         |  20 ++-
 benchmarks/Tuning/bench_blocking_sizes.cpp    |  45 +++---
 32 files changed, 477 insertions(+), 576 deletions(-)

diff --git a/benchmarks/Core/bench_block_ops.cpp b/benchmarks/Core/bench_block_ops.cpp
index 5d13f8904..1eb71ddce 100644
--- a/benchmarks/Core/bench_block_ops.cpp
+++ b/benchmarks/Core/bench_block_ops.cpp
@@ -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
diff --git a/benchmarks/Core/bench_broadcasting.cpp b/benchmarks/Core/bench_broadcasting.cpp
index f7e3c45a7..78305797c 100644
--- a/benchmarks/Core/bench_broadcasting.cpp
+++ b/benchmarks/Core/bench_broadcasting.cpp
@@ -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
diff --git a/benchmarks/Core/bench_construction.cpp b/benchmarks/Core/bench_construction.cpp
index 6479eb3e2..294ac195d 100644
--- a/benchmarks/Core/bench_construction.cpp
+++ b/benchmarks/Core/bench_construction.cpp
@@ -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");
diff --git a/benchmarks/Core/bench_cwise_math.cpp b/benchmarks/Core/bench_cwise_math.cpp
index ae0f12d98..8d7e94e6b 100644
--- a/benchmarks/Core/bench_cwise_math.cpp
+++ b/benchmarks/Core/bench_cwise_math.cpp
@@ -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
diff --git a/benchmarks/Core/bench_diagonal.cpp b/benchmarks/Core/bench_diagonal.cpp
index 5019d7384..9e1674a53 100644
--- a/benchmarks/Core/bench_diagonal.cpp
+++ b/benchmarks/Core/bench_diagonal.cpp
@@ -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
diff --git a/benchmarks/Core/bench_dot.cpp b/benchmarks/Core/bench_dot.cpp
index a03416f8b..73defdaba 100644
--- a/benchmarks/Core/bench_dot.cpp
+++ b/benchmarks/Core/bench_dot.cpp
@@ -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
diff --git a/benchmarks/Core/bench_gemm.cpp b/benchmarks/Core/bench_gemm.cpp
index 5d480ef1d..bef177ad8 100644
--- a/benchmarks/Core/bench_gemm.cpp
+++ b/benchmarks/Core/bench_gemm.cpp
@@ -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
diff --git a/benchmarks/Core/bench_gemv.cpp b/benchmarks/Core/bench_gemv.cpp
index ad994d50a..b8b9a969c 100644
--- a/benchmarks/Core/bench_gemv.cpp
+++ b/benchmarks/Core/bench_gemv.cpp
@@ -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
diff --git a/benchmarks/Core/bench_map.cpp b/benchmarks/Core/bench_map.cpp
index 1b8bfccea..56e3d4d11 100644
--- a/benchmarks/Core/bench_map.cpp
+++ b/benchmarks/Core/bench_map.cpp
@@ -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
diff --git a/benchmarks/Core/bench_reductions.cpp b/benchmarks/Core/bench_reductions.cpp
index 049bf8e1a..d6c6159f6 100644
--- a/benchmarks/Core/bench_reductions.cpp
+++ b/benchmarks/Core/bench_reductions.cpp
@@ -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
diff --git a/benchmarks/Core/bench_selfadjoint_product.cpp b/benchmarks/Core/bench_selfadjoint_product.cpp
index ec17d0a19..7b73bbf19 100644
--- a/benchmarks/Core/bench_selfadjoint_product.cpp
+++ b/benchmarks/Core/bench_selfadjoint_product.cpp
@@ -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
diff --git a/benchmarks/Core/bench_symv.cpp b/benchmarks/Core/bench_symv.cpp
index dea82cdd5..71a1c4711 100644
--- a/benchmarks/Core/bench_symv.cpp
+++ b/benchmarks/Core/bench_symv.cpp
@@ -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
diff --git a/benchmarks/Core/bench_syr.cpp b/benchmarks/Core/bench_syr.cpp
index ba6c2fce0..d179c75a9 100644
--- a/benchmarks/Core/bench_syr.cpp
+++ b/benchmarks/Core/bench_syr.cpp
@@ -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
diff --git a/benchmarks/Core/bench_syr2.cpp b/benchmarks/Core/bench_syr2.cpp
index e7d28c0f5..3bf751090 100644
--- a/benchmarks/Core/bench_syr2.cpp
+++ b/benchmarks/Core/bench_syr2.cpp
@@ -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
diff --git a/benchmarks/Core/bench_triangular_product.cpp b/benchmarks/Core/bench_triangular_product.cpp
index 95d515ce6..230dfe6f5 100644
--- a/benchmarks/Core/bench_triangular_product.cpp
+++ b/benchmarks/Core/bench_triangular_product.cpp
@@ -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
diff --git a/benchmarks/Core/bench_trmv.cpp b/benchmarks/Core/bench_trmv.cpp
index 56e75591a..90cb06da6 100644
--- a/benchmarks/Core/bench_trmv.cpp
+++ b/benchmarks/Core/bench_trmv.cpp
@@ -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
diff --git a/benchmarks/Core/bench_trsm.cpp b/benchmarks/Core/bench_trsm.cpp
index 7b050b53d..27d4106e1 100644
--- a/benchmarks/Core/bench_trsm.cpp
+++ b/benchmarks/Core/bench_trsm.cpp
@@ -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
diff --git a/benchmarks/FFT/bench_fft.cpp b/benchmarks/FFT/bench_fft.cpp
index 4934ccaa3..4c3f85241 100644
--- a/benchmarks/FFT/bench_fft.cpp
+++ b/benchmarks/FFT/bench_fft.cpp
@@ -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
diff --git a/benchmarks/Geometry/bench_geometry.cpp b/benchmarks/Geometry/bench_geometry.cpp
index 88b2f1051..5b5e2892b 100644
--- a/benchmarks/Geometry/bench_geometry.cpp
+++ b/benchmarks/Geometry/bench_geometry.cpp
@@ -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) {
diff --git a/benchmarks/LU/bench_lu.cpp b/benchmarks/LU/bench_lu.cpp
index f783cc916..dd020da03 100644
--- a/benchmarks/LU/bench_lu.cpp
+++ b/benchmarks/LU/bench_lu.cpp
@@ -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
diff --git a/benchmarks/LU/bench_rcond.cpp b/benchmarks/LU/bench_rcond.cpp
index e1f5ea376..99684b436 100644
--- a/benchmarks/LU/bench_rcond.cpp
+++ b/benchmarks/LU/bench_rcond.cpp
@@ -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
diff --git a/benchmarks/QR/bench_qr.cpp b/benchmarks/QR/bench_qr.cpp
index e4b57e962..98bae2478 100644
--- a/benchmarks/QR/bench_qr.cpp
+++ b/benchmarks/QR/bench_qr.cpp
@@ -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
diff --git a/benchmarks/SVD/bench_jacobi_sweep.cpp b/benchmarks/SVD/bench_jacobi_sweep.cpp
index 45d0a7c55..1a446c19e 100644
--- a/benchmarks/SVD/bench_jacobi_sweep.cpp
+++ b/benchmarks/SVD/bench_jacobi_sweep.cpp
@@ -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
diff --git a/benchmarks/SVD/bench_svd.cpp b/benchmarks/SVD/bench_svd.cpp
index b7e6da38c..5715f0140 100644
--- a/benchmarks/SVD/bench_svd.cpp
+++ b/benchmarks/SVD/bench_svd.cpp
@@ -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>)
diff --git a/benchmarks/Solvers/bench_dense_solvers.cpp b/benchmarks/Solvers/bench_dense_solvers.cpp
index 62223f067..dc14a2dfc 100644
--- a/benchmarks/Solvers/bench_dense_solvers.cpp
+++ b/benchmarks/Solvers/bench_dense_solvers.cpp
@@ -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
diff --git a/benchmarks/Sparse/bench_sparse_solvers.cpp b/benchmarks/Sparse/bench_sparse_solvers.cpp
index 37817c933..977ddd486 100644
--- a/benchmarks/Sparse/bench_sparse_solvers.cpp
+++ b/benchmarks/Sparse/bench_sparse_solvers.cpp
@@ -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}});
diff --git a/benchmarks/Sparse/bench_sparse_transpose.cpp b/benchmarks/Sparse/bench_sparse_transpose.cpp
index fa57c5289..e7a4dd69f 100644
--- a/benchmarks/Sparse/bench_sparse_transpose.cpp
+++ b/benchmarks/Sparse/bench_sparse_transpose.cpp
@@ -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}});
diff --git a/benchmarks/Sparse/bench_spmm.cpp b/benchmarks/Sparse/bench_spmm.cpp
index 82044e6b2..70313f48a 100644
--- a/benchmarks/Sparse/bench_spmm.cpp
+++ b/benchmarks/Sparse/bench_spmm.cpp
@@ -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}});
diff --git a/benchmarks/Sparse/bench_spmv.cpp b/benchmarks/Sparse/bench_spmv.cpp
index 61f42eabc..54e876fa5 100644
--- a/benchmarks/Sparse/bench_spmv.cpp
+++ b/benchmarks/Sparse/bench_spmv.cpp
@@ -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}});
diff --git a/benchmarks/Tuning/bench_aocl.cpp b/benchmarks/Tuning/bench_aocl.cpp
index 5850cfe5c..04396b568 100644
--- a/benchmarks/Tuning/bench_aocl.cpp
+++ b/benchmarks/Tuning/bench_aocl.cpp
@@ -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);
diff --git a/benchmarks/Tuning/bench_blas_gemm.cpp b/benchmarks/Tuning/bench_blas_gemm.cpp
index 78d6d27e7..4d7602e0d 100644
--- a/benchmarks/Tuning/bench_blas_gemm.cpp
+++ b/benchmarks/Tuning/bench_blas_gemm.cpp
@@ -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
diff --git a/benchmarks/Tuning/bench_blocking_sizes.cpp b/benchmarks/Tuning/bench_blocking_sizes.cpp
index ac9ba7371..4ed21d257 100644
--- a/benchmarks/Tuning/bench_blocking_sizes.cpp
+++ b/benchmarks/Tuning/bench_blocking_sizes.cpp
@@ -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