#include <TensorConvolution.h>

Public Member Functions
	IndexMapper (const InputDims &input_dims, const array< Index, NumKernelDims > &kernel_dims, const array< Index, NumKernelDims > &indices)

EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC Index	mapGpuInputPlaneToTensorInputOffset (Index p) const

EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC Index	mapGpuOutputPlaneToTensorOutputOffset (Index p) const

EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC Index	mapGpuInputKernelToTensorInputOffset (Index i) const

EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC Index	mapGpuOutputKernelToTensorOutputOffset (Index i) const

EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC Index	mapGpuInputKernelToTensorInputOffset (Index i, Index j) const

EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC Index	mapGpuOutputKernelToTensorOutputOffset (Index i, Index j) const

EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC Index	mapGpuInputKernelToTensorInputOffset (Index i, Index j, Index k) const

EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC Index	mapGpuOutputKernelToTensorOutputOffset (Index i, Index j, Index k) const

Private Attributes
array< Index, NumDims >	m_inputStrides

array< Index, NumDims >	m_outputStrides

array< Index, NumDims >	m_gpuInputStrides

array< Index, NumDims >	m_gpuOutputStrides

Static Private Attributes
static constexpr int	NumDims = internal::array_size<InputDims>::value

Constructor & Destructor Documentation

◆ IndexMapper()

template<typename Index , typename InputDims , int NumKernelDims, int Layout>

Eigen::internal::IndexMapper< Index, InputDims, NumKernelDims, Layout >::IndexMapper	(	const InputDims &	input_dims,
		const array< Index, NumKernelDims > &	kernel_dims,
		const array< Index, NumKernelDims > &	indices
	)

inline

                                                           {
     array<Index, NumDims> dimensions = input_dims;
     for (int i = 0; i < NumKernelDims; ++i) {
       const Index index = indices[i];
       const Index input_dim = input_dims[index];
       const Index kernel_dim = kernel_dims[i];
       const Index result_dim = input_dim - kernel_dim + 1;
       dimensions[index] = result_dim;
     }
  
     array<Index, NumDims> inputStrides;
     array<Index, NumDims> outputStrides;
     if (static_cast<int>(Layout) == static_cast<int>(ColMajor)) {
       inputStrides[0] = 1;
       outputStrides[0] = 1;
       for (int i = 1; i < NumDims; ++i) {
         inputStrides[i] = inputStrides[i - 1] * input_dims[i - 1];
         outputStrides[i] = outputStrides[i - 1] * dimensions[i - 1];
       }
     } else {
       inputStrides[NumDims - 1] = 1;
       outputStrides[NumDims - 1] = 1;
       for (int i = static_cast<int>(NumDims) - 2; i >= 0; --i) {
         inputStrides[i] = inputStrides[i + 1] * input_dims[i + 1];
         outputStrides[i] = outputStrides[i + 1] * dimensions[i + 1];
       }
     }
  
     array<Index, NumDims> gpuInputDimensions;
     array<Index, NumDims> gpuOutputDimensions;
     array<Index, NumDims> tmp = dimensions;
     array<Index, NumDims> ordering;
     const size_t offset = static_cast<int>(Layout) == static_cast<int>(ColMajor) ? 0 : NumDims - NumKernelDims;
     for (int i = 0; i < NumKernelDims; ++i) {
       const Index index = i + offset;
       ordering[index] = indices[i];
       tmp[indices[i]] = -1;
       gpuInputDimensions[index] = input_dims[indices[i]];
       gpuOutputDimensions[index] = dimensions[indices[i]];
     }
  
     int written = static_cast<int>(Layout) == static_cast<int>(ColMajor) ? NumKernelDims : 0;
     for (int i = 0; i < NumDims; ++i) {
       if (tmp[i] >= 0) {
         ordering[written] = i;
         gpuInputDimensions[written] = input_dims[i];
         gpuOutputDimensions[written] = dimensions[i];
         ++written;
       }
     }
  
     for (int i = 0; i < NumDims; ++i) {
       m_inputStrides[i] = inputStrides[ordering[i]];
       m_outputStrides[i] = outputStrides[ordering[i]];
     }
  
     if (static_cast<int>(Layout) == static_cast<int>(ColMajor)) {
       for (int i = 0; i < NumDims; ++i) {
         if (i > NumKernelDims) {
           m_gpuInputStrides[i] = m_gpuInputStrides[i - 1] * gpuInputDimensions[i - 1];
           m_gpuOutputStrides[i] = m_gpuOutputStrides[i - 1] * gpuOutputDimensions[i - 1];
         } else {
           m_gpuInputStrides[i] = 1;
           m_gpuOutputStrides[i] = 1;
         }
       }
     } else {
       for (int i = NumDims - 1; i >= 0; --i) {
         if (static_cast<size_t>(i + 1) < offset) {
           m_gpuInputStrides[i] = m_gpuInputStrides[i + 1] * gpuInputDimensions[i + 1];
           m_gpuOutputStrides[i] = m_gpuOutputStrides[i + 1] * gpuOutputDimensions[i + 1];
         } else {
           m_gpuInputStrides[i] = 1;
           m_gpuOutputStrides[i] = 1;
         }
       }
     }
   }

