BS::thread_pool::blocks< T > Class Template Reference

A helper class to divide a range into blocks. Used by detach_blocks(), submit_blocks(), detach_loop(), and submit_loop(). More...

Collaboration diagram for BS::thread_pool::blocks< T >:

Public Member Functions
	blocks (const T first_index_, const T index_after_last_, const size_t num_blocks_)
	Construct a blocks object with the given specifications.
T	start (const size_t block) const
	Get the first index of a block.
T	end (const size_t block) const
	Get the index after the last index of a block.
size_t	get_num_blocks () const
	Get the number of blocks. Note that this may be different than the desired number of blocks that was passed to the constructor.

Private Attributes
size_t	block_size = 0
	The size of each block (except possibly the last block).
T	first_index = 0
	The first index in the range.
T	index_after_last = 0
	The index after the last index in the range.
size_t	num_blocks = 0
	The number of blocks.
size_t	remainder = 0
	The remainder obtained after dividing the total size by the number of blocks.

Detailed Description

template<typename T>
class BS::thread_pool::blocks< T >

A helper class to divide a range into blocks. Used by detach_blocks(), submit_blocks(), detach_loop(), and submit_loop().

Template Parameters

T	The type of the indices. Should be a signed or unsigned integer.

Constructor & Destructor Documentation

blocks()

template<typename T >

BS::thread_pool::blocks< T >::blocks ( const T  first_index_, const T  index_after_last_, const size_t  num_blocks_  )

inline

Construct a blocks object with the given specifications.

Parameters

first_index_	The first index in the range.
index_after_last_	The index after the last index in the range.
num_blocks_	The desired number of blocks to divide the range into.

                                                                                          : first_index(first_index_), index_after_last(index_after_last_), num_blocks(num_blocks_)
        {
            if (index_after_last > first_index)
            {
                const size_t total_size = static_cast<size_t>(index_after_last - first_index);
                if (num_blocks > total_size)
                    num_blocks = total_size;
                block_size = total_size / num_blocks;
                remainder = total_size % num_blocks;
                if (block_size == 0)
                {
                    block_size = 1;
                    num_blocks = (total_size > 1) ? total_size : 1;
                }
            }
            else
            {
                num_blocks = 0;
            }
        }

Member Function Documentation

start()

template<typename T >

T BS::thread_pool::blocks< T >::start ( const size_t  block ) const

inline

Get the first index of a block.

Parameters

block

The block number.

Returns

The first index.

        {
            return first_index + static_cast<T>(block * block_size) + static_cast<T>(block < remainder ? block : remainder);
        }

Here is the caller graph for this function:

end()

template<typename T >

T BS::thread_pool::blocks< T >::end ( const size_t  block ) const

inline

Get the index after the last index of a block.

Parameters

block

The block number.

Returns

The index after the last index.

        {
            return (block == num_blocks - 1) ? index_after_last : start(block + 1);
        }

Here is the caller graph for this function:

get_num_blocks()

template<typename T >

size_t BS::thread_pool::blocks< T >::get_num_blocks ( ) const

inline

Get the number of blocks. Note that this may be different than the desired number of blocks that was passed to the constructor.

Returns

The number of blocks.

        {
            return num_blocks;
        }

Here is the caller graph for this function:

---

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

• external/threadpool/include/BS_thread_pool.hpp