assignment_threaded.cpp File Reference

#include "main.h"
#include <Eigen/ThreadPool>

Classes
struct	Eigen::internal::scalar_dummy_op< Scalar, Vectorize >
struct	Eigen::internal::functor_traits< scalar_dummy_op< Scalar, Vectorize > >

Namespaces
	Eigen
	Namespace containing all symbols from the Eigen library.
	Eigen::internal
	Namespace containing low-level routines from the Eigen library.

Macros
#define	EIGEN_USE_THREADS   1

Functions
template<typename PlainObject >
void	test_threaded_assignment (const PlainObject &, Index rows=PlainObject::RowsAtCompileTime, Index cols=PlainObject::ColsAtCompileTime)
	EIGEN_DECLARE_TEST (test)

Macro Definition Documentation

EIGEN_USE_THREADS

#define EIGEN_USE_THREADS   1

Function Documentation

EIGEN_DECLARE_TEST()

EIGEN_DECLARE_TEST

(

test

)

                         {
  for (int i = 0; i < g_repeat; i++) {
    CALL_SUBTEST(test_threaded_assignment(MatrixXd(), 123, 123));
    CALL_SUBTEST(test_threaded_assignment(Matrix<float, 16, 16>()));
  }
}

References CALL_SUBTEST, Eigen::g_repeat, i, and test_threaded_assignment().

test_threaded_assignment()

template<typename PlainObject >

void test_threaded_assignment	(	const PlainObject &	,
		Index	rows = PlainObject::RowsAtCompileTime,
		Index	cols = PlainObject::ColsAtCompileTime
	)

                                                                         {
  using Scalar = typename PlainObject::Scalar;
  using VectorizationOff = internal::scalar_dummy_op<Scalar, false>;
  using VectorizationOn = internal::scalar_dummy_op<Scalar, true>;
 
  int threads = 4;
  ThreadPool pool(threads);
  CoreThreadPoolDevice threadPoolDevice(pool);
 
  PlainObject dst(rows, cols), ref(rows, cols), rhs(rows, cols);
  rhs.setRandom();
  const auto rhs_xpr = rhs.cwiseAbs2();
 
  // linear access
  dst.setRandom();
  ref.setRandom();
  ref = rhs_xpr.unaryExpr(VectorizationOff());
  dst.device(threadPoolDevice) = rhs_xpr.unaryExpr(VectorizationOff());
  VERIFY_IS_CWISE_EQUAL(ref, dst);
 
  ref = rhs_xpr.unaryExpr(VectorizationOn());
  dst.device(threadPoolDevice) = rhs_xpr.unaryExpr(VectorizationOn());
  VERIFY_IS_CWISE_EQUAL(ref, dst);
 
  // outer-inner access
  Index blockRows = numext::maxi(Index(1), rows - 1);
  Index blockCols = numext::maxi(Index(1), cols - 1);
  dst.setRandom();
  ref.setRandom();
  ref.bottomRightCorner(blockRows, blockCols) =
      rhs_xpr.bottomRightCorner(blockRows, blockCols).unaryExpr(VectorizationOff());
  dst.bottomRightCorner(blockRows, blockCols).device(threadPoolDevice) =
      rhs_xpr.bottomRightCorner(blockRows, blockCols).unaryExpr(VectorizationOff());
  VERIFY_IS_CWISE_EQUAL(ref.bottomRightCorner(blockRows, blockCols), dst.bottomRightCorner(blockRows, blockCols));
 
  ref.setZero();
  dst.setZero();
  ref.bottomRightCorner(blockRows, blockCols) =
      rhs_xpr.bottomRightCorner(blockRows, blockCols).unaryExpr(VectorizationOn());
  dst.bottomRightCorner(blockRows, blockCols).device(threadPoolDevice) =
      rhs_xpr.bottomRightCorner(blockRows, blockCols).unaryExpr(VectorizationOn());
  VERIFY_IS_CWISE_EQUAL(ref.bottomRightCorner(blockRows, blockCols), dst.bottomRightCorner(blockRows, blockCols));
}

References cols, Eigen::numext::maxi(), rows, and VERIFY_IS_CWISE_EQUAL.

Referenced by EIGEN_DECLARE_TEST().