Public Member Functions | List of all members
Eigen::internal::dhs_cpack< Scalar, DataMapper, Packet, PacketC, StorageOrder, Conjugate, PanelMode, UseLhs > Struct Template Reference

#include <MatrixProduct.h>

Public Member Functions

template<bool transpose>
EIGEN_ALWAYS_INLINE void dhs_cblock (PacketBlock< PacketC, 8 > &cblock, PacketBlock< Packet, 4 > &block, Packet16uc permute)
 
EIGEN_ALWAYS_INLINE void dhs_ccopy (Scalar *blockAt, const DataMapper &lhs2, Index &i, Index &rir, Index &rii, Index depth, const Index vectorSize)
 
EIGEN_STRONG_INLINE void operator() (std::complex< Scalar > *blockA, const DataMapper &lhs, Index depth, Index rows, Index stride, Index offset)
 

Member Function Documentation

◆ dhs_cblock()

template<typename Scalar , typename DataMapper , typename Packet , typename PacketC , int StorageOrder, bool Conjugate, bool PanelMode, bool UseLhs>
template<bool transpose>
EIGEN_ALWAYS_INLINE void Eigen::internal::dhs_cpack< Scalar, DataMapper, Packet, PacketC, StorageOrder, Conjugate, PanelMode, UseLhs >::dhs_cblock ( PacketBlock< PacketC, 8 > &  cblock,
PacketBlock< Packet, 4 > &  block,
Packet16uc  permute 
)
inline
384  {
385  if (transpose) {
386  block.packet[0] = vec_perm(cblock.packet[0].v, cblock.packet[1].v, permute);
387  block.packet[1] = vec_perm(cblock.packet[2].v, cblock.packet[3].v, permute);
388  block.packet[2] = vec_perm(cblock.packet[4].v, cblock.packet[5].v, permute);
389  block.packet[3] = vec_perm(cblock.packet[6].v, cblock.packet[7].v, permute);
390 
391  Packet4f t0, t1, t2, t3;
392 #ifdef EIGEN_VECTORIZE_VSX
393  t0 = reinterpret_cast<Packet>(
394  vec_mergeh(reinterpret_cast<Packet2ul>(block.packet[0]), reinterpret_cast<Packet2ul>(block.packet[1])));
395  t1 = reinterpret_cast<Packet>(
396  vec_mergel(reinterpret_cast<Packet2ul>(block.packet[0]), reinterpret_cast<Packet2ul>(block.packet[1])));
397  t2 = reinterpret_cast<Packet>(
398  vec_mergeh(reinterpret_cast<Packet2ul>(block.packet[2]), reinterpret_cast<Packet2ul>(block.packet[3])));
399  t3 = reinterpret_cast<Packet>(
400  vec_mergel(reinterpret_cast<Packet2ul>(block.packet[2]), reinterpret_cast<Packet2ul>(block.packet[3])));
401 #else
402  t0 = reinterpret_cast<Packet>(vec_perm(block.packet[0], block.packet[1], p16uc_TRANSPOSE64_HI));
403  t1 = reinterpret_cast<Packet>(vec_perm(block.packet[0], block.packet[1], p16uc_TRANSPOSE64_LO));
404  t2 = reinterpret_cast<Packet>(vec_perm(block.packet[2], block.packet[3], p16uc_TRANSPOSE64_HI));
405  t3 = reinterpret_cast<Packet>(vec_perm(block.packet[2], block.packet[3], p16uc_TRANSPOSE64_LO));
406 #endif
407 
408  block.packet[0] = t0;
409  block.packet[1] = t1;
410  block.packet[2] = t2;
411  block.packet[3] = t3;
412  } else {
413  block.packet[0] = vec_perm(cblock.packet[0].v, cblock.packet[4].v, permute);
414  block.packet[1] = vec_perm(cblock.packet[1].v, cblock.packet[5].v, permute);
415  block.packet[2] = vec_perm(cblock.packet[2].v, cblock.packet[6].v, permute);
416  block.packet[3] = vec_perm(cblock.packet[3].v, cblock.packet[7].v, permute);
417  }
418  }
block
m m block(1, 0, 2, 2)<< 4
Eigen::internal::p16uc_TRANSPOSE64_LO
static Packet16uc p16uc_TRANSPOSE64_LO
Definition: AltiVec/PacketMath.h:145
Eigen::internal::Packet4f
__vector float Packet4f
Definition: AltiVec/PacketMath.h:33
Eigen::internal::Packet2ul
eigen_packet_wrapper< __m128i, 7 > Packet2ul
Definition: LSX/PacketMath.h:45
Eigen::internal::p16uc_TRANSPOSE64_HI
static Packet16uc p16uc_TRANSPOSE64_HI
Definition: AltiVec/PacketMath.h:143
anonymous_namespace{skew_symmetric_matrix3.cpp}::transpose
void transpose()
Definition: skew_symmetric_matrix3.cpp:135