References Eigen::ColMajor, i, Eigen::internal::IndexMapper< Index, InputDims, NumKernelDims, Layout >::m_gpuInputStrides, Eigen::internal::IndexMapper< Index, InputDims, NumKernelDims, Layout >::m_gpuOutputStrides, Eigen::internal::IndexMapper< Index, InputDims, NumKernelDims, Layout >::m_inputStrides, Eigen::internal::IndexMapper< Index, InputDims, NumKernelDims, Layout >::m_outputStrides, Eigen::internal::IndexMapper< Index, InputDims, NumKernelDims, Layout >::NumDims, and tmp.

Member Function Documentation

◆ mapGpuInputKernelToTensorInputOffset() [1/3]

template<typename Index , typename InputDims , int NumKernelDims, int Layout>

EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC Index Eigen::internal::IndexMapper< Index, InputDims, NumKernelDims, Layout >::mapGpuInputKernelToTensorInputOffset ( Index i ) const

inline

                                                                                                   {
     const size_t offset = static_cast<int>(Layout) == static_cast<int>(ColMajor) ? 0 : NumDims - NumKernelDims;
     return i * m_inputStrides[offset];
   }

References Eigen::ColMajor, i, Eigen::internal::IndexMapper< Index, InputDims, NumKernelDims, Layout >::m_inputStrides, and Eigen::internal::IndexMapper< Index, InputDims, NumKernelDims, Layout >::NumDims.

Referenced by Eigen::EigenConvolutionKernel< Evaluator, CoeffReturnType, KernelType, Index, InputDims, Kernel_accessor, Buffer_accessor, convolution_type::CONV1D >::operator()(), Eigen::EigenConvolutionKernel< Evaluator, CoeffReturnType, KernelType, Index, InputDims, Kernel_accessor, Buffer_accessor, convolution_type::CONV2D >::operator()(), and Eigen::EigenConvolutionKernel< Evaluator, CoeffReturnType, KernelType, Index, InputDims, Kernel_accessor, Buffer_accessor, convolution_type::CONV3D >::operator()().

◆ mapGpuInputKernelToTensorInputOffset() [2/3]

template<typename Index , typename InputDims , int NumKernelDims, int Layout>

EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC Index Eigen::internal::IndexMapper< Index, InputDims, NumKernelDims, Layout >::mapGpuInputKernelToTensorInputOffset	(	Index	i,
		Index	j
	)		const

inline

                                                                                                            {
     const size_t offset = static_cast<int>(Layout) == static_cast<int>(ColMajor) ? 0 : NumDims - NumKernelDims;
     return i * m_inputStrides[offset] + j * m_inputStrides[offset + 1];
   }

