From dd826edb42520814dab9239ec81f32ab91a4afe4 Mon Sep 17 00:00:00 2001 From: Rasmus Munk Larsen <4643818-rmlarsen1@users.noreply.gitlab.com> Date: Wed, 4 Mar 2026 08:59:22 -0800 Subject: [PATCH] Replace typedef with using in tensor contraction files libeigen/eigen!2247 Co-authored-by: Rasmus Munk Larsen --- .../Eigen/src/Tensor/TensorContraction.h | 210 +++++++++--------- .../src/Tensor/TensorContractionMapper.h | 44 ++-- .../src/Tensor/TensorContractionThreadPool.h | 76 +++---- 3 files changed, 160 insertions(+), 170 deletions(-) diff --git a/unsupported/Eigen/src/Tensor/TensorContraction.h b/unsupported/Eigen/src/Tensor/TensorContraction.h index fd1a21419..6768814b7 100644 --- a/unsupported/Eigen/src/Tensor/TensorContraction.h +++ b/unsupported/Eigen/src/Tensor/TensorContraction.h @@ -20,49 +20,49 @@ namespace internal { template struct traits> { // Type promotion to handle the case where the types of the lhs and the rhs are different. - typedef typename gebp_traits, - std::remove_const_t>::ResScalar Scalar; + using Scalar = typename gebp_traits, + std::remove_const_t>::ResScalar; - typedef typename promote_storage_type::StorageKind, - typename traits::StorageKind>::ret StorageKind; - typedef - typename promote_index_type::Index, typename traits::Index>::type Index; - typedef typename LhsXprType::Nested LhsNested; - typedef typename RhsXprType::Nested RhsNested; - typedef std::remove_reference_t LhsNested_; - typedef std::remove_reference_t RhsNested_; + using StorageKind = typename promote_storage_type::StorageKind, + typename traits::StorageKind>::ret; + using Index = + typename promote_index_type::Index, typename traits::Index>::type; + using LhsNested = typename LhsXprType::Nested; + using RhsNested = typename RhsXprType::Nested; + using LhsNested_ = std::remove_reference_t; + using RhsNested_ = std::remove_reference_t; // From NumDims below. static constexpr int NumDimensions = traits::NumDimensions + traits::NumDimensions - 2 * array_size::value; static constexpr int Layout = traits::Layout; - typedef std::conditional_t::val, - typename traits::PointerType, typename traits::PointerType> - PointerType; + using PointerType = + std::conditional_t::val, + typename traits::PointerType, typename traits::PointerType>; enum { Flags = 0 }; }; template struct eval, Eigen::Dense> { - typedef const TensorContractionOp& type; + using type = const TensorContractionOp&; }; template struct nested, 1, typename eval>::type> { - typedef TensorContractionOp type; + using type = TensorContractionOp; }; template struct traits< TensorEvaluator, Device_>> { - typedef Indices_ Indices; - typedef LeftArgType_ LeftArgType; - typedef RightArgType_ RightArgType; - typedef OutputKernelType_ OutputKernelType; - typedef Device_ Device; + using Indices = Indices_; + using LeftArgType = LeftArgType_; + using RightArgType = RightArgType_; + using OutputKernelType = OutputKernelType_; + using Device = Device_; // From NumDims below. static constexpr int NumDimensions = @@ -72,7 +72,7 @@ struct traits< // Helper class to allocate and deallocate temporary memory for packed buffers. template struct TensorContractionBlockMemAllocator { - typedef void* BlockMemHandle; + using BlockMemHandle = void*; template EIGEN_DEVICE_FUNC static BlockMemHandle allocate(Device& d, const Index bm, const Index bk, const Index bn, @@ -175,25 +175,23 @@ struct TensorContractionKernel { : m(m_), k(k_), n(n_), bm(bm_), bk(bk_), bn(bn_) {} // Pack blocks of Lhs and Rhs into contiguous blocks in memory. - typedef LhsScalar* LhsBlock; - typedef RhsScalar* RhsBlock; + using LhsBlock = LhsScalar*; + using RhsBlock = RhsScalar*; // Packed Lhs/Rhs block memory allocator. - typedef TensorContractionBlockMemAllocator BlockMemAllocator; - typedef typename BlockMemAllocator::BlockMemHandle BlockMemHandle; + using BlockMemAllocator = TensorContractionBlockMemAllocator; + using BlockMemHandle = typename BlockMemAllocator::BlockMemHandle; - typedef typename internal::gebp_traits Traits; + using Traits = typename internal::gebp_traits; - typedef internal::gemm_pack_lhs - LhsPacker; + using LhsPacker = internal::gemm_pack_lhs; - typedef internal::gemm_pack_rhs - RhsPacker; + using RhsPacker = + internal::gemm_pack_rhs; - typedef internal::gebp_kernel - GebpKernel; + using GebpKernel = internal::gebp_kernel; template EIGEN_DEVICE_FUNC BlockMemHandle allocate(Device& d, LhsBlock* lhs_block, RhsBlock* rhs_block) { @@ -303,12 +301,12 @@ template , ReadOnlyAccessors> { public: - typedef typename Eigen::internal::traits::Scalar Scalar; - typedef typename internal::gebp_traits::ResScalar CoeffReturnType; - typedef typename Eigen::internal::nested::type Nested; - typedef typename Eigen::internal::traits::StorageKind StorageKind; - typedef typename Eigen::internal::traits::Index Index; + using Scalar = typename Eigen::internal::traits::Scalar; + using CoeffReturnType = typename internal::gebp_traits::ResScalar; + using Nested = typename Eigen::internal::nested::type; + using StorageKind = typename Eigen::internal::traits::StorageKind; + using Index = typename Eigen::internal::traits::Index; EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE TensorContractionOp(const LhsXprType& lhs, const RhsXprType& rhs, const Indices& dims, @@ -337,19 +335,19 @@ class TensorContractionOp template struct TensorContractionEvaluatorBase { - typedef typename internal::traits::Indices Indices; - typedef typename internal::traits::LeftArgType LeftArgType; - typedef typename internal::traits::RightArgType RightArgType; - typedef typename internal::traits::OutputKernelType OutputKernelType; - typedef typename internal::traits::Device Device; + using Indices = typename internal::traits::Indices; + using LeftArgType = typename internal::traits::LeftArgType; + using RightArgType = typename internal::traits::RightArgType; + using OutputKernelType = typename internal::traits::OutputKernelType; + using Device = typename internal::traits::Device; - typedef TensorContractionOp XprType; - typedef std::remove_const_t Scalar; - typedef typename XprType::Index Index; - typedef typename XprType::CoeffReturnType CoeffReturnType; - typedef typename PacketType::type PacketReturnType; - typedef StorageMemory Storage; - typedef typename Storage::Type EvaluatorPointerType; + using XprType = TensorContractionOp; + using Scalar = std::remove_const_t; + using Index = typename XprType::Index; + using CoeffReturnType = typename XprType::CoeffReturnType; + using PacketReturnType = typename PacketType::type; + using Storage = StorageMemory; + using EvaluatorPointerType = typename Storage::Type; static constexpr int Layout = TensorEvaluator::Layout; enum { @@ -362,20 +360,20 @@ struct TensorContractionEvaluatorBase { }; //===- Tensor block evaluation strategy (see TensorBlock.h) -------------===// - typedef internal::TensorBlockNotImplemented TensorBlock; + using TensorBlock = internal::TensorBlockNotImplemented; //===--------------------------------------------------------------------===// // Most of the code is assuming that both input tensors are ColMajor. If the // inputs are RowMajor, we will "cheat" by swapping the LHS and RHS: // If we want to compute A * B = C, where A is LHS and B is RHS, the code // will pretend B is LHS and A is RHS. - typedef std::conditional_t(Layout) == static_cast(ColMajor), LeftArgType, RightArgType> - EvalLeftArgType; - typedef std::conditional_t(Layout) == static_cast(ColMajor), RightArgType, LeftArgType> - EvalRightArgType; + using EvalLeftArgType = + std::conditional_t(Layout) == static_cast(ColMajor), LeftArgType, RightArgType>; + using EvalRightArgType = + std::conditional_t(Layout) == static_cast(ColMajor), RightArgType, LeftArgType>; - typedef TensorEvaluator LeftEvaluatorType; - typedef TensorEvaluator RightEvaluatorType; + using LeftEvaluatorType = TensorEvaluator; + using RightEvaluatorType = TensorEvaluator; static constexpr int LDims = internal::array_size::Dimensions>::value; @@ -384,11 +382,11 @@ struct TensorContractionEvaluatorBase { static constexpr int ContractDims = internal::array_size::value; static constexpr int NumDims = LDims + RDims - 2 * ContractDims; - typedef array contract_t; - typedef array left_nocontract_t; - typedef array right_nocontract_t; + using contract_t = array; + using left_nocontract_t = array; + using right_nocontract_t = array; - typedef DSizes Dimensions; + using Dimensions = DSizes; EIGEN_STRONG_INLINE TensorContractionEvaluatorBase(const XprType& op, const Device& device) : m_leftImpl(choose(Cond(Layout) == static_cast(ColMajor)>(), op.lhsExpression(), @@ -697,23 +695,22 @@ struct TensorContractionEvaluatorBase { const Index rows = m_i_size; const Index cols = m_k_size; - typedef std::remove_const_t LhsScalar; - typedef std::remove_const_t RhsScalar; - typedef TensorEvaluator LeftEvaluator; - typedef TensorEvaluator RightEvaluator; + using LhsScalar = std::remove_const_t; + using RhsScalar = std::remove_const_t; + using LeftEvaluator = TensorEvaluator; + using RightEvaluator = TensorEvaluator; const int lhs_packet_size = internal::unpacket_traits::size; const int rhs_packet_size = internal::unpacket_traits::size; const int lhs_alignment = LeftEvaluator::IsAligned ? Aligned : Unaligned; const int rhs_alignment = RightEvaluator::IsAligned ? Aligned : Unaligned; - typedef internal::TensorContractionInputMapper - LhsMapper; + using LhsMapper = internal::TensorContractionInputMapper; - typedef internal::TensorContractionInputMapper - RhsMapper; + using RhsMapper = + internal::TensorContractionInputMapper; LhsMapper lhs(m_leftImpl, m_left_nocontract_strides, m_i_strides, m_left_contracting_strides, m_k_strides); RhsMapper rhs(m_rightImpl, m_right_nocontract_strides, m_j_strides, m_right_contracting_strides, m_k_strides); @@ -727,7 +724,7 @@ struct TensorContractionEvaluatorBase { internal::general_matrix_vector_product::run(rows, cols, lhs, rhs, buffer, resIncr, alpha); - typedef internal::blas_data_mapper OutputMapper; + using OutputMapper = internal::blas_data_mapper; m_output_kernel(OutputMapper(buffer, rows), m_tensor_contraction_params, static_cast(0), static_cast(0), rows, static_cast(1)); } @@ -765,29 +762,28 @@ struct TensorContractionEvaluatorBase { const Index n = this->m_j_size; // define data mappers for Lhs and Rhs - typedef std::remove_const_t LhsScalar; - typedef std::remove_const_t RhsScalar; + using LhsScalar = std::remove_const_t; + using RhsScalar = std::remove_const_t; - typedef TensorEvaluator LeftEvaluator; - typedef TensorEvaluator RightEvaluator; + using LeftEvaluator = TensorEvaluator; + using RightEvaluator = TensorEvaluator; const int lhs_packet_size = internal::unpacket_traits::size; const int rhs_packet_size = internal::unpacket_traits::size; - typedef internal::TensorContractionInputMapper - LhsMapper; + using LhsMapper = + internal::TensorContractionInputMapper; - typedef internal::TensorContractionInputMapper - RhsMapper; + using RhsMapper = + internal::TensorContractionInputMapper; - typedef internal::blas_data_mapper OutputMapper; + using OutputMapper = internal::blas_data_mapper; - typedef internal::TensorContractionKernel - TensorContractionKernel; + using TensorContractionKernel = + internal::TensorContractionKernel; // initialize data mappers LhsMapper lhs(this->m_leftImpl, this->m_left_nocontract_strides, this->m_i_strides, @@ -805,15 +801,15 @@ struct TensorContractionEvaluatorBase { const Index mc = numext::mini(m, blocking.mc()); const Index nc = numext::mini(n, blocking.nc()); - typedef typename TensorContractionKernel::LhsBlock LhsBlock; - typedef typename TensorContractionKernel::RhsBlock RhsBlock; + using LhsBlock = typename TensorContractionKernel::LhsBlock; + using RhsBlock = typename TensorContractionKernel::RhsBlock; LhsBlock blockA; RhsBlock blockB; TensorContractionKernel kernel(m, k_slice, n, mc, kc, nc); - typedef typename TensorContractionKernel::BlockMemHandle BlockMemHandle; + using BlockMemHandle = typename TensorContractionKernel::BlockMemHandle; const BlockMemHandle packed_mem = kernel.allocate(this->m_device, &blockA, &blockB); // If a contraction kernel does not support beta, explicitly initialize @@ -913,14 +909,14 @@ template , Device> : public TensorContractionEvaluatorBase< TensorEvaluator, Device>> { - typedef TensorEvaluator, Device> Self; - typedef TensorContractionEvaluatorBase Base; + using Self = TensorEvaluator, Device>; + using Base = TensorContractionEvaluatorBase; - typedef TensorContractionOp XprType; - typedef std::remove_const_t Scalar; - typedef typename XprType::Index Index; - typedef typename XprType::CoeffReturnType CoeffReturnType; - typedef typename PacketType::type PacketReturnType; + using XprType = TensorContractionOp; + using Scalar = std::remove_const_t; + using Index = typename XprType::Index; + using CoeffReturnType = typename XprType::CoeffReturnType; + using PacketReturnType = typename PacketType::type; static constexpr int Layout = TensorEvaluator::Layout; @@ -928,8 +924,8 @@ struct TensorEvaluator(ColMajor), LeftArgType, RightArgType> EvalLeftArgType; - typedef std::conditional_t(ColMajor), RightArgType, LeftArgType> EvalRightArgType; + using EvalLeftArgType = std::conditional_t(ColMajor), LeftArgType, RightArgType>; + using EvalRightArgType = std::conditional_t(ColMajor), RightArgType, LeftArgType>; static constexpr int LDims = internal::array_size::Dimensions>::value; @@ -937,14 +933,14 @@ struct TensorEvaluator::Dimensions>::value; static constexpr int ContractDims = internal::array_size::value; - typedef array contract_t; - typedef array left_nocontract_t; - typedef array right_nocontract_t; + using contract_t = array; + using left_nocontract_t = array; + using right_nocontract_t = array; static constexpr int NumDims = LDims + RDims - 2 * ContractDims; // Could we use NumDimensions here? - typedef DSizes Dimensions; + using Dimensions = DSizes; TensorEvaluator(const XprType& op, const Device& device) : Base(op, device) {} diff --git a/unsupported/Eigen/src/Tensor/TensorContractionMapper.h b/unsupported/Eigen/src/Tensor/TensorContractionMapper.h index 83fec99af..2fc2102ce 100644 --- a/unsupported/Eigen/src/Tensor/TensorContractionMapper.h +++ b/unsupported/Eigen/src/Tensor/TensorContractionMapper.h @@ -82,7 +82,7 @@ struct CoeffLoader { } private: - typedef typename Tensor::Scalar Scalar; + using Scalar = typename Tensor::Scalar; typename MakePointer_::Type m_data; }; @@ -243,9 +243,8 @@ class BaseTensorContractionMapper : public SimpleTensorContractionMapper { public: - typedef SimpleTensorContractionMapper - ParentMapper; + using ParentMapper = SimpleTensorContractionMapper; EIGEN_DEVICE_FUNC BaseTensorContractionMapper(const Tensor& tensor, const nocontract_t& nocontract_strides, const nocontract_t& ij_strides, const contract_t& contract_strides, @@ -330,9 +329,8 @@ class BaseTensorContractionMapper { public: - typedef SimpleTensorContractionMapper - ParentMapper; + using ParentMapper = SimpleTensorContractionMapper; EIGEN_DEVICE_FUNC BaseTensorContractionMapper(const Tensor& tensor, const nocontract_t& nocontract_strides, const nocontract_t& ij_strides, const contract_t& contract_strides, @@ -358,14 +356,12 @@ template class MakePointer_ = MakePointer> class TensorContractionSubMapper { public: - typedef BaseTensorContractionMapper - ParentMapper; - typedef TensorContractionSubMapper - Self; - typedef Self LinearMapper; - typedef Self SubMapper; + using ParentMapper = BaseTensorContractionMapper; + using Self = TensorContractionSubMapper; + using LinearMapper = Self; + using SubMapper = Self; enum { // We can use direct offsets iff the parent mapper supports then and we can compute the strides. @@ -485,15 +481,13 @@ class TensorContractionInputMapper : public BaseTensorContractionMapper { public: - typedef Scalar_ Scalar; - typedef BaseTensorContractionMapper - Base; - typedef TensorContractionSubMapper - SubMapper; - typedef SubMapper VectorMapper; - typedef SubMapper LinearMapper; + using Scalar = Scalar_; + using Base = BaseTensorContractionMapper; + using SubMapper = TensorContractionSubMapper; + using VectorMapper = SubMapper; + using LinearMapper = SubMapper; EIGEN_DEVICE_FUNC TensorContractionInputMapper(const Tensor& tensor, const nocontract_t& nocontract_strides, const nocontract_t& ij_strides, const contract_t& contract_strides, @@ -526,7 +520,7 @@ template > { - typedef Tensor_ XprType; + using XprType = Tensor_; static const bool inner_dim_contiguous = inner_dim_contiguous_; static const bool inner_dim_reordered = inner_dim_reordered_; }; diff --git a/unsupported/Eigen/src/Tensor/TensorContractionThreadPool.h b/unsupported/Eigen/src/Tensor/TensorContractionThreadPool.h index 6a6cc35a5..5dd5d6036 100644 --- a/unsupported/Eigen/src/Tensor/TensorContractionThreadPool.h +++ b/unsupported/Eigen/src/Tensor/TensorContractionThreadPool.h @@ -23,16 +23,16 @@ struct TensorEvaluator : public TensorContractionEvaluatorBase, ThreadPoolDevice>> { - typedef ThreadPoolDevice Device; + using Device = ThreadPoolDevice; - typedef TensorEvaluator, Device> Self; - typedef TensorContractionEvaluatorBase Base; + using Self = TensorEvaluator, Device>; + using Base = TensorContractionEvaluatorBase; - typedef TensorContractionOp XprType; - typedef std::remove_const_t Scalar; - typedef typename XprType::Index Index; - typedef typename XprType::CoeffReturnType CoeffReturnType; - typedef typename PacketType::type PacketReturnType; + using XprType = TensorContractionOp; + using Scalar = std::remove_const_t; + using Index = typename XprType::Index; + using CoeffReturnType = typename XprType::CoeffReturnType; + using PacketReturnType = typename PacketType::type; static constexpr int Layout = TensorEvaluator::Layout; @@ -40,10 +40,10 @@ struct TensorEvaluator(Layout) == static_cast(ColMajor), LeftArgType, RightArgType> - EvalLeftArgType; - typedef std::conditional_t(Layout) == static_cast(ColMajor), RightArgType, LeftArgType> - EvalRightArgType; + using EvalLeftArgType = + std::conditional_t(Layout) == static_cast(ColMajor), LeftArgType, RightArgType>; + using EvalRightArgType = + std::conditional_t(Layout) == static_cast(ColMajor), RightArgType, LeftArgType>; static constexpr int LDims = internal::array_size::Dimensions>::value; @@ -51,24 +51,24 @@ struct TensorEvaluator::Dimensions>::value; static constexpr int ContractDims = internal::array_size::value; - typedef array left_dim_mapper_t; - typedef array right_dim_mapper_t; + using left_dim_mapper_t = array; + using right_dim_mapper_t = array; - typedef array contract_t; - typedef array left_nocontract_t; - typedef array right_nocontract_t; + using contract_t = array; + using left_nocontract_t = array; + using right_nocontract_t = array; static constexpr int NumDims = LDims + RDims - 2 * ContractDims; - typedef DSizes Dimensions; + using Dimensions = DSizes; // typedefs needed in evalTo - typedef std::remove_const_t LhsScalar; - typedef std::remove_const_t RhsScalar; - typedef typename internal::gebp_traits Traits; + using LhsScalar = std::remove_const_t; + using RhsScalar = std::remove_const_t; + using Traits = typename internal::gebp_traits; - typedef TensorEvaluator LeftEvaluator; - typedef TensorEvaluator RightEvaluator; + using LeftEvaluator = TensorEvaluator; + using RightEvaluator = TensorEvaluator; TensorEvaluator(const XprType& op, const Device& device) : Base(op, device) {} @@ -335,23 +335,23 @@ struct TensorEvaluator class EvalParallelContext { public: - typedef internal::TensorContractionInputMapper::size, - lhs_inner_dim_contiguous, false, Unaligned> - LhsMapper; - typedef internal::TensorContractionInputMapper::size, - rhs_inner_dim_contiguous, rhs_inner_dim_reordered, Unaligned> - RhsMapper; + using LhsMapper = + internal::TensorContractionInputMapper::size, + lhs_inner_dim_contiguous, false, Unaligned>; + using RhsMapper = + internal::TensorContractionInputMapper::size, + rhs_inner_dim_contiguous, rhs_inner_dim_reordered, Unaligned>; - typedef internal::blas_data_mapper OutputMapper; + using OutputMapper = internal::blas_data_mapper; - typedef internal::TensorContractionKernel - TensorContractionKernel; + using TensorContractionKernel = + internal::TensorContractionKernel; - typedef typename TensorContractionKernel::LhsBlock LhsBlock; - typedef typename TensorContractionKernel::RhsBlock RhsBlock; - typedef typename TensorContractionKernel::BlockMemHandle BlockMemHandle; + using LhsBlock = typename TensorContractionKernel::LhsBlock; + using RhsBlock = typename TensorContractionKernel::RhsBlock; + using BlockMemHandle = typename TensorContractionKernel::BlockMemHandle; EvalParallelContext(const Self* self, int num_threads, Scalar* buffer, Index tm, Index tn, Index tk, Index bm, Index bn, Index bk, Index nm, Index nn, Index nk, Index gm, Index gn, Index nm0, Index nn0, @@ -1195,7 +1195,7 @@ struct TensorEvaluator OutputMapper; + using OutputMapper = internal::blas_data_mapper; evaluator->m_output_kernel(OutputMapper(result, m), evaluator->m_tensor_contraction_params, static_cast(0), static_cast(0), m, n); }