Eigen::internal::TensorBlockResourceRequirements Struct Reference

#include <TensorBlock.h>

Public Member Functions
EIGEN_DEVICE_FUNC TensorBlockResourceRequirements &	addCostPerCoeff (TensorOpCost cost)

Static Public Member Functions
template<typename Scalar >
static EIGEN_DEVICE_FUNC TensorBlockResourceRequirements	withShapeAndSize (TensorBlockShapeType shape_type, size_t size_in_bytes, TensorOpCost cost)
template<typename Scalar >
static EIGEN_DEVICE_FUNC TensorBlockResourceRequirements	withShapeAndSize (TensorBlockShapeType shape_type, size_t size_in_bytes)
template<typename Scalar >
static EIGEN_DEVICE_FUNC TensorBlockResourceRequirements	skewed (size_t size_in_bytes)
template<typename Scalar >
static EIGEN_DEVICE_FUNC TensorBlockResourceRequirements	uniform (size_t size_in_bytes)
static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorBlockResourceRequirements	merge (const TensorBlockResourceRequirements &lhs, const TensorBlockResourceRequirements &rhs)
static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorBlockResourceRequirements	any ()

Public Attributes
TensorBlockShapeType	shape_type
size_t	size
TensorOpCost	cost_per_coeff

Private Types
using	Requirements = TensorBlockResourceRequirements

Static Private Member Functions
static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE size_t	merge (size_t lhs_size, size_t rhs_size)
static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorBlockShapeType	merge (TensorBlockShapeType lhs, TensorBlockShapeType rhs)
static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorOpCost	merge (TensorOpCost lhs_cost, TensorOpCost rhs_cost)

Member Typedef Documentation

Requirements

using Eigen::internal::TensorBlockResourceRequirements::Requirements = TensorBlockResourceRequirements

private

Member Function Documentation

addCostPerCoeff()

EIGEN_DEVICE_FUNC TensorBlockResourceRequirements& Eigen::internal::TensorBlockResourceRequirements::addCostPerCoeff ( TensorOpCost  cost )

inline

                                                                                        {
    cost_per_coeff += cost;
    return *this;
  }

References cost_per_coeff.

Referenced by Eigen::TensorEvaluator< const TensorCwiseBinaryOp< BinaryOp, LeftArgType, RightArgType >, Device >::getResourceRequirements(), and Eigen::TensorEvaluator< const TensorShufflingOp< Shuffle, ArgType >, Device >::getResourceRequirements().

any()

static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorBlockResourceRequirements Eigen::internal::TensorBlockResourceRequirements::any ( )

inlinestatic

                                                                                     {
    return {TensorBlockShapeType::kUniformAllDims, 1, {0, 0, 0}};
  }

References Eigen::internal::kUniformAllDims.

Referenced by Eigen::TensorEvaluator< Derived, Device >::getResourceRequirements(), Eigen::TensorEvaluator< const Derived, Device >::getResourceRequirements(), Eigen::TensorEvaluator< const TensorForcedEvalOp< ArgType_ >, Device >::getResourceRequirements(), and Eigen::TensorEvaluator< const TensorReshapingOp< NewDimensions, ArgType >, Device >::getResourceRequirements().

merge() [1/4]

static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorBlockResourceRequirements Eigen::internal::TensorBlockResourceRequirements::merge ( const TensorBlockResourceRequirements &  lhs, const TensorBlockResourceRequirements &  rhs  )

inlinestatic

                                                                                                {
    return {merge(lhs.shape_type, rhs.shape_type),           // shape_type
            merge(lhs.size, rhs.size),                       // size
            merge(lhs.cost_per_coeff, rhs.cost_per_coeff)};  // cost_per_coeff
  }

References cost_per_coeff, shape_type, and size.

Referenced by Eigen::TensorEvaluator< const TensorAssignOp< LeftArgType, RightArgType >, Device >::getResourceRequirements(), Eigen::TensorEvaluator< const TensorBroadcastingOp< Broadcast, ArgType >, Device >::getResourceRequirements(), Eigen::TensorEvaluator< const TensorChippingOp< DimId, ArgType >, Device >::getResourceRequirements(), Eigen::TensorEvaluator< const TensorCwiseBinaryOp< BinaryOp, LeftArgType, RightArgType >, Device >::getResourceRequirements(), Eigen::TensorEvaluator< const TensorSelectOp< IfArgType, ThenArgType, ElseArgType >, Device >::getResourceRequirements(), Eigen::TensorEvaluator< const TensorSlicingOp< StartIndices, Sizes, ArgType >, Device >::getResourceRequirements(), and Eigen::TensorEvaluator< const TensorPaddingOp< PaddingDimensions, ArgType >, Device >::getResourceRequirements().

