Eigen::internal::TensorBlockIO< Scalar, IndexType, NumDims, Layout > Class Template Reference

#include <TensorBlock.h>

Classes
struct	BlockIteratorState
struct	Dst
struct	Src

Public Types
typedef DSizes< IndexType, NumDims >	Dimensions
typedef DSizes< int, NumDims >	DimensionsMap

Static Public Member Functions
static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE IndexType	Copy (const Dst &dst, const Src &src, const DimensionsMap &dst_to_src_dim_map)
static EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE IndexType	Copy (const Dst &dst, const Src &src)

Private Types
typedef StridedLinearBufferCopy< Scalar, IndexType >	LinCopy

Static Private Member Functions
static int	NumSqueezableInnerDims (const DimensionsMap &dim_map)

Static Private Attributes
static constexpr bool	IsColMajor = (Layout == ColMajor)

Member Typedef Documentation

Dimensions

template<typename Scalar , typename IndexType , int NumDims, int Layout>

typedef DSizes<IndexType, NumDims> Eigen::internal::TensorBlockIO< Scalar, IndexType, NumDims, Layout >::Dimensions

DimensionsMap

template<typename Scalar , typename IndexType , int NumDims, int Layout>

typedef DSizes<int, NumDims> Eigen::internal::TensorBlockIO< Scalar, IndexType, NumDims, Layout >::DimensionsMap

LinCopy

template<typename Scalar , typename IndexType , int NumDims, int Layout>

typedef StridedLinearBufferCopy<Scalar, IndexType> Eigen::internal::TensorBlockIO< Scalar, IndexType, NumDims, Layout >::LinCopy

private

Member Function Documentation

Copy() [1/2]

template<typename Scalar , typename IndexType , int NumDims, int Layout>

static EIGEN_DEVICE_FUNC EIGEN_ALWAYS_INLINE IndexType Eigen::internal::TensorBlockIO< Scalar, IndexType, NumDims, Layout >::Copy ( const Dst &  dst, const Src &  src  )

inlinestatic

                                                                                              {
    DimensionsMap dst_to_src_map;
    for (int i = 0; i < NumDims; ++i) dst_to_src_map[i] = i;
    return Copy(dst, src, dst_to_src_map);
  }

References Eigen::internal::TensorBlockIO< Scalar, IndexType, NumDims, Layout >::Copy(), and i.

Copy() [2/2]

template<typename Scalar , typename IndexType , int NumDims, int Layout>

static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE IndexType Eigen::internal::TensorBlockIO< Scalar, IndexType, NumDims, Layout >::Copy ( const Dst &  dst, const Src &  src, const DimensionsMap &  dst_to_src_dim_map  )

