BS::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...

#include <BS_thread_pool.hpp>

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

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

Detailed Description

template<typename T>
class BS::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::blocks< T >::blocks ( const T  first_index_, const T  index_after_last_, const std::size_t  num_blocks_  )

inlinenoexcept

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.

                                                                                                  : num_blocks(num_blocks_), first_index(first_index_), index_after_last(index_after_last_)
    {
        if (index_after_last > first_index)
        {
            const std::size_t total_size = static_cast<std::size_t>(index_after_last - first_index);
            num_blocks = std::min(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

end()

template<typename T >

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

inlinenoexcept

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);
    }

get_num_blocks()

template<typename T >

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

inlinenoexcept

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:

start()

template<typename T >

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

inlinenoexcept

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);
    }

---

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

• external/threadpool/include/BS_thread_pool.hpp