parallel_chunk::ParallelChunkProcessor< T > Class Template Reference

Parallel chunk processor for concurrent operations. More...

#include <parallel_chunk.hpp>

Public Types
using	ChunkOperation = std::function< void(std::vector< T > &)>

Static Public Member Functions
template<typename U >
static std::vector< std::vector< U > >	map (const std::vector< std::vector< T > > &chunks, std::function< U(const T &)> operation)
	Map operation over chunks in parallel.
static void	process_chunks (std::vector< std::vector< T > > &chunks, const std::function< void(std::vector< T > &)> &operation)
	Process chunks in parallel.
static T	reduce (const std::vector< std::vector< T > > &chunks, std::function< T(const T &, const T &)> operation, T initial)
	Reduce chunks in parallel.

Detailed Description

template<typename T>
class parallel_chunk::ParallelChunkProcessor< T >

Parallel chunk processor for concurrent operations.

Template Parameters

T	The type of elements to process

Definition at line 19 of file parallel_chunk.hpp.

Member Typedef Documentation

ChunkOperation

template<typename T >

using parallel_chunk::ParallelChunkProcessor< T >::ChunkOperation = std::function<void(std::vector<T>&)>

Definition at line 21 of file parallel_chunk.hpp.

Member Function Documentation

map()

template<typename T >

template<typename U >

static std::vector< std::vector< U > > parallel_chunk::ParallelChunkProcessor< T >::map ( const std::vector< std::vector< T > > &  chunks, std::function< U(const T &)>  operation  )

inlinestatic

Map operation over chunks in parallel.

Parameters

chunks	Input chunks
operation	Mapping operation

Returns

Transformed chunks

Definition at line 64 of file parallel_chunk.hpp.

                                                                               {
        std::vector<std::vector<U>> result(chunks.size());
        std::vector<std::future<void>> futures;
 
        for (size_t i = 0; i < chunks.size(); ++i) {
            futures.push_back(std::async(std::launch::async, [&, i]() {
                result[i].reserve(chunks[i].size());
                std::transform(chunks[i].begin(), chunks[i].end(), std::back_inserter(result[i]),
                               operation);
            }));
        }
 
        for (auto& future : futures) {
            future.wait();
        }
 
        return result;
    }

process_chunks()

template<typename T >

static void parallel_chunk::ParallelChunkProcessor< T >::process_chunks ( std::vector< std::vector< T > > &  chunks, const std::function< void(std::vector< T > &)> &  operation  )

inlinestatic

Process chunks in parallel.

Parameters

chunks	Vector of chunks to process
operation	Operation to apply to each chunk
num_threads	Number of threads to use (default: hardware concurrency)

Definition at line 29 of file parallel_chunk.hpp.

                                                                                  {
        std::mutex exception_mutex;
        std::exception_ptr exception_ptr = nullptr;
        std::vector<std::thread> threads;
 
        for (auto& chunk : chunks) {
            threads.emplace_back([&chunk, &operation, &exception_mutex, &exception_ptr]() {
                try {
                    operation(chunk);
                } catch (...) {
                    std::lock_guard<std::mutex> lock(exception_mutex);
                    if (!exception_ptr) {
                        exception_ptr = std::current_exception();
                    }
                }
            });
        }
 
        for (auto& thread : threads) {
            thread.join();
        }
 
        if (exception_ptr) {
            std::rethrow_exception(exception_ptr);
        }
    }

Referenced by TEST_F(), TEST_F(), TEST_F(), TEST_F(), and TEST_F().

reduce()

template<typename T >

static T parallel_chunk::ParallelChunkProcessor< T >::reduce ( const std::vector< std::vector< T > > &  chunks, std::function< T(const T &, const T &)>  operation, T  initial  )

inlinestatic

Reduce chunks in parallel.

Parameters

chunks	Input chunks
operation	Reduction operation
initial	Initial value

Returns

Reduced value

Definition at line 91 of file parallel_chunk.hpp.

                                                                             {
        std::vector<std::future<T>> futures;
 
        for (const auto& chunk : chunks) {
            futures.push_back(std::async(std::launch::async, [&]() {
                return std::accumulate(chunk.begin(), chunk.end(), T(), operation);
            }));
        }
 
        T result = initial;
        for (auto& future : futures) {
            result = operation(result, future.get());
        }
 
        return result;
    }

Referenced by TEST_F(), TEST_F(), and TEST_F().

---

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

• parallel_chunk.hpp