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 *	get_pointer_if_available () const
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 1718 of file Calorimeter/CaloRecGPU/CaloRecGPU/Helpers.h.

      {
        std::unique_lock<std::shared_mutex> lock(m_mutex);
        
        const std::thread::id this_id = std::this_thread::get_id();
        const std::thread::id invalid_id{};
 
        bool empty_found = false;
        
        size_t first_empty;
        
        for (size_t i = 0; i < m_thread_equivs.size(); ++i)
          {
            if (m_thread_equivs[i] == this_id)
              {
                return *(m_held[i]);
              }
            else if (!empty_found && m_thread_equivs[i] == invalid_id)
              {
                empty_found = true;
                first_empty = i;
              }
          }
 
        if (empty_found)
          {
            m_thread_equivs[first_empty] = this_id;
            return *(m_held[first_empty]);
          }
        else
          {
            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 1840 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 1855 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 1772 of file Calorimeter/CaloRecGPU/CaloRecGPU/Helpers.h.

      {
        std::shared_lock<std::shared_mutex> lock(m_mutex);
 
        T * to_return = get_pointer_if_available();
 
        if (to_return != nullptr)
          {
            return *to_return;
          }
        else
          {
            //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 1756 of file Calorimeter/CaloRecGPU/CaloRecGPU/Helpers.h.

      {
        {
          std::shared_lock<std::shared_mutex> lock(m_mutex);
 
          T * to_return = get_pointer_if_available();
 
          if (to_return != nullptr)
            {
              return *to_return;
            }
        }
        return add_one_and_return();
      }

get_pointer_if_available()

template<class T>

T * CaloRecGPU::Helpers::separate_thread_holder< T >::get_pointer_if_available ( ) const

inlineprivate

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

      {
        const 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].get();
              }
          }
        return nullptr;
      }

held_size()

template<class T>

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

inline

Definition at line 1834 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 1825 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 1790 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 1804 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