References block(), Eigen::internal::p16uc_TRANSPOSE64_HI, Eigen::internal::p16uc_TRANSPOSE64_LO, Eigen::internal::PacketBlock< Packet, N >::packet, and anonymous_namespace{skew_symmetric_matrix3.cpp}::transpose().

◆ dhs_ccopy()

template<typename Scalar , typename DataMapper , typename Packet , typename PacketC , int StorageOrder, bool Conjugate, bool PanelMode, bool UseLhs>
EIGEN_ALWAYS_INLINE void Eigen::internal::dhs_cpack< Scalar, DataMapper, Packet, PacketC, StorageOrder, Conjugate, PanelMode, UseLhs >::dhs_ccopy ( Scalar *  blockAt,
const DataMapper &  lhs2,
Index &  i,
Index &  rir,
Index &  rii,
Index  depth,
const Index  vectorSize 
)
inline
421  {
422  PacketBlock<Packet, 4> blockr, blocki;
423  PacketBlock<PacketC, 8> cblock;
424 
425  for (; i + vectorSize <= depth; i += vectorSize) {
426  if (UseLhs) {
427  bload<DataMapper, PacketC, 2, StorageOrder, true, 4>(cblock, lhs2, 0, i);
428  } else {
429  bload<DataMapper, PacketC, 2, StorageOrder, true, 4>(cblock, lhs2, i, 0);
430  }
431 
432  if (((StorageOrder == RowMajor) && UseLhs) || (((StorageOrder == ColMajor) && !UseLhs))) {
433  dhs_cblock<true>(cblock, blockr, p16uc_GETREAL32b);
434  dhs_cblock<true>(cblock, blocki, p16uc_GETIMAG32b);
435  } else {
436  dhs_cblock<false>(cblock, blockr, p16uc_GETREAL32);
437  dhs_cblock<false>(cblock, blocki, p16uc_GETIMAG32);
438  }
439 
440  if (Conjugate) {
441  blocki.packet[0] = -blocki.packet[0];
442  blocki.packet[1] = -blocki.packet[1];
443  blocki.packet[2] = -blocki.packet[2];
444  blocki.packet[3] = -blocki.packet[3];
445  }
446 
447  storeBlock<Scalar, Packet, 4>(blockAt + rir, blockr);
448  storeBlock<Scalar, Packet, 4>(blockAt + rii, blocki);
449 
450  rir += 4 * vectorSize;
451  rii += 4 * vectorSize;
452  }
453  }
i
int i
Definition: BiCGSTAB_step_by_step.cpp:9
Eigen::ColMajor
@ ColMajor
Definition: Constants.h:318
Eigen::RowMajor
@ RowMajor
Definition: Constants.h:320
Eigen::internal::p16uc_GETIMAG32b
static const Packet16uc p16uc_GETIMAG32b
Definition: MatrixProduct.h:96
Eigen::internal::p16uc_GETIMAG32
static const Packet16uc p16uc_GETIMAG32
Definition: MatrixProduct.h:92
Eigen::internal::p16uc_GETREAL32
static const Packet16uc p16uc_GETREAL32
Definition: MatrixProduct.h:90
Eigen::internal::p16uc_GETREAL32b
static const Packet16uc p16uc_GETREAL32b
Definition: MatrixProduct.h:94

References Eigen::ColMajor, i, Eigen::internal::p16uc_GETIMAG32, Eigen::internal::p16uc_GETIMAG32b, Eigen::internal::p16uc_GETREAL32, Eigen::internal::p16uc_GETREAL32b, Eigen::internal::PacketBlock< Packet, N >::packet, and Eigen::RowMajor.

Referenced by Eigen::internal::dhs_cpack< double, DataMapper, Packet, PacketC, StorageOrder, Conjugate, PanelMode, true >::operator()(), Eigen::internal::dhs_cpack< double, DataMapper, Packet, PacketC, StorageOrder, Conjugate, PanelMode, false >::operator()(), and Eigen::internal::dhs_cpack< Scalar, DataMapper, Packet, PacketC, StorageOrder, Conjugate, PanelMode, UseLhs >::operator()().

◆ operator()()

