mirror of
https://gitlab.com/libeigen/eigen.git
synced 2026-04-10 11:34:33 +08:00
Optimize SYMV, SYR, SYR2, and TRMV product kernels
libeigen/eigen!2228 Co-authored-by: Rasmus Munk Larsen <rmlarsen@gmail.com>
This commit is contained in:
Rasmus Munk Larsen
@@ -14,6 +14,10 @@ eigen_add_benchmark(bench_map bench_map.cpp)
|
||||
eigen_add_benchmark(bench_diagonal bench_diagonal.cpp)
|
||||
eigen_add_benchmark(bench_triangular_product bench_triangular_product.cpp)
|
||||
eigen_add_benchmark(bench_selfadjoint_product bench_selfadjoint_product.cpp)
|
||||
eigen_add_benchmark(bench_symv bench_symv.cpp)
|
||||
eigen_add_benchmark(bench_trmv bench_trmv.cpp)
|
||||
eigen_add_benchmark(bench_syr bench_syr.cpp)
|
||||
eigen_add_benchmark(bench_syr2 bench_syr2.cpp)
|
||||
eigen_add_benchmark(bench_construction bench_construction.cpp)
|
||||
eigen_add_benchmark(bench_fixed_size bench_fixed_size.cpp)
|
||||
eigen_add_benchmark(bench_fixed_size_double bench_fixed_size.cpp DEFINITIONS SCALAR=double)
|
||||
|
||||
62
benchmarks/Core/bench_symv.cpp
Normal file
62
benchmarks/Core/bench_symv.cpp
Normal file
@@ -0,0 +1,62 @@
|
||||
// Benchmarks for selfadjoint matrix-vector product (SYMV/HEMV).
|
||||
//
|
||||
// Tests y += selfadjointView(A) * x for various sizes and scalar types.
|
||||
// Exercises SelfadjointMatrixVector.h kernel.
|
||||
|
||||
#include <benchmark/benchmark.h>
|
||||
#include <Eigen/Core>
|
||||
|
||||
using namespace Eigen;
|
||||
|
||||
template <typename Scalar>
|
||||
double symvFlops(Index n) {
|
||||
// SYMV uses n^2 multiply-adds (exploiting symmetry)
|
||||
return (NumTraits<Scalar>::IsComplex ? 8.0 : 2.0) * n * n;
|
||||
}
|
||||
|
||||
// y += selfadjointView<Lower>(A) * x
|
||||
template <typename Scalar>
|
||||
static void BM_SYMV_Lower(benchmark::State& state) {
|
||||
const Index n = state.range(0);
|
||||
using Mat = Matrix<Scalar, Dynamic, Dynamic>;
|
||||
using Vec = Matrix<Scalar, Dynamic, 1>;
|
||||
Mat A = Mat::Random(n, n);
|
||||
A = (A + A.transpose().eval()) / Scalar(2);
|
||||
Vec x = Vec::Random(n);
|
||||
Vec y = Vec::Random(n);
|
||||
for (auto _ : state) {
|
||||
y.noalias() += A.template selfadjointView<Lower>() * x;
|
||||
benchmark::DoNotOptimize(y.data());
|
||||
benchmark::ClobberMemory();
|
||||
}
|
||||
state.counters["GFLOPS"] = benchmark::Counter(symvFlops<Scalar>(n), benchmark::Counter::kIsIterationInvariantRate,
|
||||
benchmark::Counter::kIs1000);
|
||||
}
|
||||
|
||||
// y += selfadjointView<Upper>(A) * x
|
||||
template <typename Scalar>
|
||||
static void BM_SYMV_Upper(benchmark::State& state) {
|
||||
const Index n = state.range(0);
|
||||
using Mat = Matrix<Scalar, Dynamic, Dynamic>;
|
||||
using Vec = Matrix<Scalar, Dynamic, 1>;
|
||||
Mat A = Mat::Random(n, n);
|
||||
A = (A + A.transpose().eval()) / Scalar(2);
|
||||
Vec x = Vec::Random(n);
|
||||
Vec y = Vec::Random(n);
|
||||
for (auto _ : state) {
|
||||
y.noalias() += A.template selfadjointView<Upper>() * x;
|
||||
benchmark::DoNotOptimize(y.data());
|
||||
benchmark::ClobberMemory();
|
||||
}
|
||||
state.counters["GFLOPS"] = benchmark::Counter(symvFlops<Scalar>(n), benchmark::Counter::kIsIterationInvariantRate,
|
||||
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");
|
||||
59
benchmarks/Core/bench_syr.cpp
Normal file
59
benchmarks/Core/bench_syr.cpp
Normal file
@@ -0,0 +1,59 @@
|
||||
// Benchmarks for symmetric rank-1 update (SYR).
|
||||
//
|
||||
// Tests C.selfadjointView<Lower>().rankUpdate(v, alpha) which computes
|
||||
// C += alpha * v * v^T, updating only the lower (or upper) triangle.
|
||||
// Exercises SelfadjointProduct.h / selfadjoint_rank1_update.
|
||||
|
||||
#include <benchmark/benchmark.h>
|
||||
#include <Eigen/Core>
|
||||
|
||||
using namespace Eigen;
|
||||
|
||||
template <typename Scalar>
|
||||
double syrFlops(Index n) {
|
||||
// SYR: n*(n+1)/2 multiply-adds ~ n^2
|
||||
return (NumTraits<Scalar>::IsComplex ? 8.0 : 2.0) * n * (n + 1) / 2;
|
||||
}
|
||||
|
||||
template <typename Scalar>
|
||||
static void BM_SYR_Lower(benchmark::State& state) {
|
||||
const Index n = state.range(0);
|
||||
using Mat = Matrix<Scalar, Dynamic, Dynamic>;
|
||||
using Vec = Matrix<Scalar, Dynamic, 1>;
|
||||
Vec v = Vec::Random(n);
|
||||
Mat C = Mat::Zero(n, n);
|
||||
Scalar alpha(1);
|
||||
for (auto _ : state) {
|
||||
C.template selfadjointView<Lower>().rankUpdate(v, alpha);
|
||||
benchmark::DoNotOptimize(C.data());
|
||||
benchmark::ClobberMemory();
|
||||
}
|
||||
state.counters["GFLOPS"] = benchmark::Counter(syrFlops<Scalar>(n), benchmark::Counter::kIsIterationInvariantRate,
|
||||
benchmark::Counter::kIs1000);
|
||||
}
|
||||
|
||||
template <typename Scalar>
|
||||
static void BM_SYR_Upper(benchmark::State& state) {
|
||||
const Index n = state.range(0);
|
||||
using Mat = Matrix<Scalar, Dynamic, Dynamic>;
|
||||
using Vec = Matrix<Scalar, Dynamic, 1>;
|
||||
Vec v = Vec::Random(n);
|
||||
Mat C = Mat::Zero(n, n);
|
||||
Scalar alpha(1);
|
||||
for (auto _ : state) {
|
||||
C.template selfadjointView<Upper>().rankUpdate(v, alpha);
|
||||
benchmark::DoNotOptimize(C.data());
|
||||
benchmark::ClobberMemory();
|
||||
}
|
||||
state.counters["GFLOPS"] = benchmark::Counter(syrFlops<Scalar>(n), benchmark::Counter::kIsIterationInvariantRate,
|
||||
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");
|
||||
61
benchmarks/Core/bench_syr2.cpp
Normal file
61
benchmarks/Core/bench_syr2.cpp
Normal file
@@ -0,0 +1,61 @@
|
||||
// Benchmarks for symmetric rank-2 update (SYR2).
|
||||
//
|
||||
// Tests C.selfadjointView<Lower>().rankUpdate(u, v, alpha) which computes
|
||||
// C += alpha * u * v^T + conj(alpha) * v * u^T.
|
||||
// Exercises SelfadjointRank2Update.h.
|
||||
|
||||
#include <benchmark/benchmark.h>
|
||||
#include <Eigen/Core>
|
||||
|
||||
using namespace Eigen;
|
||||
|
||||
template <typename Scalar>
|
||||
double syr2Flops(Index n) {
|
||||
// SYR2: 2 * n*(n+1)/2 multiply-adds ~ 2*n^2
|
||||
return (NumTraits<Scalar>::IsComplex ? 8.0 : 2.0) * 2 * n * (n + 1) / 2;
|
||||
}
|
||||
|
||||
template <typename Scalar>
|
||||
static void BM_SYR2_Lower(benchmark::State& state) {
|
||||
const Index n = state.range(0);
|
||||
using Mat = Matrix<Scalar, Dynamic, Dynamic>;
|
||||
using Vec = Matrix<Scalar, Dynamic, 1>;
|
||||
Vec u = Vec::Random(n);
|
||||
Vec v = Vec::Random(n);
|
||||
Mat C = Mat::Zero(n, n);
|
||||
Scalar alpha(1);
|
||||
for (auto _ : state) {
|
||||
C.template selfadjointView<Lower>().rankUpdate(u, v, alpha);
|
||||
benchmark::DoNotOptimize(C.data());
|
||||
benchmark::ClobberMemory();
|
||||
}
|
||||
state.counters["GFLOPS"] = benchmark::Counter(syr2Flops<Scalar>(n), benchmark::Counter::kIsIterationInvariantRate,
|
||||
benchmark::Counter::kIs1000);
|
||||
}
|
||||
|
||||
template <typename Scalar>
|
||||
static void BM_SYR2_Upper(benchmark::State& state) {
|
||||
const Index n = state.range(0);
|
||||
using Mat = Matrix<Scalar, Dynamic, Dynamic>;
|
||||
using Vec = Matrix<Scalar, Dynamic, 1>;
|
||||
Vec u = Vec::Random(n);
|
||||
Vec v = Vec::Random(n);
|
||||
Mat C = Mat::Zero(n, n);
|
||||
Scalar alpha(1);
|
||||
for (auto _ : state) {
|
||||
C.template selfadjointView<Upper>().rankUpdate(u, v, alpha);
|
||||
benchmark::DoNotOptimize(C.data());
|
||||
benchmark::ClobberMemory();
|
||||
}
|
||||
state.counters["GFLOPS"] = benchmark::Counter(syr2Flops<Scalar>(n), benchmark::Counter::kIsIterationInvariantRate,
|
||||
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");
|
||||
46
benchmarks/Core/bench_trmv.cpp
Normal file
46
benchmarks/Core/bench_trmv.cpp
Normal file
@@ -0,0 +1,46 @@
|
||||
// Benchmarks for triangular matrix-vector product (TRMV).
|
||||
//
|
||||
// Tests y += triangularView(A) * x for various modes and sizes.
|
||||
// Exercises TriangularMatrixVector.h kernel.
|
||||
|
||||
#include <benchmark/benchmark.h>
|
||||
#include <Eigen/Core>
|
||||
|
||||
using namespace Eigen;
|
||||
|
||||
template <typename Scalar>
|
||||
double trmvFlops(Index n) {
|
||||
// TRMV: ~n^2 multiply-adds
|
||||
return (NumTraits<Scalar>::IsComplex ? 8.0 : 2.0) * n * n;
|
||||
}
|
||||
|
||||
// y = triangularView<Mode>(A) * x
|
||||
template <typename Scalar, unsigned int Mode>
|
||||
static void BM_TRMV(benchmark::State& state) {
|
||||
const Index n = state.range(0);
|
||||
using Mat = Matrix<Scalar, Dynamic, Dynamic>;
|
||||
using Vec = Matrix<Scalar, Dynamic, 1>;
|
||||
Mat A = Mat::Random(n, n);
|
||||
Vec x = Vec::Random(n);
|
||||
Vec y(n);
|
||||
for (auto _ : state) {
|
||||
y.noalias() = A.template triangularView<Mode>() * x;
|
||||
benchmark::DoNotOptimize(y.data());
|
||||
benchmark::ClobberMemory();
|
||||
}
|
||||
state.counters["GFLOPS"] = benchmark::Counter(trmvFlops<Scalar>(n), benchmark::Counter::kIsIterationInvariantRate,
|
||||
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");
|
||||
Reference in New Issue
Block a user