Eigen::CoreThreadPoolDevice Struct Reference

#include <CoreThreadPoolDevice.h>

Public Types
using	Task = std::function< void()>

Public Member Functions
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE	CoreThreadPoolDevice (ThreadPool &pool, float threadCostThreshold=3e-5f)
template<int PacketSize>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE int	calculateLevels (Index size, float cost) const
template<typename UnaryFunctor , int PacketSize>
EIGEN_DEVICE_FUNC EIGEN_PARALLEL_FOR_INLINE void	parallelForImpl (Index begin, Index end, UnaryFunctor &f, Barrier &barrier, int level)
template<typename BinaryFunctor , int PacketSize>
EIGEN_DEVICE_FUNC EIGEN_PARALLEL_FOR_INLINE void	parallelForImpl (Index outerBegin, Index outerEnd, Index innerBegin, Index innerEnd, BinaryFunctor &f, Barrier &barrier, int level)
template<typename UnaryFunctor , int PacketSize>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void	parallelFor (Index begin, Index end, UnaryFunctor &f, float cost)
template<typename BinaryFunctor , int PacketSize>
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void	parallelFor (Index outerBegin, Index outerEnd, Index innerBegin, Index innerEnd, BinaryFunctor &f, float cost)

Public Attributes
ThreadPool &	m_pool
float	m_costFactor

Member Typedef Documentation

Task

using Eigen::CoreThreadPoolDevice::Task = std::function<void()>

Constructor & Destructor Documentation

CoreThreadPoolDevice()

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Eigen::CoreThreadPoolDevice::CoreThreadPoolDevice ( ThreadPool &  pool, float  threadCostThreshold = 3e-5f  )

inline

      : m_pool(pool) {
    eigen_assert(threadCostThreshold >= 0.0f && "threadCostThreshold must be non-negative");
    m_costFactor = threadCostThreshold;
  }

References eigen_assert, and m_costFactor.

Member Function Documentation

calculateLevels()

template<int PacketSize>

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE int Eigen::CoreThreadPoolDevice::calculateLevels ( Index  size, float  cost  ) const

inline

                                                                                          {
    eigen_assert(cost >= 0.0f && "cost must be non-negative");
    Index numOps = size / PacketSize;
    int actualThreads = numOps < m_pool.NumThreads() ? static_cast<int>(numOps) : m_pool.NumThreads();
    float totalCost = static_cast<float>(numOps) * cost;
    float idealThreads = totalCost * m_costFactor;
    if (idealThreads < static_cast<float>(actualThreads)) {
      idealThreads = numext::maxi(idealThreads, 1.0f);
      actualThreads = numext::mini(actualThreads, static_cast<int>(idealThreads));
    }
    int maxLevel = internal::log2_ceil(actualThreads);
    return maxLevel;
  }

References eigen_assert, Eigen::internal::log2_ceil(), m_costFactor, m_pool, Eigen::numext::maxi(), Eigen::numext::mini(), Eigen::ThreadPoolTempl< Environment >::NumThreads(), and size.

parallelFor() [1/2]

template<typename UnaryFunctor , int PacketSize>

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void Eigen::CoreThreadPoolDevice::parallelFor ( Index  begin, Index  end, UnaryFunctor &  f, float  cost  )

inline

                                                                                                              {
    Index size = end - begin;
    int maxLevel = calculateLevels<PacketSize>(size, cost);
    Barrier barrier(1 << maxLevel);
    parallelForImpl<UnaryFunctor, PacketSize>(begin, end, f, barrier, maxLevel);
    barrier.Wait();
  }

References Eigen::placeholders::end, f(), size, and Eigen::Barrier::Wait().

parallelFor() [2/2]

template<typename BinaryFunctor , int PacketSize>

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void Eigen::CoreThreadPoolDevice::parallelFor ( Index  outerBegin, Index  outerEnd, Index  innerBegin, Index  innerEnd, BinaryFunctor &  f, float  cost  )