merge() [2/4]

static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE size_t Eigen::internal::TensorBlockResourceRequirements::merge ( size_t  lhs_size, size_t  rhs_size  )

inlinestaticprivate

                                                                                              {
    return numext::maxi(lhs_size, rhs_size);
  }

References Eigen::numext::maxi().

merge() [3/4]

static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorBlockShapeType Eigen::internal::TensorBlockResourceRequirements::merge ( TensorBlockShapeType  lhs, TensorBlockShapeType  rhs  )

inlinestaticprivate

                                                                                                    {
    return (lhs == TensorBlockShapeType::kSkewedInnerDims || rhs == TensorBlockShapeType::kSkewedInnerDims)
               ? TensorBlockShapeType::kSkewedInnerDims
               : TensorBlockShapeType::kUniformAllDims;
  }

References Eigen::internal::kSkewedInnerDims, and Eigen::internal::kUniformAllDims.

merge() [4/4]

static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorOpCost Eigen::internal::TensorBlockResourceRequirements::merge ( TensorOpCost  lhs_cost, TensorOpCost  rhs_cost  )

inlinestaticprivate

                                                                                                                {
    return lhs_cost + rhs_cost;
  }

skewed()

template<typename Scalar >

static EIGEN_DEVICE_FUNC TensorBlockResourceRequirements Eigen::internal::TensorBlockResourceRequirements::skewed ( size_t  size_in_bytes )

inlinestatic

                                                                                        {
    return withShapeAndSize<Scalar>(TensorBlockShapeType::kSkewedInnerDims, size_in_bytes);
  }

References Eigen::internal::kSkewedInnerDims.

uniform()

template<typename Scalar >

static EIGEN_DEVICE_FUNC TensorBlockResourceRequirements Eigen::internal::TensorBlockResourceRequirements::uniform ( size_t  size_in_bytes )

inlinestatic

                                                                                         {
    return withShapeAndSize<Scalar>(TensorBlockShapeType::kUniformAllDims, size_in_bytes);
  }

References Eigen::internal::kUniformAllDims.

withShapeAndSize() [1/2]

template<typename Scalar >

static EIGEN_DEVICE_FUNC TensorBlockResourceRequirements Eigen::internal::TensorBlockResourceRequirements::withShapeAndSize ( TensorBlockShapeType  shape_type, size_t  size_in_bytes  )

inlinestatic

                                                                                                  {
    // This default cost per coefficient is valid for most materialized tensor
    // block evaluation implementations, because they typically just read
    // coefficients from the underlying tensor storage, and write to the tensor
    // block buffer (scratch or destination memory, reads and writes have linear
    // access pattern). We ignore the fixed cost of block evaluation, because in
    // practice it should negligible.
    //
    // Lazy block evaluation adds the cost of calling a functor for each
    // coefficient.
    //
    // All non-trivial block evaluation implementations must provide their own
    // cost approximation (e.g. shuffling inner dimension has a much higher cost
    // because it reads memory randomly, although the total number of moved
    // bytes is the same).
    return withShapeAndSize<Scalar>(shape_type, size_in_bytes,
                                    {/*bytes_loaded=*/sizeof(Scalar),
                                     /*bytes_stored=*/sizeof(Scalar),
                                     /*compute_cycles=*/0});
  }

References shape_type.

withShapeAndSize() [2/2]

template<typename Scalar >

static EIGEN_DEVICE_FUNC TensorBlockResourceRequirements Eigen::internal::TensorBlockResourceRequirements::withShapeAndSize ( TensorBlockShapeType  shape_type, size_t  size_in_bytes, TensorOpCost  cost  )

inlinestatic

                                                                                                                     {
    const size_t size = numext::maxi(size_t(1), size_in_bytes / sizeof(Scalar));
    return {shape_type, size, cost};
  }

References Eigen::numext::maxi(), shape_type, and size.

Member Data Documentation

cost_per_coeff

TensorOpCost Eigen::internal::TensorBlockResourceRequirements::cost_per_coeff

Referenced by addCostPerCoeff(), and merge().

shape_type

TensorBlockShapeType Eigen::internal::TensorBlockResourceRequirements::shape_type

Referenced by Eigen::internal::TensorBlockMapper< NumDims, Layout, IndexType >::InitializeBlockDimensions(), merge(), and withShapeAndSize().

size

size_t Eigen::internal::TensorBlockResourceRequirements::size

Referenced by Eigen::internal::TensorBlockMapper< NumDims, Layout, IndexType >::InitializeBlockDimensions(), merge(), and withShapeAndSize().

---

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

• TensorBlock.h