blasutil.cpp File Reference

#include "main.h"

Classes
struct	PacketBlockSet< Scalar, StorageOrder, n >

Macros
#define	GET(i, j)   (StorageOrder == RowMajor ? (i) * stride + (j) : (i) + (j) * stride)
#define	SCATTER(i, j, k)   (StorageOrder == RowMajor ? ((i) + (k)) * stride + (j) : (i) + ((j) + (k)) * stride)

Functions
template<typename Scalar , typename Packet >
void	compare (const Packet &a, const Packet &b)
template<typename Scalar , int StorageOrder, int BlockSize>
void	run_bdmp_spec_1 ()
template<typename Scalar >
void	run_test ()
	EIGEN_DECLARE_TEST (blasutil)

Macro Definition Documentation

GET

#define GET	(		i,
			j
	)		(StorageOrder == RowMajor ? (i) * stride + (j) : (i) + (j) * stride)

SCATTER

#define SCATTER	(		i,
			j,
			k
	)		(StorageOrder == RowMajor ? ((i) + (k)) * stride + (j) : (i) + ((j) + (k)) * stride)

Function Documentation

compare()

template<typename Scalar , typename Packet >

void compare	(	const Packet &	a,
		const Packet &	b
	)

                                               {
  int pktsz = internal::packet_traits<Scalar>::size;
  Scalar* buffA = new Scalar[pktsz];
  Scalar* buffB = new Scalar[pktsz];
 
  internal::pstoreu<Scalar, Packet>(buffA, a);
  internal::pstoreu<Scalar, Packet>(buffB, b);
 
  for (int i = 0; i < pktsz; i++) {
    VERIFY_IS_EQUAL(buffA[i], buffB[i]);
  }
 
  delete[] buffA;
  delete[] buffB;
}

References a, b, i, size, and VERIFY_IS_EQUAL.

Referenced by Eigen::getMarketHeader(), File::write(), and DPMBase::write().

EIGEN_DECLARE_TEST()

EIGEN_DECLARE_TEST

(

blasutil

)

                             {
  for (int i = 0; i < g_repeat; i++) {
    CALL_SUBTEST_1(run_test<numext::int8_t>());
    CALL_SUBTEST_2(run_test<numext::int16_t>());
    CALL_SUBTEST_3(run_test<numext::int32_t>());
 
    // TODO: Replace this by a call to numext::int64_t as soon as we have a way to
    // detect the typedef for int64_t on all platforms
    CALL_SUBTEST_4(run_test<signed long long>());
    CALL_SUBTEST_5(run_test<float_t>());
    CALL_SUBTEST_6(run_test<double_t>());
    CALL_SUBTEST_7(run_test<std::complex<float> >());
    CALL_SUBTEST_8(run_test<std::complex<double> >());
  }
}

References CALL_SUBTEST_1, CALL_SUBTEST_2, CALL_SUBTEST_3, CALL_SUBTEST_4, CALL_SUBTEST_5, CALL_SUBTEST_6, CALL_SUBTEST_7, CALL_SUBTEST_8, Eigen::g_repeat, i, and run_test().

run_bdmp_spec_1()

template<typename Scalar , int StorageOrder, int BlockSize>

void run_bdmp_spec_1

