Multithread générique

Multithread générique - C++ - Programmation

Marsh Posté le 04-06-2011 à 10:47:57    

Salut à tous,
 
Voici mon problème : j'ai des conteneurs 3D dans lesquels je stocke des données quelconque sur lesquelles je souhaite appliquer divers filtres, morphologies mathématiques, etc... Donc jusqu'ici, pour paralléliser ces opérations, je faisais une fonction pour l'opération elle-même et une fonction qui s'occupait de créer mes threads et de leur répartir le travail (chaque thread traite une partie du volume). Le truc c'est cette seconde fonction est en fait tout le temps la même à l'exception du nom de la fonction que celle-ci appelle et des paramètres de la fonction appelée. Je cherche donc un moyen d'écrire une fonction générique qui pourrait m'appeler n'importe qu'elle fonction. Donc jusqu'ici je suis parvenu à appeler une fonction quelconque en passant un pointeur sur fonction à ma fonction générique mais le hic c'est que toutes les fonctions qu'elle peut potentiellement appeler doivent avoir les mêmes paramètres (ce qui n'est évidemment pas le cas de mes fonctions). J'ai solutionné le problème en passant à mes fonctions un vector de pointeurs. Ça marche alors très bien mais je suis obligé de faire plein de static_cast au début de mes fonctions pour utiliser mes pointeurs et en plus je me retrouve à manipuler des pointeurs partout et c'est un peu ch***t .... Je cherche donc un moyen plus joli de faire ça, qui m'éviterai de passer par un vector de pointeurs :)
Pour la partie threads, j'utilise Boost::threads.
 
 
Merci d'avance :)
 
