Eigen::internal::TensorBlockAssignment< Scalar, NumDims, TensorBlockExpr, IndexType > Class Template Reference

#include <TensorBlock.h>

Classes
struct	BlockIteratorState
struct	InnerDimAssign
struct	InnerDimAssign< true, Evaluator >
struct	Target

Static Public Member Functions
static Target	target (const Dimensions &target_dims, const Dimensions &target_strides, Scalar *target_data, IndexType target_offset=0)
template<typename TargetDimsIndexType , typename TargetStridesIndexType >
static Target	target (const DSizes< TargetDimsIndexType, NumDims > &target_dims, const DSizes< TargetStridesIndexType, NumDims > &target_strides, Scalar *target_data, IndexType target_offset=0)
static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void	Run (const Target &target, const TensorBlockExpr &expr)

Private Types
enum	{ Vectorizable = packet_traits<Scalar>::Vectorizable , PacketSize = packet_traits<Scalar>::size }
typedef TensorEvaluator< const TensorBlockExpr, DefaultDevice >	TensorBlockEvaluator
typedef DSizes< IndexType, NumDims >	Dimensions

Member Typedef Documentation

Dimensions

template<typename Scalar , int NumDims, typename TensorBlockExpr , typename IndexType = Eigen::Index>

typedef DSizes<IndexType, NumDims> Eigen::internal::TensorBlockAssignment< Scalar, NumDims, TensorBlockExpr, IndexType >::Dimensions

private

TensorBlockEvaluator

template<typename Scalar , int NumDims, typename TensorBlockExpr , typename IndexType = Eigen::Index>

typedef TensorEvaluator<const TensorBlockExpr, DefaultDevice> Eigen::internal::TensorBlockAssignment< Scalar, NumDims, TensorBlockExpr, IndexType >::TensorBlockEvaluator

private

Member Enumeration Documentation

anonymous enum

template<typename Scalar , int NumDims, typename TensorBlockExpr , typename IndexType = Eigen::Index>

anonymous enum

private

Enumerator
Vectorizable
PacketSize

{ Vectorizable = packet_traits<Scalar>::Vectorizable, PacketSize = packet_traits<Scalar>::size };

Member Function Documentation

Run()

template<typename Scalar , int NumDims, typename TensorBlockExpr , typename IndexType = Eigen::Index>

static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void Eigen::internal::TensorBlockAssignment< Scalar, NumDims, TensorBlockExpr, IndexType >::Run ( const Target &  target, const TensorBlockExpr &  expr  )

inlinestatic

                                                                                                           {
    // Prepare evaluator for block expression.
    DefaultDevice default_device;
    TensorBlockEvaluator eval(expr, default_device);
 
    // Tensor block expression dimension should match destination dimensions.
    eigen_assert(dimensions_match(target.dims, eval.dimensions()));
 
    static const int Layout = TensorBlockEvaluator::Layout;
    static const bool is_col_major = Layout == ColMajor;
 
    // Initialize output inner dimension size based on a layout.
    const IndexType output_size = NumDims == 0 ? 1 : target.dims.TotalSize();
    const int inner_dim_idx = is_col_major ? 0 : NumDims - 1;
    IndexType output_inner_dim_size = target.dims[inner_dim_idx];
 
    // Target inner dimension stride must be '1'.
    eigen_assert(target.strides[inner_dim_idx] == 1);
 
    // Squeeze multiple inner dims into one if they are contiguous in `target`.
    IndexType num_squeezed_dims = 0;
    for (Index i = 1; i < NumDims; ++i) {
      const Index dim = is_col_major ? i : NumDims - i - 1;
      const IndexType target_stride = target.strides[dim];
 
      if (output_inner_dim_size == target_stride) {
        output_inner_dim_size *= target.dims[dim];
        num_squeezed_dims++;
      } else {
        break;
      }
    }
 
    // Initialize output block iterator state. Dimension in this array are
    // always in inner_most -> outer_most order (col major layout).
    array<BlockIteratorState, NumDims> it;
 
    int idx = 0;  // currently initialized iterator state index
    for (Index i = num_squeezed_dims; i < NumDims - 1; ++i) {
      const Index dim = is_col_major ? i + 1 : NumDims - i - 2;
 
      it[idx].count = 0;
      it[idx].size = target.dims[dim];
      it[idx].output_stride = target.strides[dim];
      it[idx].output_span = it[idx].output_stride * (it[idx].size - 1);
      idx++;
    }
 
    // We read block expression from the beginning, and start writing data to
    // `target` at given offset.
    IndexType input_offset = 0;
    IndexType output_offset = target.offset;
 
    // Iterate copying data from `eval` to `target`.
    for (IndexType i = 0; i < output_size; i += output_inner_dim_size) {
      // Assign to `target` at current offset.
      InnerDimAssign<Vectorizable && TensorBlockEvaluator::PacketAccess, TensorBlockEvaluator>::Run(
          target.data + output_offset, output_inner_dim_size, eval, input_offset);
 
      // Move input offset forward by the number of assigned coefficients.
      input_offset += output_inner_dim_size;
 
      // Update index.
      for (int j = 0; j < idx; ++j) {
        if (++it[j].count < it[j].size) {
          output_offset += it[j].output_stride;
          break;
        }
        it[j].count = 0;
        output_offset -= it[j].output_span;
      }
    }
  }

