Paralléliser une tâche sur un tableau

Bonjour à tous,

Alors voila je commence un peu à m’intéresser aux threads en c++ avec std::thread. Et je me pose une question. Imaginons j'ai un un tableau de string de 1000 éléments voir plus, sur chacun des éléments je veux exécuter une fonction qui me retourne un résultat.
Je me demandais si il serait possible de faire quelques chose du genre:
je sépare mon tableau en 2 tableaux de 500 éléments, je créer 2 threads en passant en paramètre un tableau et je boucle dans la fonction appelé par mes threads sur les éléments du tableau pour exécuter ma fonction et retourner un tableau de résultat.

Code:

---

1 2 3 4 5 6 7 8 9 10

mon_tableau_1000   tab1_500; tab2_500;   std::thread t1 (fonction, &tab1_500); std::thread t2 (fonction, &tab2_500);   t1.join(); t2.join();

---

Voilà un pseudo code de ce que j'aimerais faire, mais je me pose des questions, est-il possible déjà de retourner un tableau depuis la fonction qui sera appelé par mes threads ? Et une autre question est-ce une bonne méthode afin d’accélérer le traitement sur un gros tableau ?

Citation:

---

Envoyé par simon884

est-il possible déjà de retourner un tableau depuis la fonction qui sera appelé par mes threads ?

---

On peut tout retourner en C++ sauf un tableau brut!
Mais il est aussi possible de mettre à jour le demi-tableau et dans ce cas il n'y a pas besoin de valeur de retour.
On peut sinon retourner un vector ou un array et en utilisant des future, il est alors plus simple d'utiliser std::async() qui gère à la fois le thread, la future et la promise.

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

#include <future> #include <vector> std::vector<std::string> fct( std::string const* tb , std::size_t nb ) { std::vector<std::string> res(nb); for ( std::size_t i{} ; i < nb ; ++i ) res[i] = tb[i] + "x"; return res; }   std::string tab[] = { "a", "b", "c", "d", "e", "f" }; std::future<std::vector<std::string>> r1 = std::async( std::launch::async , &fct , tab , 3 ); std::future<std::vector<std::string>> r2 = std::async( std::launch::async , &fct , tab+3 , 3 );   r1.wait(); // attend la disponibilité de la future r2.wait(); for ( auto const& s : r1.get() ) std::cout << s; for ( auto const& s : r2.get() ) std::cout << s;

---

Citation:

---

Envoyé par simon884

Et une autre question est-ce une bonne méthode afin d’accélérer le traitement sur un gros tableau ?

---

Très probablement, surtout si la taille du tableau et le traitement sont importants.

Merci j'y vois déjà un peu plus clair avec ton exemple :D

Citation:

---

Envoyé par dalfab

On peut tout retourner en C++ sauf un tableau brut!
Mais il est aussi possible de mettre à jour le demi-tableau et dans ce cas il n'y a pas besoin de valeur de retour.

---

Oui je me suis un peut mal exprimé pour le retour de la fonction :roll:
Pour mettre à jour le demi-tableau qui est passé à la fonction tu utiliserais un passage par référence ? Le fait de mettre à jour le demi-tableau serait plus performant non? Niveau rapidité utilisation mémoire ?

Encore mieux serait que tes threads utilisent le tableau et modifient un autre directement avec quelque chose comme

Code:

---

1 2 3 4 5 6 7 8 9 10

int main() { auto fn = [](int* start, int* end, int* res) { while (start != end) *res++ = bidule(*start++); }; int val[1000]; int results[1000]; std::thread t1([]() {fn(&val[0], &val[0] + 500, &results[0]);}); std::thread t2([]() {fn(&val[0] + 500, &val[0] + 1000, &results[0] + 500);}); t1.join(); t2.join(); }

---

Le main tourne déjà dans un thread donc inutile d'en créer deux supplémentaires, un seul suffit.

Code:

---

1 2 3 4 5 6

auto fn = [](int* start, int* end, int* res) { while (start != end) *res++ = bidule(*start++); }; int val[1000]; int results[1000]; std::thread t1([]() {fn(&val[0], &val[0] + 500, &results[0]);}); fn(&val[0] + 500, &val[0] + 1000, &results[0] + 500); t1.join();

---

Et si tu ne tiens pas absolument à manipuler les threads à la main, tu peux utiliser OpenMP, qui est plus simple et plus flexible.

Code:

---

1 2 3 4 5

int val[1000]; int results[1000]; #pragma omp parallel for for (int i=0; i<1000; i++) results[i] = bidule(val[i]);

---