inlinestatic

                                                                                                       {
    // Copy single scalar value from `src` to `dst`.
    if (NumDims == 0) {
      *(dst.data + dst.offset) = *(src.data + src.offset);
      return 1;
    }
 
    // Both `dst` and `src` must have contiguous innermost dimension. We also
    // accept the special case with stride '0', because it's used as a trick to
    // implement broadcasting.
    {
      int inner_dim = IsColMajor ? 0 : NumDims - 1;
      EIGEN_UNUSED_VARIABLE(inner_dim);
      eigen_assert(dst.strides[inner_dim] == 1 || dst.strides[inner_dim] == 0);
      eigen_assert(src.strides[inner_dim] == 1 || src.strides[inner_dim] == 0);
    }
 
    // Give a shorter name to `dst_to_src_dim_map`.
    const DimensionsMap& dim_map = dst_to_src_dim_map;
 
    // Do not squeeze reordered inner dimensions.
    int num_squeezable_dims = NumSqueezableInnerDims(dim_map);
 
    // NOTE: We find the innermost dimension (contiguous in memory) in the dst
    // block, and we write data linearly into that dimension, reading it from
    // the src. If dimensions are reordered, we might end up reading data from
    // the src with `stride != 1`.
    //
    // NOTE: Random-Read/Linear-Write can be up to ~2X faster than
    // Linear-Read/Random-Write: https://stackoverflow.com/a/54935680
 
    // Find the innermost dimension in the dst whose size is not 1. This is the
    // effective inner dim.
    int num_size_one_inner_dims = 0;
    for (int i = 0; i < num_squeezable_dims; ++i) {
      const int dst_dim = IsColMajor ? i : NumDims - i - 1;
      if (dst.dims[dst_dim] != 1) break;
      num_size_one_inner_dims++;
    }
 
    // If all dimensions are of size 1, just copy a scalar from `src` to `dst`.
    if (num_size_one_inner_dims == NumDims) {
      *(dst.data + dst.offset) = *(src.data + src.offset);
      return 1;
    }
 
    // Outermost dimension in the dst with `stride == 1` (contiguous in memory).
    const int dst_stride1_dim = IsColMajor ? num_size_one_inner_dims : NumDims - num_size_one_inner_dims - 1;
 
    // Dimension in the src that corresponds to the dst innermost dimension.
    const int src_dim_for_dst_stride1_dim = NumDims == 0 ? 1 : dim_map[dst_stride1_dim];
 
    // Size of the innermost dimension (length of contiguous blocks of memory).
    IndexType dst_inner_dim_size = NumDims == 0 ? 1 : dst.dims[dst_stride1_dim];
 
    // Squeeze multiple inner dims into one if they are contiguous in `dst` and
    // `src` memory, so we can do less linear copy calls.
    for (int i = num_size_one_inner_dims + 1; i < num_squeezable_dims; ++i) {
      const int dst_dim = IsColMajor ? i : NumDims - i - 1;
      const IndexType dst_stride = dst.strides[dst_dim];
      const IndexType src_stride = src.strides[dim_map[dst_dim]];
      if (dst_inner_dim_size == dst_stride && dst_stride == src_stride) {
        dst_inner_dim_size *= dst.dims[dst_dim];
        ++num_size_one_inner_dims;
      } else {
        break;
      }
    }
 
    // Setup strides to read data from `src` and write to `dst`.
    IndexType input_offset = src.offset;
    IndexType output_offset = dst.offset;
    IndexType input_stride = NumDims == 0 ? 1 : src.strides[src_dim_for_dst_stride1_dim];
    IndexType output_stride = NumDims == 0 ? 1 : dst.strides[dst_stride1_dim];
 
    const int at_least_1_dim = NumDims <= 1 ? 1 : NumDims - 1;
    array<BlockIteratorState, at_least_1_dim> it;
 
    // Initialize block iterator state. Squeeze away any dimension of size 1.
    int idx = 0;  // currently initialized iterator state index
    for (int i = num_size_one_inner_dims; i < NumDims - 1; ++i) {
      const int dst_dim = IsColMajor ? i + 1 : NumDims - i - 2;
      if (dst.dims[dst_dim] == 1) continue;
 
      it[idx].size = dst.dims[dst_dim];
      it[idx].input_stride = src.strides[dim_map[dst_dim]];
      it[idx].output_stride = dst.strides[dst_dim];
 
      it[idx].input_span = it[idx].input_stride * (it[idx].size - 1);
      it[idx].output_span = it[idx].output_stride * (it[idx].size - 1);
 
      idx++;
    }
 
    // Iterate copying data from src to dst.
    const IndexType block_total_size = NumDims == 0 ? 1 : dst.dims.TotalSize();
 
#define COPY_INNER_DIM(KIND)                                                                                      \
  IndexType num_copied = 0;                                                                                       \
  for (num_copied = 0; num_copied < block_total_size; num_copied += dst_inner_dim_size) {                         \
    LinCopy::template Run<KIND>(typename LinCopy::Dst(output_offset, output_stride, dst.data),                    \
                                typename LinCopy::Src(input_offset, input_stride, src.data), dst_inner_dim_size); \
                                                                                                                  \
    for (int j = 0; j < idx; ++j) {                                                                               \
      if (++it[j].count < it[j].size) {                                                                           \
        input_offset += it[j].input_stride;                                                                       \
        output_offset += it[j].output_stride;                                                                     \
        break;                                                                                                    \
      }                                                                                                           \
      it[j].count = 0;                                                                                            \
      input_offset -= it[j].input_span;                                                                           \
      output_offset -= it[j].output_span;                                                                         \
    }                                                                                                             \
  }                                                                                                               \
  return num_copied;
 
    if (input_stride == 1 && output_stride == 1) {
      COPY_INNER_DIM(LinCopy::Kind::Linear);
    } else if (input_stride == 1 && output_stride != 1) {
      COPY_INNER_DIM(LinCopy::Kind::Scatter);
    } else if (input_stride == 0 && output_stride == 1) {
      COPY_INNER_DIM(LinCopy::Kind::FillLinear);
    } else if (input_stride == 0 && output_stride != 1) {
      COPY_INNER_DIM(LinCopy::Kind::FillScatter);
    } else if (output_stride == 1) {
      COPY_INNER_DIM(LinCopy::Kind::Gather);
    } else {
      COPY_INNER_DIM(LinCopy::Kind::Random);
    }
 
#undef COPY_INNER_DIM
  }

