CaloRecGPU::Helpers::separate_thread_holder< T > Class Template Reference

Manages objects of type T in a thread-safe way, ensuring that there's an object available for each separate thread while minimizing the number of allocations. More...

#include <Helpers.h>

Collaboration diagram for CaloRecGPU::Helpers::separate_thread_holder< T >:

Public Member Functions
T &	get_one ()
T &	get_for_thread () const
void	release_one ()
void	resize (const size_t new_size)
template<class F, class ... Args>
void	operate_on_all (F &&f, Args &&... args)
size_t	held_size () const
size_t	available_size () const
size_t	filled_size () const

Private Member Functions
T &	add_one_and_return ()

Private Attributes
std::vector< std::unique_ptr< T > >	m_held
std::vector< typename std::thread::id >	m_thread_equivs
std::shared_mutex	m_mutex

Detailed Description

template<class T>
class CaloRecGPU::Helpers::separate_thread_holder< T >

Manages objects of type T in a thread-safe way, ensuring that there's an object available for each separate thread while minimizing the number of allocations.

Internally uses a std::vector of std::thread::id to manage the different threads, thus it is especially efficient for relatively small numbers of concurrent threads (which matches the use case, e. g. 64 threads )

Definition at line 1683 of file Calorimeter/CaloRecGPU/CaloRecGPU/Helpers.h.

Member Function Documentation

add_one_and_return()

template<class T>

T & CaloRecGPU::Helpers::separate_thread_holder< T >::add_one_and_return ( )

inlineprivate

Definition at line 1701 of file Calorimeter/CaloRecGPU/CaloRecGPU/Helpers.h.

      {
        std::unique_lock<std::shared_mutex> lock(m_mutex);
        m_held.emplace_back(std::make_unique<T>());
        m_thread_equivs.emplace_back(std::this_thread::get_id());
        return *(m_held.back());
      }

available_size()

template<class T>

size_t CaloRecGPU::Helpers::separate_thread_holder< T >::available_size ( ) const

inline

Definition at line 1795 of file Calorimeter/CaloRecGPU/CaloRecGPU/Helpers.h.

      {
        std::shared_lock<std::shared_mutex> lock(m_mutex);
        size_t count = 0;
        const std::thread::id invalid_id{};
        for (const auto & id : m_thread_equivs)
          {
            if (id == invalid_id)
              {
                ++count;
              }
          }
        return count;
      }

filled_size()

template<class T>

size_t CaloRecGPU::Helpers::separate_thread_holder< T >::filled_size ( ) const

inline

Definition at line 1810 of file Calorimeter/CaloRecGPU/CaloRecGPU/Helpers.h.

      {
        std::shared_lock<std::shared_mutex> lock(m_mutex);
        size_t count = 0;
        const std::thread::id invalid_id{};
        for (const auto & id : m_thread_equivs)
          {
            if (id == invalid_id)
              {
                ++count;
              }
          }
        return m_held.size() - count;
      }

get_for_thread()

template<class T>

T & CaloRecGPU::Helpers::separate_thread_holder< T >::get_for_thread ( ) const

inline

Precondition

Assumes the thread already has an allocated object (through get_one).

Definition at line 1729 of file Calorimeter/CaloRecGPU/CaloRecGPU/Helpers.h.

      {
        std::shared_lock<std::shared_mutex> lock(m_mutex);
        std::thread::id this_id = std::this_thread::get_id();
        for (size_t i = 0; i < m_thread_equivs.size(); ++i)
          {
            if (m_thread_equivs[i] == this_id)
              {
                return *(m_held[i]);
              }
          }
        //Here would be a good place for an unreachable.
        //C++23?
        return *(m_held.back());
      }

get_one()

template<class T>

T & CaloRecGPU::Helpers::separate_thread_holder< T >::get_one ( )

inline

Definition at line 1710 of file Calorimeter/CaloRecGPU/CaloRecGPU/Helpers.h.

      {
        {
          std::shared_lock<std::shared_mutex> lock(m_mutex);
          std::thread::id this_id = std::this_thread::get_id();
          const std::thread::id invalid_id{};
          for (size_t i = 0; i < m_thread_equivs.size(); ++i)
            {
              if (m_thread_equivs[i] == invalid_id)
                {
                  m_thread_equivs[i] = this_id;
                  return *(m_held[i]);
                }
            }
        }
        return add_one_and_return();
      }

held_size()

template<class T>

size_t CaloRecGPU::Helpers::separate_thread_holder< T >::held_size ( ) const

inline

Definition at line 1789 of file Calorimeter/CaloRecGPU/CaloRecGPU/Helpers.h.

      {
        std::shared_lock<std::shared_mutex> lock(m_mutex);
        return m_held.size();
      }

operate_on_all()

template<class T>

template<class F, class ... Args>

void CaloRecGPU::Helpers::separate_thread_holder< T >::operate_on_all ( F && f, Args &&... args )

inline

Definition at line 1780 of file Calorimeter/CaloRecGPU/CaloRecGPU/Helpers.h.

      {
        std::unique_lock<std::shared_mutex> lock(m_mutex);
        for (std::unique_ptr<T> & obj : m_held)
          {
            f(*obj, std::forward<Args>(args)...);
          }
      }

release_one()

template<class T>

void CaloRecGPU::Helpers::separate_thread_holder< T >::release_one ( )

inline

Definition at line 1745 of file Calorimeter/CaloRecGPU/CaloRecGPU/Helpers.h.

      {
        std::unique_lock<std::shared_mutex> lock(m_mutex);
        std::thread::id this_id = std::this_thread::get_id();
        const std::thread::id invalid_id{};
        for (size_t i = 0; i < m_thread_equivs.size(); ++i)
          {
            if (m_thread_equivs[i] == this_id)
              {
                m_thread_equivs[i] = invalid_id;
              }
          }
      }

resize()

template<class T>

void CaloRecGPU::Helpers::separate_thread_holder< T >::resize ( const size_t new_size )

inline

Definition at line 1759 of file Calorimeter/CaloRecGPU/CaloRecGPU/Helpers.h.

      {
        std::unique_lock<std::shared_mutex> lock(m_mutex);
        if (new_size < m_held.size())
          {
            m_held.resize(new_size);
            m_thread_equivs.resize(new_size);
          }
        else if (new_size > m_held.size())
          {
            const size_t to_add = new_size - m_held.size();
            const std::thread::id invalid_id{};
            for (size_t i = 0; i < to_add; ++i)
              {
                m_held.emplace_back(std::make_unique<T>());
                m_thread_equivs.emplace_back(invalid_id);
              }
          }
      }

Member Data Documentation

m_held

template<class T>

std::vector< std::unique_ptr<T> > CaloRecGPU::Helpers::separate_thread_holder< T >::m_held

private

Definition at line 1686 of file Calorimeter/CaloRecGPU/CaloRecGPU/Helpers.h.

m_mutex

template<class T>

std::shared_mutex CaloRecGPU::Helpers::separate_thread_holder< T >::m_mutex

mutableprivate

Definition at line 1699 of file Calorimeter/CaloRecGPU/CaloRecGPU/Helpers.h.

m_thread_equivs

template<class T>

std::vector< typename std::thread::id > CaloRecGPU::Helpers::separate_thread_holder< T >::m_thread_equivs

private

Definition at line 1687 of file Calorimeter/CaloRecGPU/CaloRecGPU/Helpers.h.

---

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

• Calorimeter/CaloRecGPU/CaloRecGPU/Helpers.h