PS : Voici le code actuel (faites pas attention aux fonctions Run,affiche_test et test_thread:
 

Code :
  1. #include "Mes_Fonctions.hpp"
  3. #ifndef threadbool
  4. #define threadbool 0
  5. #ifdef THREAD
  6. #include <boost/thread/thread.hpp>
  7. #undef threadbool
  8. #define threadbool 1
  9. #endif
  10. #endif
  12. using namespace std;
  14. // ===================================================================
  16. class erode_class{
  18. public:
  20. erode_class(vector<void*> args_):ptrs_(args_){};
  22. void Run(vector<void* > &truc){
  23. cout<<"Paramètres :"<<endl;
  24. for(size_t i=0;i<ptrs_.size();++i){
  25.  cout<<"\t"<<*(static_cast<int *> (ptrs_[i]))<<endl;
  26.  }
  27. cout<<"Paramètre additionel :"<<endl;
  28. for(size_t i=0;i<truc.size();++i){
  29.  int *temp=static_cast<int *> (truc[i]);
  30.  cout<<"\t"<<(*temp)<<endl;
  31.  }
  32.  cout<<endl<<endl;
  33. };
  35. template<class T>
  36. void thread_erode_b(vector<void *> &arguments_,vector<bool> &traites){
  37. if(arguments_.size()!=5){cout<<"Erode arguments are incorrect"<<endl<<"End program"<<endl;exit(0);}
  38. T *volume=static_cast<T *> (arguments_[0]);
  39. T *volume2=static_cast<T *> (arguments_[1]);
  40. int ordre=*(static_cast<int *> (arguments_[2]));
  41. int planstart=*(static_cast<int *> (arguments_[3]));
  42. int planstop=*(static_cast<int *> (arguments_[4]));
  43. const int dim1=(*volume).dim1(),dim2=(*volume).dim2(),dim3=(*volume).dim3();
  45. // Traitement proprement dit
  47. }
  48. private:
  49. vector<void*> ptrs_;
  50. };
  52. typedef void (erode_class::*traitement)(vector<void *> &arguments_,vector<bool> &traites);
  53. typedef void (erode_class::*Run_test)(vector<void *> &truc);
  55. // =========================================================================
  56. template <class T>
  57. void GenericThreadedFunction_2Volumes(T &volume1,T &volume2,const size_t nb_threads,vector<void* > &args,erode_class &test,int &planstart,int &planstop,vector<bool> &traites, traitement fonction){
  58. volume2.resize(volume1.dim1(),volume1.dim2(),volume1.dim3());
  59. #if threadbool
  60. boost::thread_group threads1;
  61. size_t box_size=volume1.dim1();
  63. for (std::size_t n=0; n<nb_threads; ++n){
  64. size_t nb_plans=(int)((double)box_size/(double)nb_threads);
  65. if(n<box_size%nb_threads)nb_plans++;
  66. if(n>=box_size%nb_threads){
  67.  planstart=n*nb_plans+box_size%nb_threads;
  68.  }
  69. else {
  70.  planstart=n*nb_plans;
  71.  }
  72. planstop=planstart-1+nb_plans;
  73. // Ici je sais que ce n'est pas la meilleure façon de répartir les taches mais j'optimiserai ça plus tard :-P
  74. args[3]=&planstart;
  75. args[4]=&planstop;
  76. cout<<n<<" : "<<*(static_cast<int*> (args[3]))<<" to "<<*(static_cast<int*> (args[4]))<<endl;
  77. threads1.create_thread(boost::bind(fonction,boost::ref(test),boost::ref(args),boost::ref(traites)));
  78. }
  79. threads1.join_all();
  80. #else
  81. size_t planstart=0,planstop=volume1.dim1()-1;
  82. fonction(volume1,volume2,ordre,planstart,planstop);
  83. #endif
  84. }
  86. template<typename T>
  87. void affiche_test(double i){
  88. cout<<"Affiche_test = "<<T(i)<<endl;
  89. }
  91. template<typename T>
  92. void test_thread(T j,void (*f)(T k)){
  93. boost::thread_group threads1;
  94. for(int i=0;i<2;++i){
  95. threads1.create_thread(boost::bind(f,j));
  96. sleep(1);}
  97. threads1.join_all();
  98. }
  100. int main(int argc, char *argv[])
  101. {
  102. size_t nb_threads;
  103. #if threadbool
  104. nb_threads=boost::thread::hardware_concurrency();
  105. #else
  106. nb_threads=1;
  107. #endif
  109. slip::RegularVector3dField3d<double> volume1b;
  110. read_slip_data(volume1b,"volume_lif_00005.abe" );
  112. slip::Volume<double> volume1(volume1b.dim1(),volume1b.dim2(),volume1b.dim3()),volume2;
  113. slip::RegularVector3dField3d<double>::const_iterator iter1=volume1b.begin();
  114. slip::Volume<double>::iterator iter2=volume1.begin();
  116. for( ;
  117. iter1!=volume1b.end()&&
  118. iter2!=volume1.end();
  119. ++iter1,++iter2)
  120. (*iter2)=(*iter1)[0];
  122. vector<void*> args,tmp;
  123. erode_class test(args);
  125. int planstart=0,planstop=(int)volume1.dim1(),ordre=3;
  127. // Création du vector de poiteurs sur les paramètres ... ce que je voudrai éviter
  128. tmp.push_back(&volume1);
  129. tmp.push_back(&volume2);
  130. tmp.push_back(&ordre);
  131. tmp.push_back(&planstart);
  132. tmp.push_back(&planstop);
  134. vector<bool> traites(volume1.dim1());
  135. traitement f = &erode_class::thread_erode_b<slip::Volume<double> >;
  136. GenericThreadedFunction_2Volumes(volume1,volume2,nb_threads,tmp,test,planstart,planstop,traites,f);
  139. return 0;
  140. }

Reply

Marsh Posté le 04-06-2011 à 10:47:57   

Reply

Marsh Posté le 04-06-2011 à 17:55:24    

Ça y est, j'ai trouvé une manière faire proche de ce que j'imaginai.
Je crée des classes contenant ma fonction et ses paramètres puis j'ai juste à balancer la fonction dans un thread.
Donc au lieu d'avoir une fonction par traitement j'ai maintenant une classe mais ça ne change pas grand chose :)
 