References Eigen::ColMajor, Eigen::internal::TensorBlockAssignment< Scalar, NumDims, TensorBlockExpr, IndexType >::Target::data, Eigen::dimensions_match(), Eigen::internal::TensorBlockAssignment< Scalar, NumDims, TensorBlockExpr, IndexType >::Target::dims, eigen_assert, eval(), i, j, Eigen::TensorEvaluator< Derived, Device >::Layout, Eigen::internal::TensorBlockAssignment< Scalar, NumDims, TensorBlockExpr, IndexType >::Target::offset, Eigen::internal::TensorBlockAssignment< Scalar, NumDims, TensorBlockExpr, IndexType >::InnerDimAssign< Vectorizable, Evaluator >::Run(), size, Eigen::internal::TensorBlockAssignment< Scalar, NumDims, TensorBlockExpr, IndexType >::Target::strides, Eigen::internal::TensorBlockAssignment< Scalar, NumDims, TensorBlockExpr, IndexType >::target(), and Eigen::DSizes< DenseIndex, NumDims >::TotalSize().

target() [1/2]

template<typename Scalar , int NumDims, typename TensorBlockExpr , typename IndexType = Eigen::Index>

static Target Eigen::internal::TensorBlockAssignment< Scalar, NumDims, TensorBlockExpr, IndexType >::target ( const Dimensions &  target_dims, const Dimensions &  target_strides, Scalar *  target_data, IndexType  target_offset = 0  )

inlinestatic

                                                    {
    return Target(target_dims, target_strides, target_data, target_offset);
  }

References Eigen::Architecture::Target.

Referenced by Eigen::internal::TensorBlockAssignment< Scalar, NumDims, TensorBlockExpr, IndexType >::Run(), Eigen::internal::TensorBlockAssignment< Scalar, NumDims, TensorBlockExpr, IndexType >::InnerDimAssign< Vectorizable, Evaluator >::Run(), and Eigen::internal::TensorBlockAssignment< Scalar, NumDims, TensorBlockExpr, IndexType >::InnerDimAssign< true, Evaluator >::Run().

target() [2/2]

template<typename Scalar , int NumDims, typename TensorBlockExpr , typename IndexType = Eigen::Index>

template<typename TargetDimsIndexType , typename TargetStridesIndexType >

static Target Eigen::internal::TensorBlockAssignment< Scalar, NumDims, TensorBlockExpr, IndexType >::target ( const DSizes< TargetDimsIndexType, NumDims > &  target_dims, const DSizes< TargetStridesIndexType, NumDims > &  target_strides, Scalar *  target_data, IndexType  target_offset = 0  )

inlinestatic

                                                    {
    // DSizes constructor will do index type promotion if it's safe.
    return Target(Dimensions(target_dims), Dimensions(target_strides), target_data, target_offset);
  }

References Eigen::Architecture::Target.

---

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

• TensorBlock.h