Discussion :

[simon884]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 ?

[dalfab]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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;

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.

[simon884]

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

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
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 ?

[Bousk]

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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

[zobal]

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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