Merci quand même !  :jap:  
A+  :hello:  
 
 
Le code pour ceux que ça intéresserait :
 

Code :
  1. #include "Mes_Fonctions.hpp"
  3. #ifndef threadbool
  4. #define threadbool 0
  5. #ifdef THREAD
  6. #include <boost/thread/thread.hpp>
  7. #undef threadbool
  8. #define threadbool 1
  9. #endif
  10. #endif
  12. using namespace std;
  14. #if threadbool
  15. boost::mutex mutexTraitement;
  16. #endif
  18. int next_plane(vector<bool> &indices,int k){
  19. for(int i=k+1;i<(int)indices.size();++i){
  20. if(!indices[i])return i;
  21. }
  22. for(int i=k-1;i>0;--i){
  23. if(!indices[i])return i;
  24. }
  25. return -10;
  26. }
  30. // ===================================================================
  31. template<class T>
  32. class erode_class{
  34. public:
  36. erode_class(T &vol1,T &vol2, int ord,int plan1):volume(vol1),volume2(vol2),ordre(ord),planstart(plan1){};
  38. void treatment(vector<bool> &indices){
  39. int k=next_plane(indices,planstart);
  40. const int dim1=volume.dim1(),dim2=volume.dim2(),dim3=volume.dim3();
  42. // Traitements ...
  44. }
  46. private:
  47. T &volume;
  48. T &volume2;
  49. int ordre;
  50. int planstart;
  52. };
  54. // =========================================================================
  55. template <class T,class TT>
  56. void GenericThreadedFunction_2Volumes(T &volume1,T &volume2,const size_t nb_threads,TT &Treatment_Type,int &planstart,vector<bool> &indices){
  57. volume2.resize(volume1.dim1(),volume1.dim2(),volume1.dim3());
  58. #if threadbool
  59. boost::thread_group threads1;
  60. size_t box_size=volume1.dim1();
  61. for (std::size_t n=0; n<nb_threads; ++n){
  62. size_t nb_plans=(int)((double)box_size/(double)nb_threads);
  63. if(n<box_size%nb_threads)nb_plans++;
  64. if(n>=box_size%nb_threads){
  65.  planstart=n*nb_plans+box_size%nb_threads;
  66.  }
  67. else {
  68.  planstart=n*nb_plans;
  69.  }
  70. threads1.create_thread(boost::bind(&TT::treatment,boost::ref(Treatment_Type),boost::ref(indices)));
  71. }
  72. threads1.join_all();
  73. #else
  74. planstart=0;
  75. Treatment_Type.treatment(indices);
  76. #endif
  77. }
  79. int main(int argc, char *argv[])
  80. {
  81. size_t nb_threads;
  82. #if threadbool
  83. nb_threads=boost::thread::hardware_concurrency();
  84. #else
  85. nb_threads=1;
  86. #endif
  88. slip::RegularVector3dField3d<double> volume1b;
  89. read_slip_data(volume1b,"volume_lif_00005.abe" );
  91. slip::Volume<double> volume1(volume1b.dim1(),volume1b.dim2(),volume1b.dim3()),volume2;
  92. slip::RegularVector3dField3d<double>::const_iterator iter1=volume1b.begin();
  93. slip::Volume<double>::iterator iter2=volume1.begin();
  94. for( ;
  95. iter1!=volume1b.end()&&
  96. iter2!=volume1.end();
  97. ++iter1,++iter2)
  98. (*iter2)=(*iter1)[0];
  100. int planstart=0,ordre=3;
  102. vector<bool> indices(volume1.dim1());
  103. erode_class<slip::Volume<double> > erosion1(volume1,volume2,ordre,planstart);
  104. GenericThreadedFunction_2Volumes(volume1,volume2,nb_threads,erosion1,planstart,indices);
  105. return 0;
  107. }

Reply

Sujets relatifs:

Leave a Replay

Make sure you enter the(*)required information where indicate.HTML code is not allowed