References COPY_INNER_DIM, Eigen::internal::TensorBlockIO< Scalar, IndexType, NumDims, Layout >::Dst::data, Eigen::internal::TensorBlockIO< Scalar, IndexType, NumDims, Layout >::Src::data, Eigen::internal::TensorBlockIO< Scalar, IndexType, NumDims, Layout >::Dst::dims, eigen_assert, EIGEN_UNUSED_VARIABLE, Eigen::internal::StridedLinearBufferCopy< Scalar, IndexType >::FillLinear, Eigen::internal::StridedLinearBufferCopy< Scalar, IndexType >::FillScatter, Eigen::internal::StridedLinearBufferCopy< Scalar, IndexType >::Gather, i, Eigen::internal::TensorBlockIO< Scalar, IndexType, NumDims, Layout >::IsColMajor, Eigen::internal::StridedLinearBufferCopy< Scalar, IndexType >::Linear, Eigen::internal::TensorBlockIO< Scalar, IndexType, NumDims, Layout >::NumSqueezableInnerDims(), Eigen::internal::TensorBlockIO< Scalar, IndexType, NumDims, Layout >::Dst::offset, Eigen::internal::TensorBlockIO< Scalar, IndexType, NumDims, Layout >::Src::offset, Eigen::internal::StridedLinearBufferCopy< Scalar, IndexType >::Random, Eigen::internal::StridedLinearBufferCopy< Scalar, IndexType >::Scatter, Eigen::internal::TensorBlockIO< Scalar, IndexType, NumDims, Layout >::Dst::strides, Eigen::internal::TensorBlockIO< Scalar, IndexType, NumDims, Layout >::Src::strides, and Eigen::DSizes< DenseIndex, NumDims >::TotalSize().

Referenced by Eigen::internal::TensorBlockIO< Scalar, IndexType, NumDims, Layout >::Copy(), and Eigen::internal::TensorMaterializedBlock< Scalar, NumDims, Layout, IndexType >::materialize().

NumSqueezableInnerDims()

template<typename Scalar , typename IndexType , int NumDims, int Layout>

static int Eigen::internal::TensorBlockIO< Scalar, IndexType, NumDims, Layout >::NumSqueezableInnerDims ( const DimensionsMap &  dim_map )

inlinestaticprivate

                                                                  {
    int num_squeezable_dims = 0;
    for (int i = 0; i < NumDims; ++i) {
      const int dim = IsColMajor ? i : NumDims - i - 1;
      if (dim_map[dim] != dim) break;
      num_squeezable_dims++;
    }
    return num_squeezable_dims;
  }

References i, and Eigen::internal::TensorBlockIO< Scalar, IndexType, NumDims, Layout >::IsColMajor.

Referenced by Eigen::internal::TensorBlockIO< Scalar, IndexType, NumDims, Layout >::Copy().

Member Data Documentation

IsColMajor

template<typename Scalar , typename IndexType , int NumDims, int Layout>

constexpr bool Eigen::internal::TensorBlockIO< Scalar, IndexType, NumDims, Layout >::IsColMajor = (Layout == ColMajor)

staticconstexprprivate

Referenced by Eigen::internal::TensorBlockIO< Scalar, IndexType, NumDims, Layout >::Copy(), and Eigen::internal::TensorBlockIO< Scalar, IndexType, NumDims, Layout >::NumSqueezableInnerDims().

---

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

• TensorBlock.h