inline

                                                                                                       {
    Index outerSize = outerEnd - outerBegin;
    Index innerSize = innerEnd - innerBegin;
    Index size = outerSize * innerSize;
    int maxLevel = calculateLevels<PacketSize>(size, cost);
    Barrier barrier(1 << maxLevel);
    parallelForImpl<BinaryFunctor, PacketSize>(outerBegin, outerEnd, innerBegin, innerEnd, f, barrier, maxLevel);
    barrier.Wait();
  }

References f(), size, and Eigen::Barrier::Wait().

parallelForImpl() [1/2]

template<typename UnaryFunctor , int PacketSize>

EIGEN_DEVICE_FUNC EIGEN_PARALLEL_FOR_INLINE void Eigen::CoreThreadPoolDevice::parallelForImpl ( Index  begin, Index  end, UnaryFunctor &  f, Barrier &  barrier, int  level  )

inline

                                                                                                {
    while (level > 0) {
      level--;
      Index size = end - begin;
      eigen_assert(size % PacketSize == 0 && "this function assumes size is a multiple of PacketSize");
      Index mid = begin + numext::round_down(size >> 1, PacketSize);
      Task right = [this, mid, end, &f, &barrier, level]() {
        parallelForImpl<UnaryFunctor, PacketSize>(mid, end, f, barrier, level);
      };
      m_pool.Schedule(std::move(right));
      end = mid;
    }
    for (Index i = begin; i < end; i += PacketSize) f(i);
    barrier.Notify();
  }

References eigen_assert, Eigen::placeholders::end, f(), i, m_pool, Eigen::Barrier::Notify(), Eigen::numext::round_down(), Eigen::ThreadPoolTempl< Environment >::Schedule(), and size.

parallelForImpl() [2/2]

template<typename BinaryFunctor , int PacketSize>

EIGEN_DEVICE_FUNC EIGEN_PARALLEL_FOR_INLINE void Eigen::CoreThreadPoolDevice::parallelForImpl ( Index  outerBegin, Index  outerEnd, Index  innerBegin, Index  innerEnd, BinaryFunctor &  f, Barrier &  barrier, int  level  )

inline

                                                                              {
    while (level > 0) {
      level--;
      Index outerSize = outerEnd - outerBegin;
      if (outerSize > 1) {
        Index outerMid = outerBegin + (outerSize >> 1);
        Task right = [this, &f, &barrier, outerMid, outerEnd, innerBegin, innerEnd, level]() {
          parallelForImpl<BinaryFunctor, PacketSize>(outerMid, outerEnd, innerBegin, innerEnd, f, barrier, level);
        };
        m_pool.Schedule(std::move(right));
        outerEnd = outerMid;
      } else {
        Index innerSize = innerEnd - innerBegin;
        eigen_assert(innerSize % PacketSize == 0 && "this function assumes innerSize is a multiple of PacketSize");
        Index innerMid = innerBegin + numext::round_down(innerSize >> 1, PacketSize);
        Task right = [this, &f, &barrier, outerBegin, outerEnd, innerMid, innerEnd, level]() {
          parallelForImpl<BinaryFunctor, PacketSize>(outerBegin, outerEnd, innerMid, innerEnd, f, barrier, level);
        };
        m_pool.Schedule(std::move(right));
        innerEnd = innerMid;
      }
    }
    for (Index outer = outerBegin; outer < outerEnd; outer++)
      for (Index inner = innerBegin; inner < innerEnd; inner += PacketSize) f(outer, inner);
    barrier.Notify();
  }

References eigen_assert, f(), m_pool, Eigen::Barrier::Notify(), Eigen::numext::round_down(), and Eigen::ThreadPoolTempl< Environment >::Schedule().

Member Data Documentation

m_costFactor

float Eigen::CoreThreadPoolDevice::m_costFactor

Referenced by calculateLevels(), and CoreThreadPoolDevice().

m_pool

ThreadPool& Eigen::CoreThreadPoolDevice::m_pool

Referenced by calculateLevels(), and parallelForImpl().

---

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

• CoreThreadPoolDevice.h