References Eigen::ColMajor, i, j, Eigen::internal::IndexMapper< Index, InputDims, NumKernelDims, Layout >::m_inputStrides, and Eigen::internal::IndexMapper< Index, InputDims, NumKernelDims, Layout >::NumDims.

◆ mapGpuInputKernelToTensorInputOffset() [3/3]

template<typename Index , typename InputDims , int NumKernelDims, int Layout>

EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC Index Eigen::internal::IndexMapper< Index, InputDims, NumKernelDims, Layout >::mapGpuInputKernelToTensorInputOffset	(	Index	i,
		Index	j,
		Index	k
	)		const

inline

                                                                                                                     {
     const size_t offset = static_cast<int>(Layout) == static_cast<int>(ColMajor) ? 0 : NumDims - NumKernelDims;
     return i * m_inputStrides[offset] + j * m_inputStrides[offset + 1] + k * m_inputStrides[offset + 2];
   }

References Eigen::ColMajor, i, j, k, Eigen::internal::IndexMapper< Index, InputDims, NumKernelDims, Layout >::m_inputStrides, and Eigen::internal::IndexMapper< Index, InputDims, NumKernelDims, Layout >::NumDims.

◆ mapGpuInputPlaneToTensorInputOffset()

template<typename Index , typename InputDims , int NumKernelDims, int Layout>

EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC Index Eigen::internal::IndexMapper< Index, InputDims, NumKernelDims, Layout >::mapGpuInputPlaneToTensorInputOffset ( Index p ) const

inline

                                                                                                  {
     Index inputIndex = 0;
     if (static_cast<int>(Layout) == static_cast<int>(ColMajor)) {
       for (int d = NumDims - 1; d > NumKernelDims; --d) {
         const Index idx = p / m_gpuInputStrides[d];
         inputIndex += idx * m_inputStrides[d];
         p -= idx * m_gpuInputStrides[d];
       }
       if (NumKernelDims < NumDims) {
         inputIndex += p * m_inputStrides[NumKernelDims];
       }
     } else {
       std::ptrdiff_t limit = 0;
       if (NumKernelDims < NumDims) {
         limit = NumDims - NumKernelDims - 1;
       }
       for (int d = 0; d < limit; ++d) {
         const Index idx = p / m_gpuInputStrides[d];
         inputIndex += idx * m_inputStrides[d];
         p -= idx * m_gpuInputStrides[d];
       }
       inputIndex += p * m_inputStrides[limit];
     }
     return inputIndex;
   }

References Eigen::ColMajor, Eigen::internal::IndexMapper< Index, InputDims, NumKernelDims, Layout >::m_gpuInputStrides, Eigen::internal::IndexMapper< Index, InputDims, NumKernelDims, Layout >::m_inputStrides, Eigen::internal::IndexMapper< Index, InputDims, NumKernelDims, Layout >::NumDims, and p.

Referenced by Eigen::EigenConvolutionKernel< Evaluator, CoeffReturnType, KernelType, Index, InputDims, Kernel_accessor, Buffer_accessor, convolution_type::CONV1D >::operator()(), Eigen::EigenConvolutionKernel< Evaluator, CoeffReturnType, KernelType, Index, InputDims, Kernel_accessor, Buffer_accessor, convolution_type::CONV2D >::operator()(), and Eigen::EigenConvolutionKernel< Evaluator, CoeffReturnType, KernelType, Index, InputDims, Kernel_accessor, Buffer_accessor, convolution_type::CONV3D >::operator()().

◆ mapGpuOutputKernelToTensorOutputOffset() [1/3]

template<typename Index , typename InputDims , int NumKernelDims, int Layout>

EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC Index Eigen::internal::IndexMapper< Index, InputDims, NumKernelDims, Layout >::mapGpuOutputKernelToTensorOutputOffset ( Index i ) const

inline

                                                                                                     {
     const size_t offset = static_cast<int>(Layout) == static_cast<int>(ColMajor) ? 0 : NumDims - NumKernelDims;
     return i * m_outputStrides[offset];
   }

