Boucles parallèles en C++

Qu'est-ce que votre plate-forme? Vous pouvez regarder OpenMP, si ce n'est pas une partie de C++. Mais il est largement soutenu par les compilateurs.

Comme pour la gamme à base de boucles, voir, par exemple, En utilisant OpenMP avec C++11 gamme à base de boucles for?.

J'ai aussi vu quelques documents à http://www.open-std.org qui indiquent des efforts pour intégrer les constructions parallèles/algorithmes dans l'avenir en C++, mais ne savent pas quel est leur état actuel.

Mise à JOUR

Simplement en ajoutant quelques exemplaires code:

template <typename RAIter>
void loop_in_parallel(RAIter first, RAIter last) {
   const size_t n = std::distance(first, last);

   #pragma omp parallel for
   for (size_t i = 0; i < n; i++) {
       auto& elem = *(first + i);
       //do whatever you want with elem
    }
}

Le nombre de threads peut être réglé au moment de l'exécution par le OMP_NUM_THREADS variable d'environnement.

OriginalL'auteur Daniel Langr

std::async peut être un bon ajustement ici, si vous êtes heureux de laisser la C++ exécution de contrôler le parallélisme.

Exemple de l'cppreference.com:

#include <iostream>
#include <vector>
#include <algorithm>
#include <numeric>
#include <future>

template <typename RAIter>
int parallel_sum(RAIter beg, RAIter end)
{
    auto len = end - beg;
    if(len < 1000)
        return std::accumulate(beg, end, 0);

    RAIter mid = beg + len/2;
    auto handle = std::async(std::launch::async,
                              parallel_sum<RAIter>, mid, end);
    int sum = parallel_sum(beg, mid);
    return sum + handle.get();
}

int main()
{
    std::vector<int> v(10000, 1);
    std::cout << "The sum is " << parallel_sum(v.begin(), v.end()) << '\n';
}

OriginalL'auteur bobah

Avec C++11, vous pouvez paralléliser une boucle for avec seulement quelques lignes de codes.
Cette fend d'une boucle for dans de plus petits morceaux et d'attribuer à chaque sous-boucle à un fil:

///Basically replacing:
void sequential_for(){
    for(int i = 0; i < nb_elements; ++i)
        computation(i);
}

///By:
void threaded_for(){
    parallel_for(nb_elements, [&](int start, int end){ 
        for(int i = start; i < end; ++i)
            computation(i); 
    } );
}

Ou au sein d'une classe:

struct My_obj {

    ///Replacing:
    void sequential_for(){
        for(int i = 0; i < nb_elements; ++i)
            computation(i);
    }

    ///By:
    void threaded_for(){
        parallel_for(nb_elements, [this](int s, int e){ this->process_chunk(s, e); } );
    }

    void process_chunk(int start, int end)
    {
        for(int i = start; i < end; ++i)
            computation(i);
    }
};

Pour ce faire, il vous suffit de mettre le code ci-dessous dans un fichier d'en-tête et de l'utiliser à volonté:

#include <algorithm>
#include <thread>
#include <functional>
#include <vector>
///@param[in] nb_elements : size of your for loop
///@param[in] functor(start, end) :
///your function processing a sub chunk of the for loop.
///"start" is the first index to process (included) until the index "end"
///(excluded)
///@code
///    for(int i = start; i < end; ++i)
///        computation(i);
///@endcode
///@param use_threads : enable /disable threads.
///
///
static
void parallel_for(unsigned nb_elements,
std::function<void (int start, int end)> functor,
bool use_threads = true)
{
//-------
unsigned nb_threads_hint = std::thread::hardware_concurrency();
unsigned nb_threads = nb_threads_hint == 0 ? 8 : (nb_threads_hint);
unsigned batch_size = nb_elements / nb_threads;
unsigned batch_remainder = nb_elements % nb_threads;
std::vector< std::thread > my_threads(nb_threads);
if( use_threads )
{
//Multithread execution
for(unsigned i = 0; i < nb_threads; ++i)
{
int start = i * batch_size;
my_threads[i] = std::thread(functor, start, start+batch_size);
}
}
else
{
//Single thread execution (for easy debugging)
for(unsigned i = 0; i < nb_threads; ++i){
int start = i * batch_size;
functor( start, start+batch_size );
}
}
//Deform the elements left
int start = nb_threads * batch_size;
functor( start, start+batch_remainder);
//Wait for the other thread to finish their task
if( use_threads )
std::for_each(my_threads.begin(), my_threads.end(), std::mem_fn(&std::thread::join));
}

Enfin, vous pouvez définir une macro pour obtenir encore plus compact expression:

#define PARALLEL_FOR_BEGIN(nb_elements) tbx::parallel_for(nb_elements, [&](int start, int end){ for(int i = start; i < end; ++i)
#define PARALLEL_FOR_END()})
TBX_PARALLEL_FOR_BEGIN(nb_edges)
{
computation(i);
}TBX_PARALLEL_FOR_END();

OriginalL'auteur arkan