template<typename Scalar , typename DataMapper , typename Packet , typename PacketC , int StorageOrder, bool Conjugate, bool PanelMode, bool UseLhs>
EIGEN_STRONG_INLINE void Eigen::internal::dhs_cpack< Scalar, DataMapper, Packet, PacketC, StorageOrder, Conjugate, PanelMode, UseLhs >::operator() ( std::complex< Scalar > *  blockA,
const DataMapper &  lhs,
Index  depth,
Index  rows,
Index  stride,
Index  offset 
)
inline
456  {
457  const Index vectorSize = quad_traits<Scalar>::vectorsize;
458  const Index vectorDelta = vectorSize * ((PanelMode) ? stride : depth);
459  Index rir = ((PanelMode) ? (vectorSize * offset) : 0), rii;
460  Scalar* blockAt = reinterpret_cast<Scalar*>(blockA);
461  Index j = 0;
462 
463  for (; j + vectorSize <= rows; j += vectorSize) {
464  const DataMapper lhs2 = UseLhs ? lhs.getSubMapper(j, 0) : lhs.getSubMapper(0, j);
465  Index i = 0;
466 
467  rii = rir + vectorDelta;
468 
469  dhs_ccopy(blockAt, lhs2, i, rir, rii, depth, vectorSize);
470 
471  for (; i < depth; i++) {
472  PacketBlock<Packet, 1> blockr, blocki;
473  PacketBlock<PacketC, 2> cblock;
474 
475  if (((StorageOrder == ColMajor) && UseLhs) || (((StorageOrder == RowMajor) && !UseLhs))) {
476  if (UseLhs) {
477  cblock.packet[0] = lhs2.template loadPacket<PacketC>(0, i);
478  cblock.packet[1] = lhs2.template loadPacket<PacketC>(2, i);
479  } else {
480  cblock.packet[0] = lhs2.template loadPacket<PacketC>(i, 0);
481  cblock.packet[1] = lhs2.template loadPacket<PacketC>(i, 2);
482  }
483  } else {
484  if (UseLhs) {
485  cblock.packet[0] = pload2(lhs2(0, i), lhs2(1, i));
486  cblock.packet[1] = pload2(lhs2(2, i), lhs2(3, i));
487  } else {
488  cblock.packet[0] = pload2(lhs2(i, 0), lhs2(i, 1));
489  cblock.packet[1] = pload2(lhs2(i, 2), lhs2(i, 3));
490  }
491  }
492 
493  blockr.packet[0] = vec_perm(cblock.packet[0].v, cblock.packet[1].v, p16uc_GETREAL32);
494  blocki.packet[0] = vec_perm(cblock.packet[0].v, cblock.packet[1].v, p16uc_GETIMAG32);
495 
496  if (Conjugate) {
497  blocki.packet[0] = -blocki.packet[0];
498  }
499 
500  pstore<Scalar>(blockAt + rir, blockr.packet[0]);
501  pstore<Scalar>(blockAt + rii, blocki.packet[0]);
502 
503  rir += vectorSize;
504  rii += vectorSize;
505  }
506 
507  rir += ((PanelMode) ? (vectorSize * (2 * stride - depth)) : vectorDelta);
508  }
509 
510  if (!UseLhs) {
511  if (PanelMode) rir -= (offset * (vectorSize - 1));
512 
513  for (; j < rows; j++) {
514  const DataMapper lhs2 = lhs.getSubMapper(0, j);
515  rii = rir + ((PanelMode) ? stride : depth);
516 
517  for (Index i = 0; i < depth; i++) {
518  blockAt[rir] = lhs2(i, 0).real();
519 
520  if (Conjugate)
521  blockAt[rii] = -lhs2(i, 0).imag();
522  else
523  blockAt[rii] = lhs2(i, 0).imag();
524 
525  rir += 1;
526  rii += 1;
527  }
528 
529  rir += ((PanelMode) ? (2 * stride - depth) : depth);
530  }
531  } else {
532  if (j < rows) {
533  if (PanelMode) rir += (offset * (rows - j - vectorSize));
534  rii = rir + (((PanelMode) ? stride : depth) * (rows - j));
535 
536  for (Index i = 0; i < depth; i++) {
537  Index k = j;
538  for (; k < rows; k++) {
539  blockAt[rir] = lhs(k, i).real();
540 
541  if (Conjugate)
542  blockAt[rii] = -lhs(k, i).imag();
543  else
544  blockAt[rii] = lhs(k, i).imag();
545 
546  rir += 1;
547  rii += 1;
548  }
549  }
550  }
551  }
552  }
rows
int rows
Definition: Tutorial_commainit_02.cpp:1
Scalar
SCALAR Scalar
Definition: bench_gemm.cpp:45
k
char char char int int * k
Definition: level2_impl.h:374
Eigen::internal::pload2
EIGEN_STRONG_INLINE Packet2cf pload2(const std::complex< float > &from0, const std::complex< float > &from1)
Definition: AltiVec/Complex.h:185
Eigen::Index
EIGEN_DEFAULT_DENSE_INDEX_TYPE Index
The Index type as used for the API.
Definition: Meta.h:83
Eigen::internal::dhs_cpack::dhs_ccopy
EIGEN_ALWAYS_INLINE void dhs_ccopy(Scalar *blockAt, const DataMapper &lhs2, Index &i, Index &rir, Index &rii, Index depth, const Index vectorSize)
Definition: MatrixProduct.h:420
Eigen::internal::quad_traits::vectorsize
@ vectorsize
Definition: MatrixProduct.h:67
j
std::ptrdiff_t j
Definition: tut_arithmetic_redux_minmax.cpp:2

References Eigen::ColMajor, Eigen::internal::dhs_cpack< Scalar, DataMapper, Packet, PacketC, StorageOrder, Conjugate, PanelMode, UseLhs >::dhs_ccopy(), i, j, k, Eigen::internal::p16uc_GETIMAG32, Eigen::internal::p16uc_GETREAL32, Eigen::internal::PacketBlock< Packet, N >::packet, Eigen::internal::pload2(), Eigen::RowMajor, and rows.

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