MRParallelFor.h

Go to the documentation of this file.

#pragma once
 
#include "MRFunctional.h"
#include "MRParallel.h"
#include "MRProgressCallback.h"
#include "MRTbbThreadMutex.h"
#include "MRVector.h"
 
#include <atomic>
 
namespace MR
{

 
MRMESH_API void parallelFor( size_t begin, size_t end, FunctionRef<void ( size_t )> f );
 
MRMESH_API void parallelFor( size_t begin, size_t end, FunctionRef<void ( size_t )> f, tbb::task_group_context& tgc );
 
MRMESH_API void parallelFor( size_t begin, size_t end, FunctionRef<void ( size_t, void* )> f, FunctionRef<void* ()> ctx );
 
MRMESH_API bool parallelFor( size_t begin, size_t end, FunctionRef<void ( size_t, void* )> f, FunctionRef<void* ()> ctx,
    ProgressCallback cb, size_t reportProgressEvery = 1024 );

template <typename I, typename F, typename ...Cb>
inline auto ParallelFor( I begin, I end, F && f, Cb && ... cb )
{
    if constexpr ( sizeof...( cb ) == 0 )
    {
        return parallelFor( begin, end, [&] ( size_t i )
        {
            std::forward<F>( f )( I( i ) );
        } );
    }
    else
    {
        return parallelFor( begin, end, [&] ( size_t i, void* )
        {
            std::forward<F>( f )( I( i ) );
        }, [&]
        {
            return nullptr;
        }, std::forward<Cb>( cb )... );
    }
}

template <typename I, typename F>
inline void ParallelFor( I begin, I end, F && f, tbb::task_group_context& tgc )
{
    parallelFor( begin, end, [&] ( size_t i )
    {
        std::forward<F>( f )( I( i ) );
    }, tgc );
}

template <typename I, typename L, typename F, typename ...Cb>
inline auto ParallelFor( I begin, I end, tbb::enumerable_thread_specific<L> & e, F && f, Cb && ... cb )
{
    return parallelFor( begin, end, [&] ( size_t i, void* ctx )
    {
        std::forward<F>( f )( I( i ), *(L*)ctx );
    }, [&]
    {
        return &e.local();
    }, std::forward<Cb>( cb )... );
}

template <typename T, typename ...F>
inline auto ParallelFor( const std::vector<T> & v, F &&... f )
{
    return ParallelFor( size_t(0), v.size(), std::forward<F>( f )... );
}

template <typename T, typename I, typename ...F>
inline auto ParallelFor( const Vector<T, I> & v, F &&... f )
{
    return ParallelFor( v.beginId(), v.endId(), std::forward<F>( f )... );
}

template <typename T, typename I, typename ...F>
inline auto ParallelFor( const Buffer<T, I> & buf, F &&... f )
{
    return ParallelFor( buf.beginId(), buf.endId(), std::forward<F>( f )... );
}

 
}