unalignedcount.cpp File Reference

#include "main.h"

Macros
#define	EIGEN_DEBUG_ALIGNED_LOAD    { nb_load++; }
#define	EIGEN_DEBUG_UNALIGNED_LOAD    { nb_loadu++; }
#define	EIGEN_DEBUG_ALIGNED_STORE    { nb_store++; }
#define	EIGEN_DEBUG_UNALIGNED_STORE    { nb_storeu++; }
#define	VERIFY_ALIGNED_UNALIGNED_COUNT(XPR, AL, UL, AS, US)

Functions
	EIGEN_DECLARE_TEST (unalignedcount)

Variables
static int	nb_load
static int	nb_loadu
static int	nb_store
static int	nb_storeu

Macro Definition Documentation

EIGEN_DEBUG_ALIGNED_LOAD

#define EIGEN_DEBUG_ALIGNED_LOAD    { nb_load++; }

EIGEN_DEBUG_ALIGNED_STORE

#define EIGEN_DEBUG_ALIGNED_STORE    { nb_store++; }

EIGEN_DEBUG_UNALIGNED_LOAD

#define EIGEN_DEBUG_UNALIGNED_LOAD    { nb_loadu++; }

EIGEN_DEBUG_UNALIGNED_STORE

#define EIGEN_DEBUG_UNALIGNED_STORE    { nb_storeu++; }

VERIFY_ALIGNED_UNALIGNED_COUNT

#define VERIFY_ALIGNED_UNALIGNED_COUNT	(		XPR,
			AL,
			UL,
			AS,
			US
	)

Value:

  {                                                                                                        \
    nb_load = nb_loadu = nb_store = nb_storeu = 0;                                                         \
    XPR;                                                                                                   \
    if (!(nb_load == AL && nb_loadu == UL && nb_store == AS && nb_storeu == US))                           \
      std::cerr << " >> " << nb_load << ", " << nb_loadu << ", " << nb_store << ", " << nb_storeu << "\n"; \
    VERIFY((#XPR) && nb_load == AL && nb_loadu == UL && nb_store == AS && nb_storeu == US);                \
  }

Function Documentation

EIGEN_DECLARE_TEST()

EIGEN_DECLARE_TEST

(

unalignedcount

)

                                   {
#if defined(EIGEN_VECTORIZE_AVX512)
  VectorXf a(48), b(48);
  a.fill(0);
  b.fill(1);
  VERIFY_ALIGNED_UNALIGNED_COUNT(a += b, 6, 0, 3, 0);
  VERIFY_ALIGNED_UNALIGNED_COUNT(a.segment(0, 48) += b.segment(0, 48), 3, 3, 3, 0);
  VERIFY_ALIGNED_UNALIGNED_COUNT(a.segment(0, 48) -= b.segment(0, 48), 3, 3, 3, 0);
  VERIFY_ALIGNED_UNALIGNED_COUNT(a.segment(0, 48) *= 3.5, 3, 0, 3, 0);
  VERIFY_ALIGNED_UNALIGNED_COUNT(a.segment(0, 48) /= 3.5, 3, 0, 3, 0);
#elif defined(EIGEN_VECTORIZE_AVX)
  VectorXf a(40), b(40);
  a.fill(0);
  b.fill(1);
  VERIFY_ALIGNED_UNALIGNED_COUNT(a += b, 10, 0, 5, 0);
  VERIFY_ALIGNED_UNALIGNED_COUNT(a.segment(0, 40) += b.segment(0, 40), 5, 5, 5, 0);
  VERIFY_ALIGNED_UNALIGNED_COUNT(a.segment(0, 40) -= b.segment(0, 40), 5, 5, 5, 0);
  VERIFY_ALIGNED_UNALIGNED_COUNT(a.segment(0, 40) *= 3.5, 5, 0, 5, 0);
  VERIFY_ALIGNED_UNALIGNED_COUNT(a.segment(0, 40) /= 3.5, 5, 0, 5, 0);
#elif defined(EIGEN_VECTORIZE_SSE)
  VectorXf a(40), b(40);
  a.fill(0);
  b.fill(1);
  VERIFY_ALIGNED_UNALIGNED_COUNT(a += b, 20, 0, 10, 0);
  VERIFY_ALIGNED_UNALIGNED_COUNT(a.segment(0, 40) += b.segment(0, 40), 10, 10, 10, 0);
  VERIFY_ALIGNED_UNALIGNED_COUNT(a.segment(0, 40) -= b.segment(0, 40), 10, 10, 10, 0);
  VERIFY_ALIGNED_UNALIGNED_COUNT(a.segment(0, 40) *= 3.5, 10, 0, 10, 0);
  VERIFY_ALIGNED_UNALIGNED_COUNT(a.segment(0, 40) /= 3.5, 10, 0, 10, 0);
#else
  // The following line is to eliminate "variable not used" warnings
  nb_load = nb_loadu = nb_store = nb_storeu = 0;
  int a(0), b(0);
  VERIFY(a == b);
#endif
}

References a, b, nb_load, nb_loadu, nb_store, nb_storeu, VERIFY, and VERIFY_ALIGNED_UNALIGNED_COUNT.

Variable Documentation

nb_load

int nb_load

static

Referenced by EIGEN_DECLARE_TEST().

nb_loadu

int nb_loadu

static

Referenced by EIGEN_DECLARE_TEST().

nb_store

int nb_store

static

Referenced by EIGEN_DECLARE_TEST().

nb_storeu

int nb_storeu

static

Referenced by EIGEN_DECLARE_TEST().