Public Types | Static Public Member Functions | Static Public Attributes | List of all members
vectorization_logic_half< Scalar, Enable > Struct Template Reference

Public Types

using RealScalar = typename NumTraits< Scalar >::Real
 
typedef internal::packet_traits< Scalar > PacketTraits
 
typedef internal::unpacket_traits< typename internal::packet_traits< Scalar >::type >::half PacketType
 

Static Public Member Functions

static void run ()
 

Static Public Attributes

static constexpr int PacketSize = internal::unpacket_traits<PacketType>::size
 

Member Typedef Documentation

◆ PacketTraits

template<typename Scalar , bool Enable = !internal::is_same< typename internal::unpacket_traits<typename internal::packet_traits<Scalar>::type>::half, typename internal::packet_traits<Scalar>::type>::value>
typedef internal::packet_traits<Scalar> vectorization_logic_half< Scalar, Enable >::PacketTraits

◆ PacketType

template<typename Scalar , bool Enable = !internal::is_same< typename internal::unpacket_traits<typename internal::packet_traits<Scalar>::type>::half, typename internal::packet_traits<Scalar>::type>::value>
typedef internal::unpacket_traits<typename internal::packet_traits<Scalar>::type>::half vectorization_logic_half< Scalar, Enable >::PacketType

◆ RealScalar

template<typename Scalar , bool Enable = !internal::is_same< typename internal::unpacket_traits<typename internal::packet_traits<Scalar>::type>::half, typename internal::packet_traits<Scalar>::type>::value>
using vectorization_logic_half< Scalar, Enable >::RealScalar = typename NumTraits<Scalar>::Real

Member Function Documentation

◆ run()

