product_threshold.cpp File Reference

#include <iostream>
#include <Eigen/Core>
#include <bench/BenchTimer.h>

Classes
struct	map_size< S >
struct	map_size< 10 >
struct	map_size< 11 >
struct	map_size< 12 >
struct	map_size< 13 >
struct	alt_prod< M, N, K >
struct	loop_on_k< M, N, K >
struct	loop_on_k< M, N, END >
struct	loop_on_m< M, N, K >
struct	loop_on_m< END, N, K >
struct	loop_on_n< M, N, K, Scalar, Mode >
struct	loop_on_n< M, END, K, Scalar, Mode >
struct	print_n< N >
struct	print_n< END >

Macros
#define	END   9

Functions
void	print_mode (int mode)
template<int Mode, typename Lhs , typename Rhs , typename Res >
EIGEN_DONT_INLINE void	prod (const Lhs &a, const Rhs &b, Res &c)
template<int M, int N, int K, typename Scalar , int Mode>
EIGEN_DONT_INLINE void	bench_prod ()
int	main ()

Macro Definition Documentation

END

#define END   9

Function Documentation

bench_prod()

template<int M, int N, int K, typename Scalar , int Mode>

EIGEN_DONT_INLINE void bench_prod

(

)

                                    {
  typedef Matrix<Scalar, M, K> Lhs;
  Lhs a;
  a.setRandom();
  typedef Matrix<Scalar, K, N> Rhs;
  Rhs b;
  b.setRandom();
  typedef Matrix<Scalar, M, N> Res;
  Res c;
  c.setRandom();
 
  BenchTimer t;
  double n = 2. * double(M) * double(N) * double(K);
  int rep = 100000. / n;
  rep /= 2;
  if (rep < 1) rep = 1;
  do {
    rep *= 2;
    t.reset();
    BENCH(t, 1, rep, prod<CoeffBasedProductMode>(a, b, c));
  } while (t.best() < 0.1);
 
  t.reset();
  BENCH(t, 5, rep, prod<Mode>(a, b, c));
 
  print_mode(Mode);
  std::cout << int(1e-6 * n * rep / t.best()) << "\t";
}

References a, b, BENCH, calibrate::c, e(), int(), PlanarWave::K, Eigen::internal::Lhs, n, N, print_mode(), Eigen::internal::Rhs, and plotPSD::t.

Referenced by loop_on_n< M, N, K, Scalar, Mode >::run().

main()

int main

(

)

           {
  loop_on_k<1, 1, 1>::run();
 
  return 0;
}

References loop_on_k< M, N, K >::run().

print_mode()

void print_mode

(

int

mode

)

                          {
  if (mode == InnerProduct) std::cout << "i";
  if (mode == OuterProduct) std::cout << "o";
  if (mode == CoeffBasedProductMode) std::cout << "c";
  if (mode == LazyCoeffBasedProductMode) std::cout << "l";
  if (mode == GemvProduct) std::cout << "v";
  if (mode == GemmProduct) std::cout << "m";
}

References Eigen::CoeffBasedProductMode, Eigen::GemmProduct, Eigen::GemvProduct, Eigen::InnerProduct, Eigen::LazyCoeffBasedProductMode, and Eigen::OuterProduct.

Referenced by bench_prod().

prod()

template<int Mode, typename Lhs , typename Rhs , typename Res >

EIGEN_DONT_INLINE void prod	(	const Lhs &	a,
		const Rhs &	b,
		Res &	c
	)

                                                                {
  c.noalias() += typename ProductReturnType<Lhs, Rhs, Mode>::Type(a, b);
}

References a, b, and calibrate::c.

Referenced by EIGEN_DECLARE_TEST(), main(), test_simple_reductions(), vectorwiseop_matrix(), and zeroSizedMatrix().