References Eigen::ColMajor, i, Eigen::internal::IndexMapper< Index, InputDims, NumKernelDims, Layout >::m_outputStrides, and Eigen::internal::IndexMapper< Index, InputDims, NumKernelDims, Layout >::NumDims.

Referenced by Eigen::EigenConvolutionKernel< Evaluator, CoeffReturnType, KernelType, Index, InputDims, Kernel_accessor, Buffer_accessor, convolution_type::CONV1D >::operator()(), Eigen::EigenConvolutionKernel< Evaluator, CoeffReturnType, KernelType, Index, InputDims, Kernel_accessor, Buffer_accessor, convolution_type::CONV2D >::operator()(), and Eigen::EigenConvolutionKernel< Evaluator, CoeffReturnType, KernelType, Index, InputDims, Kernel_accessor, Buffer_accessor, convolution_type::CONV3D >::operator()().

◆ mapGpuOutputKernelToTensorOutputOffset() [2/3]

template<typename Index , typename InputDims , int NumKernelDims, int Layout>

EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC Index Eigen::internal::IndexMapper< Index, InputDims, NumKernelDims, Layout >::mapGpuOutputKernelToTensorOutputOffset	(	Index	i,
		Index	j
	)		const

inline

                                                                                                              {
     const size_t offset = static_cast<int>(Layout) == static_cast<int>(ColMajor) ? 0 : NumDims - NumKernelDims;
     return i * m_outputStrides[offset] + j * m_outputStrides[offset + 1];
   }

References Eigen::ColMajor, i, j, Eigen::internal::IndexMapper< Index, InputDims, NumKernelDims, Layout >::m_outputStrides, and Eigen::internal::IndexMapper< Index, InputDims, NumKernelDims, Layout >::NumDims.

◆ mapGpuOutputKernelToTensorOutputOffset() [3/3]

template<typename Index , typename InputDims , int NumKernelDims, int Layout>

EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC Index Eigen::internal::IndexMapper< Index, InputDims, NumKernelDims, Layout >::mapGpuOutputKernelToTensorOutputOffset	(	Index	i,
		Index	j,
		Index	k
	)		const

inline

                                                                                                                       {
     const size_t offset = static_cast<int>(Layout) == static_cast<int>(ColMajor) ? 0 : NumDims - NumKernelDims;
     return i * m_outputStrides[offset] + j * m_outputStrides[offset + 1] + k * m_outputStrides[offset + 2];
   }

References Eigen::ColMajor, i, j, k, Eigen::internal::IndexMapper< Index, InputDims, NumKernelDims, Layout >::m_outputStrides, and Eigen::internal::IndexMapper< Index, InputDims, NumKernelDims, Layout >::NumDims.

◆ mapGpuOutputPlaneToTensorOutputOffset()

template<typename Index , typename InputDims , int NumKernelDims, int Layout>

EIGEN_STRONG_INLINE EIGEN_DEVICE_FUNC Index Eigen::internal::IndexMapper< Index, InputDims, NumKernelDims, Layout >::mapGpuOutputPlaneToTensorOutputOffset ( Index p ) const

inline

                                                                                                    {
     Index outputIndex = 0;
     if (static_cast<int>(Layout) == static_cast<int>(ColMajor)) {
       for (int d = NumDims - 1; d > NumKernelDims; --d) {
         const Index idx = p / m_gpuOutputStrides[d];
         outputIndex += idx * m_outputStrides[d];
         p -= idx * m_gpuOutputStrides[d];
       }
       if (NumKernelDims < NumDims) {
         outputIndex += p * m_outputStrides[NumKernelDims];
       }
     } else {
       std::ptrdiff_t limit = 0;
       if (NumKernelDims < NumDims) {
         limit = NumDims - NumKernelDims - 1;
       }
       for (int d = 0; d < limit; ++d) {
         const Index idx = p / m_gpuOutputStrides[d];
         outputIndex += idx * m_outputStrides[d];
         p -= idx * m_gpuOutputStrides[d];
       }
       outputIndex += p * m_outputStrides[limit];
     }
     return outputIndex;
   }