(

)

                       {
  typedef internal::blas_data_mapper<Scalar, int, StorageOrder> BlasDataMapper;
  int packetSize = internal::packet_traits<Scalar>::size;
  int minSize = std::max<int>(packetSize, BlockSize);
  typedef typename internal::packet_traits<Scalar>::type Packet;
 
  int szm = internal::random<int>(minSize, 500), szn = internal::random<int>(minSize, 500);
  int stride = StorageOrder == RowMajor ? szn : szm;
  Scalar* d = new Scalar[szn * szm];
 
  // Initializing with random entries
  for (int i = 0; i < szm * szn; i++) {
    d[i] = internal::random<Scalar>(static_cast<Scalar>(3), static_cast<Scalar>(10));
  }
 
  BlasDataMapper bdm(d, stride);
 
  // Testing operator()
  for (int i = 0; i < szm; i++) {
    for (int j = 0; j < szn; j++) {
      VERIFY_IS_EQUAL(d[GET(i, j)], bdm(i, j));
    }
  }
 
  // Testing getSubMapper and getLinearMapper
  int i0 = internal::random<int>(0, szm - 2);
  int j0 = internal::random<int>(0, szn - 2);
  for (int i = i0; i < szm; i++) {
    for (int j = j0; j < szn; j++) {
      const BlasDataMapper& bdmSM = bdm.getSubMapper(i0, j0);
      const internal::BlasLinearMapper<Scalar, int, 0>& bdmLM = bdm.getLinearMapper(i0, j0);
 
      Scalar v = bdmSM(i - i0, j - j0);
      Scalar vd = d[GET(i, j)];
      VERIFY_IS_EQUAL(vd, v);
      VERIFY_IS_EQUAL(vd, bdmLM(GET(i - i0, j - j0)));
    }
  }
 
  // Testing loadPacket
  for (int i = 0; i < szm - minSize; i++) {
    for (int j = 0; j < szn - minSize; j++) {
      Packet pktBDM = bdm.template loadPacket<Packet>(i, j);
      Packet pktD = internal::ploadu<Packet>(d + GET(i, j));
 
      compare<Scalar, Packet>(pktBDM, pktD);
    }
  }
 
  // Testing gatherPacket
  Scalar* buff = new Scalar[packetSize];
  for (int i = 0; i < szm - minSize; i++) {
    for (int j = 0; j < szn - minSize; j++) {
      Packet p = bdm.template gatherPacket<Packet>(i, j);
      internal::pstoreu<Scalar, Packet>(buff, p);
 
      for (int k = 0; k < packetSize; k++) {
        VERIFY_IS_EQUAL(d[SCATTER(i, j, k)], buff[k]);
      }
    }
  }
  delete[] buff;
 
  // Testing scatterPacket
  for (int i = 0; i < szm - minSize; i++) {
    for (int j = 0; j < szn - minSize; j++) {
      Packet p = internal::pset1<Packet>(static_cast<Scalar>(1));
      bdm.template scatterPacket<Packet>(i, j, p);
      for (int k = 0; k < packetSize; k++) {
        VERIFY_IS_EQUAL(d[SCATTER(i, j, k)], static_cast<Scalar>(1));
      }
    }
  }
 
  // Testing storePacketBlock
  internal::PacketBlock<Packet, BlockSize> block;
 
  PacketBlockSet<Scalar, StorageOrder, BlockSize> pbs;
  pbs.setPacketBlock(block, static_cast<Scalar>(2));
 
  for (int i = 0; i < szm - minSize; i++) {
    for (int j = 0; j < szn - minSize; j++) {
      bdm.template storePacketBlock<Packet, BlockSize>(i, j, block);
 
      pbs.comparePacketBlock(d, i, j, stride, block);
    }
  }
 
  delete[] d;
}

References block(), PacketBlockSet< Scalar, StorageOrder, n >::comparePacketBlock(), GET, i, j, k, p, Eigen::RowMajor, SCATTER, PacketBlockSet< Scalar, StorageOrder, n >::setPacketBlock(), size, v, and VERIFY_IS_EQUAL.

run_test()

template<typename Scalar >

void run_test

(

)

                {
  run_bdmp_spec_1<Scalar, RowMajor, 1>();
  run_bdmp_spec_1<Scalar, ColMajor, 1>();
  run_bdmp_spec_1<Scalar, RowMajor, 2>();
  run_bdmp_spec_1<Scalar, ColMajor, 2>();
  run_bdmp_spec_1<Scalar, RowMajor, 4>();
  run_bdmp_spec_1<Scalar, ColMajor, 4>();
  run_bdmp_spec_1<Scalar, RowMajor, 8>();
  run_bdmp_spec_1<Scalar, ColMajor, 8>();
  run_bdmp_spec_1<Scalar, RowMajor, 16>();
  run_bdmp_spec_1<Scalar, ColMajor, 16>();
}

Referenced by EIGEN_DECLARE_TEST().