template<typename Scalar , bool Enable = !internal::is_same< typename internal::unpacket_traits<typename internal::packet_traits<Scalar>::type>::half, typename internal::packet_traits<Scalar>::type>::value>
static void vectorization_logic_half< Scalar, Enable >::run ( )
inlinestatic
295  {
296  // Some half-packets have a byte size < EIGEN_MIN_ALIGN_BYTES (e.g. Packet2f),
297  // which causes many of these tests to fail since they don't vectorize if
298  // EIGEN_UNALIGNED_VECTORIZE is 0 (the matrix is assumed unaligned).
299  // Adjust the matrix sizes to account for these alignment issues.
300  constexpr int PacketBytes = sizeof(Scalar) * PacketSize;
301  constexpr int MinVSize = int(EIGEN_UNALIGNED_VECTORIZE) ? PacketSize
302  : PacketBytes >= EIGEN_MIN_ALIGN_BYTES
303  ? PacketSize
304  : (EIGEN_MIN_ALIGN_BYTES + sizeof(Scalar) - 1) / sizeof(Scalar);
305 
306  typedef Matrix<Scalar, MinVSize, 1> Vector1;
307  typedef Matrix<Scalar, MinVSize, MinVSize> Matrix11;
308  typedef Matrix<Scalar, 5 * MinVSize, 7, ColMajor> Matrix57;
309  typedef Matrix<Scalar, 3 * MinVSize, 5, ColMajor> Matrix35;
310  typedef Matrix<Scalar, 5 * MinVSize, 7, DontAlign | ColMajor> Matrix57u;
311 
312  typedef Matrix<Scalar,
313  (PacketSize == 16 ? 8
314  : PacketSize == 8 ? 4
315  : PacketSize == 4 ? 2
316  : PacketSize == 2 ? 1
317  : /*PacketSize==1 ?*/ 1),
318  (PacketSize == 16 ? 2
319  : PacketSize == 8 ? 2
320  : PacketSize == 4 ? 2
321  : PacketSize == 2 ? 2
322  : /*PacketSize==1 ?*/ 1)>
323  Matrix1;
324 
325  typedef Matrix<Scalar,
326  (PacketSize == 16 ? 8
327  : PacketSize == 8 ? 4
328  : PacketSize == 4 ? 2
329  : PacketSize == 2 ? 1
330  : /*PacketSize==1 ?*/ 1),
331  (PacketSize == 16 ? 2
332  : PacketSize == 8 ? 2
333  : PacketSize == 4 ? 2
334  : PacketSize == 2 ? 2
335  : /*PacketSize==1 ?*/ 1),
336  DontAlign | ((Matrix1::Flags & RowMajorBit) ? RowMajor : ColMajor)>
337  Matrix1u;
338 
339  // this type is made such that it can only be vectorized when viewed as a linear 1D vector
340  typedef Matrix<Scalar,
341  (MinVSize == 16 ? 4
342  : MinVSize == 8 ? 4
343  : MinVSize == 4 ? 6
344  : MinVSize == 2 ? ((Matrix11::Flags & RowMajorBit) ? 2 : 3)
345  : /*PacketSize==1 ?*/ 1),
346  (MinVSize == 16 ? 12
347  : MinVSize == 8 ? 6
348  : MinVSize == 4 ? 2
349  : MinVSize == 2 ? ((Matrix11::Flags & RowMajorBit) ? 3 : 2)
350  : /*PacketSize==1 ?*/ 3)>
351  Matrix3;
352 
353 #if !EIGEN_GCC_AND_ARCH_DOESNT_WANT_STACK_ALIGNMENT
354  VERIFY(test_assign(Vector1(), Vector1(), InnerVectorizedTraversal, CompleteUnrolling));
355  VERIFY(test_assign(Vector1(), Vector1() + Vector1(), InnerVectorizedTraversal, CompleteUnrolling));
356  VERIFY(test_assign(Vector1(), Vector1().template segment<MinVSize>(0).derived(),
357  EIGEN_UNALIGNED_VECTORIZE ? InnerVectorizedTraversal : LinearVectorizedTraversal,
358  CompleteUnrolling));
359  VERIFY(test_assign(Vector1(), Scalar(RealScalar(2.1)) * Vector1() - Vector1(), InnerVectorizedTraversal,
360  CompleteUnrolling));
361  VERIFY(test_assign(
362  Vector1(),
363  (Scalar(RealScalar(2.1)) * Vector1().template segment<MinVSize>(0) - Vector1().template segment<MinVSize>(0))
364  .derived(),
365  EIGEN_UNALIGNED_VECTORIZE ? InnerVectorizedTraversal : LinearVectorizedTraversal, CompleteUnrolling));
366  VERIFY(test_assign(Vector1(), Vector1().cwiseProduct(Vector1()), InnerVectorizedTraversal, CompleteUnrolling));
367  VERIFY(test_assign(Vector1(), Vector1().template cast<Scalar>(), InnerVectorizedTraversal, CompleteUnrolling));
368 
369  VERIFY(test_assign(Matrix57(), Matrix57() + Matrix57(), InnerVectorizedTraversal, InnerUnrolling));
370 
371  VERIFY(test_assign(Matrix57u(), Matrix57() + Matrix57(),
372  EIGEN_UNALIGNED_VECTORIZE ? InnerVectorizedTraversal : LinearTraversal,
373  EIGEN_UNALIGNED_VECTORIZE ? InnerUnrolling : NoUnrolling));
374 
375  VERIFY(test_assign(Matrix1u(), Matrix1() + Matrix1(),
376  EIGEN_UNALIGNED_VECTORIZE
377  ? ((int(Matrix1::InnerSizeAtCompileTime) % int(PacketSize)) == 0 ? InnerVectorizedTraversal
378  : LinearVectorizedTraversal)
379  : LinearTraversal,
380  CompleteUnrolling));
381 
382  if (PacketSize > 1) {
383  typedef Matrix<Scalar, 3, 3, ColMajor> Matrix33c;
384  VERIFY(
385  test_assign(Matrix33c().row(2), Matrix33c().row(1) + Matrix33c().row(1), LinearTraversal, CompleteUnrolling));
386 
387  // Unrolling depends on read costs and unroll limits, which vary - ignore.
388  VERIFY(test_assign(Matrix3(), Matrix3().cwiseQuotient(Matrix3()),
389  PacketTraits::HasDiv ? LinearVectorizedTraversal : LinearTraversal, -1));
390 
391  VERIFY(test_assign(Matrix<Scalar, 17, 17>(), Matrix<Scalar, 17, 17>() + Matrix<Scalar, 17, 17>(),
392  sizeof(Scalar) == 16
393  ? InnerVectorizedTraversal
394  : (EIGEN_UNALIGNED_VECTORIZE ? LinearVectorizedTraversal : LinearTraversal),
395  NoUnrolling));
396 
397  VERIFY(test_assign(Matrix11(),
398  Matrix<Scalar, 17, 17>().template block<MinVSize, MinVSize>(2, 3) +
399  Matrix<Scalar, 17, 17>().template block<MinVSize, MinVSize>(8, 4),
400  EIGEN_UNALIGNED_VECTORIZE ? InnerVectorizedTraversal : DefaultTraversal,
401  InnerUnrolling + CompleteUnrolling));
402 
403  VERIFY(test_assign(Vector1(), Matrix11() * Vector1(), InnerVectorizedTraversal, CompleteUnrolling));
404 
405  VERIFY(test_assign(Matrix11(), Matrix11().lazyProduct(Matrix11()), InnerVectorizedTraversal,
406  InnerUnrolling + CompleteUnrolling));
407  }
408 
409  VERIFY(test_redux(Vector1(), LinearVectorizedTraversal, CompleteUnrolling));
410 
411  VERIFY(test_redux(Matrix<Scalar, MinVSize, 3>(), LinearVectorizedTraversal, CompleteUnrolling));
412 
413  VERIFY(test_redux(Matrix3(), LinearVectorizedTraversal, CompleteUnrolling));
414 
415  VERIFY(test_redux(Matrix35(), LinearVectorizedTraversal, CompleteUnrolling));
416 
417  VERIFY(test_redux(Matrix57().template block < PacketSize == 1 ? 2 : PacketSize, 3 > (1, 0),
418  SliceVectorizedTraversal, CompleteUnrolling));
419 
420  if (PacketSize > 1) {
421  VERIFY(test_redux(Matrix57().template block<PacketSize, 2>(1, 0), DefaultTraversal, CompleteUnrolling));
422  }
423 
424  VERIFY((test_assign<
425  Map<Matrix<Scalar, internal::plain_enum_max(2, PacketSize), internal::plain_enum_max(2, PacketSize)>,
426  AlignedMax, InnerStride<3 * PacketSize> >,
427  Matrix<Scalar, internal::plain_enum_max(2, PacketSize), internal::plain_enum_max(2, PacketSize)> >(
428  DefaultTraversal, PacketSize > 4 ? InnerUnrolling : CompleteUnrolling)));
429 
430  VERIFY((test_assign(Matrix57(), Matrix<Scalar, 5 * MinVSize, 3>() * Matrix<Scalar, 3, 7>(),
431  InnerVectorizedTraversal, InnerUnrolling + CompleteUnrolling)));
432 #endif
433  }
EIGEN_MIN_ALIGN_BYTES
#define EIGEN_MIN_ALIGN_BYTES
Definition: ConfigureVectorization.h:73
EIGEN_UNALIGNED_VECTORIZE
#define EIGEN_UNALIGNED_VECTORIZE
Definition: ConfigureVectorization.h:173
row
m row(1)
Scalar
SCALAR Scalar
Definition: bench_gemm.cpp:45
Eigen::InnerStride
Convenience specialization of Stride to specify only an inner stride See class Map for some examples.
Definition: Stride.h:93
Eigen::Map
A matrix or vector expression mapping an existing array of data.
Definition: Map.h:96
Eigen::Matrix
The matrix class, also used for vectors and row-vectors.
Definition: Eigen/Eigen/src/Core/Matrix.h:186
Eigen::InnerVectorizedTraversal
@ InnerVectorizedTraversal
Definition: Constants.h:284
Eigen::LinearVectorizedTraversal
@ LinearVectorizedTraversal
Definition: Constants.h:287
Eigen::DefaultTraversal
@ DefaultTraversal
Definition: Constants.h:279
Eigen::SliceVectorizedTraversal
@ SliceVectorizedTraversal
Definition: Constants.h:290
Eigen::LinearTraversal
@ LinearTraversal
Definition: Constants.h:281
Eigen::AlignedMax
@ AlignedMax
Definition: Constants.h:254
Eigen::ColMajor
@ ColMajor
Definition: Constants.h:318
Eigen::DontAlign
@ DontAlign
Definition: Constants.h:324
Eigen::RowMajor
@ RowMajor
Definition: Constants.h:320
Eigen::InnerUnrolling
@ InnerUnrolling
Definition: Constants.h:303
Eigen::CompleteUnrolling
@ CompleteUnrolling
Definition: Constants.h:306
Eigen::NoUnrolling
@ NoUnrolling
Definition: Constants.h:301
Eigen::RowMajorBit
const unsigned int RowMajorBit
Definition: Constants.h:70
int
return int(ret)+1
VERIFY
#define VERIFY(a)
Definition: main.h:362
Eigen::internal::plain_enum_max
constexpr int plain_enum_max(A a, B b)
Definition: Meta.h:656
vectorization_logic_half::PacketSize
static constexpr int PacketSize
Definition: vectorization_logic.cpp:293
vectorization_logic_half::RealScalar
typename NumTraits< Scalar >::Real RealScalar
Definition: vectorization_logic.cpp:290
test_redux
bool test_redux(const Xpr &, int traversal, int unrolling)
Definition: vectorization_logic.cpp:88
test_assign
bool test_assign(const Dst &, const Src &, int traversal, int unrolling)
Definition: vectorization_logic.cpp:38

References Eigen::AlignedMax, Eigen::ColMajor, Eigen::CompleteUnrolling, Eigen::DefaultTraversal, Eigen::DontAlign, EIGEN_MIN_ALIGN_BYTES, EIGEN_UNALIGNED_VECTORIZE, Eigen::InnerUnrolling, Eigen::InnerVectorizedTraversal, int(), Eigen::LinearTraversal, Eigen::LinearVectorizedTraversal, Eigen::NoUnrolling, vectorization_logic_half< Scalar, Enable >::PacketSize, Eigen::internal::plain_enum_max(), row(), Eigen::RowMajor, Eigen::RowMajorBit, Eigen::SliceVectorizedTraversal, test_assign(), test_redux(), and VERIFY.

Member Data Documentation

◆ PacketSize

template<typename Scalar , bool Enable = !internal::is_same< typename internal::unpacket_traits<typename internal::packet_traits<Scalar>::type>::half, typename internal::packet_traits<Scalar>::type>::value>
constexpr int vectorization_logic_half< Scalar, Enable >::PacketSize = internal::unpacket_traits<PacketType>::size
staticconstexpr

Referenced by vectorization_logic_half< Scalar, Enable >::run().

The documentation for this struct was generated from the following file: