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 1472 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 1490 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 1584 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 1599 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 1518 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 1499 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 1578 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 1569 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 1534 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 1548 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);
               }
           }
       }