pthread et C++

Version imprimable

17/01/2011, 10h23
Alpha573

pthread et C++

Bonjour,
Dans le cadre d'un rojet, je suis amener à utiliser des threads.
J'ai trouvé la librairie Pthread en C, et j'ai vu que l'on pouvait l'adapter à C++.
Existe-t-il d'autres possibilités ? Il faut que mon programme tourne sur Linux.
Merci
17/01/2011, 12h00
Emmanuel Deloget

pthread est la librairie de thread système ; a ma connaissance, toute autre librairie sera soit basée dessus (comme boost.thread), soit bâtie autour d'un système qui sera très similaire voire identique (comme... comme... mince, je n'ai pas d'exemple).

A noter que gcc sait nativement quoi faire avec pthread.

Il ne sert à rien, à mon humble avis, de vouloir trouver une autre solution : c'est la librairie système, donc autant l'utiliser. Construire un wrapper C++ autour de pthread est relativement simple, et il en existe des tonnes (dont le déjà mentionné boost.thread).

Cf. http://blog.emptycrate.com/node/270 pour une base (relativement) correcte. On peut faire bien mieux, bien sûr.
17/01/2011, 13h11
Alpha573

Ok merci beaucoup.
Bonne journée !

J'ai commencé un wrapper en m'inspirant fortement de ce que j'ai trouvé ici :
http://blog.nicoleau-fabien.net/inde...ns-un-object-C

Mais j'ai un problème à la déclaration de la structure pthread_t dans mon header :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
#ifndef PTHREAD_H
#define PTHREAD_H
#include <pthread.h>
 
//Définition du processus
typedef void* (*threadProcess)(void*);
 
//Définition de la structure d'un thread
typedef struct
{
    threadProcess process;
    void *args;
    bool *running;
    bool *finished;
} threadParams;
 
////////////////////////////////////////////////////////////////////////////
// Librairie utilisant les pthread du C pour faire un objet thread simple //
////////////////////////////////////////////////////////////////////////////
class PThread
{
    private:
   ///////////////
   // ATTRIBUTS //
   ///////////////
 
   //Handle du thread
   pthread_t* handle;
 
   //S'il est actif
   bool running;
 
   //S'il est fini
   bool finished;
 
    //////////////
   // FONCTIONS //
   ///////////////
   //Fonction threadée
   static void* threadStartup(void*);
 
   public:
 
   //Constructeur
   PThread();
 
   //Destructeur
   ~PThread();
 
   //Prparer et lancer un thread
   bool exec(threadProcess, void*);
 
   //Terminer un thread
   bool terminate();
 
   //Le thread tourne ?
   bool isRunning();
 
   //Le thread est terminé ?
   bool isFinished();
 
   //Join le thread
   void* join();
 
   //Récupérer l'handle du thread
   pthread_t* getHandle();
};
 
#endif // PTHREAD_H

Et ce que me sors GCC :

Code:

error: ISO C++ forbids declaration of 'pthread_t' with no type

Je vous met aussi le cpp :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
#include <iostream>
#include "../include/PThread.h"
using namespace std;
 
/**Constructeur*/
PThread::PThread()
{
    this->finished=false;
    this->running=false;
    this->handle=new pthread_t;
}
 
/**Destructeur*/
PThread::~PThread()
{
    this->terminate();
    pthread_join(*this->handle, NULL);
    delete this->handle;
}
 
/** Prépare et lance un thread.
Enregistre la fonction à exécuter et ses arguments,
Puis crée un thread et lance la fonction */
bool PThread::exec(threadProcess monThreadProcess, void* args)
{
    //Test si le thread ne tourne pas déjà
    if(!this->isRunning())
    {
        threadParams tp;
        tp.process=monThreadProcess;
        tp.args;
        tp.running=&this->running;
        tp.finished=&this->finished;
 
        if(pthread_create (this->handle, NULL, PThread::threadStartup, (void*)&tp<0)
        {
            return false;
        }
    }
    return false;
}
 
/**Fonction threadée. Dans cette fonction, le thread est préparé, et ensuite la fonction à
exécuter est lancée*/
void* PThread::threadStartup(void* targs)
{
    threadParams* tp=(threadParams*)targs;
    bool* running=tp->running;
    bool* finished=tp->finished;
    threadProcess process=tp->process;
    void* args=tp->args;
    *running=true;
    pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, NULL);
    pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS, NULL);
    process(args);
    *running = false;
    *finished = true;
    pthread_exit(0);
}
 
/**Arrête le thread */
bool PThread::terminate()
{
    //Si le thread tourne
    if(this->isRunning())
    {
        if(pthread_cancel (*this->handle)!=0)
        {
            return false;
        }
        this->running=false;
        return true;
    }
    return false;
}
 
/**Donne l'état du thread*/
bool PThread::terminate()
{
    return this->running;
}
 
/**Dis si le thread est fini*/
bool PThread::isFinished()
{
    return this->finished;
}
 
/**Attends la fin du thread et libère la mémoire*/
void* PThread::join()
{
    void* ret;
    pthread_join(*this->handle, &ret);
    return ret;
}
 
/**Retourne l'handle d'un thread*/
pthread_t* PThread::getHandle()
{
    return this->handle;
}

Merci ! :?

17/01/2011, 17h34
fregolo52

Nommer tes fichiers exactement comme les nom des API sytème ne me semble pas très malin !!! :oops:*

A 1 '_' près tu définissais le define system :
toi : #ifndef PTHREAD_H
pthread de linux : #ifndef _PTHREAD_H
17/01/2011, 17h50
JolyLoic

Suivant l'usage que tu veux faire des threads, certaines alternatives plus haut niveau que les pthreads peuvent être intéressants (ou pas). Je pense par exemple à TBB ou à openMP.

J'ai réussi à regler le problème en changeant le nom de la classe.
En revanche, je n'arrive pas à éxecuter une fonction avec le code suivant :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
void* process(void*);
 
 
int main(void) {
   const unsigned int nbThreads = 5;
   ThreadSiteMaths* threads[nbThreads];
 
   // Création des threads, puis exécution
   for(unsigned int i = 0; i<nbThreads; i++) {
      threads[i] = new ThreadSiteMaths();
      threads[i]->exec(process,(void*)i);
   }
   // Attente de la fin des threads et libération mémoire
   for(unsigned int i = 0; i<nbThreads; i++) {
      threads[i]->join();
      delete(threads[i]);
   }
   return 0;
}
 
// Cette fonction compte de 0 à (<arg>+1)*4
void* process(void* arg) {
   unsigned int numThread=(unsigned int)arg;
   unsigned int until = (numThread+1)*4;
   for(unsigned int i = 0 ; i < until ; i ++) {
      cout << "Thread " << numThread << " : " << i << endl;
      sleep(1);
   }
}

Le compilateur me sort cette erreur :

Code:

/home/alchimiste/PTut/PThread/main.cpp|46|erreur: cast from ‘void*’ to ‘unsigned int’ loses precision

En fait, l'erreur vient du cast de void*, il n'y a pas d'autres solutions ?
Merci.

18/01/2011, 11h24
Luc Hermitte

boost::thread ? (futurement std::thread) C'est bien pour dégager quantité de ces problèmes de typage inhérents aux API C.

@Emmanuel, Solaris a un truc à lui pour le threading en plus de pthread dans mes souvenirs.
18/01/2011, 11h32
Alpha573

Avec boost, ça serait plus simple ?
La prise en main est rapide ?
18/01/2011, 13h34
Emmanuel Deloget

Citation:

Envoyé par Luc Hermitte

boost::thread ? (futurement std::thread) C'est bien pour dégager quantité de ces problèmes de typage inhérents aux API C.

@Emmanuel, Solaris a un truc à lui pour le threading en plus de pthread dans mes souvenirs.

C'est vrai ; ceci dit, pthread est également dispo sur cette plateforme (et encapsule dans ce cas spécifique la librairie thread de Solaris). La plupart des "vieux Unix propriétaires" (Solaris, SCO Unix, voire d'autres) ont une librairies de thread spécifiques, mais pthread existe pour la plupart de ces plateformes sous la forme d'une librairie d'encapsulation.

Pour plus d'informations sur les librairies disponibles, cf. http://www.humanfactor.com/pthreads/posix-threads.html
19/01/2011, 11h56
Alpha573

Ok merci beaucoup, je vais essayer de me débrouiller.
Mais j'ai toujours ce problème de cast...
19/01/2011, 12h09
jabbounet

Citation:

Envoyé par Luc Hermitte

boost::thread ? (futurement std::thread) C'est bien pour dégager quantité de ces problèmes de typage inhérents aux API C.

@Emmanuel, Solaris a un truc à lui pour le threading en plus de pthread dans mes souvenirs.

je confirme, solaris propose nativement deux interfaces de threading (posix et la sienne)

Citation:

Envoyé par Alpha573

Mais j'ai toujours ce problème de cast...

Les casts entre types pointeurs et type scalaires sont dangereux (au mieux). Si tu veux stocker un int dans un pointeur, tu peux, au choix :

* utiliser une union:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
 
union thread_param
{
  void* as_pointer;
  int as_value;
};
 
thread_param tp;
 
tp.as_value = i;
threads[i]->exec(process,tp.as_pointer);
 
void* process(void* arg) {
  thread_param tp;
  tp.as_pointer = arg;
  int num_thread = tp.as_value;
  ...
}

Ou utiliser, si il est supporté sur ta plateforme, le type intptr_t, qui est un type entier qui garanti sizeof(intptr_t) == sizeof(T*) quelque soit T. intptr_t devrait être intégré dans le standard à venir C++1x, et il existe déjà dans le standard C99 supporté par de nombreux compilateurs, y compris gcc et (partiellement) Visual C++ 2010.

Le type est défini dans <stdint.h> (C99) ou dans <cstdint> (dans le namespace std, Visual C++ 2010, versions plus récentes de g++) ou <tr1/cstdint> (g++ 4.3 ; dans le namespace std::tr1).

Et si tu ne trouve intptr_t nulle part, voilà un "petit truc rigolo" :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
 
namespace bits
{
  template <class T>
  struct same_size_ptr
  { static const bool value = (sizeof(T) == sizeof(T*)); };
 
  template <class T>
  struct inner
  { typedef typename T::type type; };
 
  template <> struct inner<char> { typedef char type; };
  template <> struct inner<short> { typedef short type; };
  template <> struct inner<int> { typedef int type; };
  template <> struct inner<long> { typedef long type; };
  template <> struct inner<long long> { typedef long long type; };
  template <> struct inner<unsigned char> { typedef unsigned char type; };
  template <> struct inner<unsigned short> { typedef unsigned short type; };
  template <> struct inner<unsigned int> { typedef unsigned int type; };
  template <> struct inner<unsigned long> { typedef unsigned long type; };
  template <> struct inner<unsigned long long> { typedef unsigned long long type; };
 
  template <bool cond, class T1, class T2>
  struct select { };
 
  template <class T1, class T2>
  struct select<true,T1,T2>
  { typedef typename T1::type type; };
 
  template <class T1, class T2>
  struct select<false,T1,T2>
  { typedef typename T2::type type; };
 
  template <class T1, class T2>
  struct helper
  {
    typedef typename select<
      same_size_ptr<
        typename inner<T1>::type
      >::value,
      inner<T1>,
      inner<T2>
     >::type type;
  };
 
  typedef
    helper<
      helper<
        helper<
          helper<
            char,
            short
          >,
          int
        >,
        long
      >,
      long long // ou ton type int64, selon ta plateforme
    >::type basic_intptr_t;
 
  typedef
    helper<
      helper<
        helper<
          helper<
            unsigned char,
            unsigned short
          >,
          unsigned int
        >,
        unsigned long
      >,
      unsigned long long // ou ton type int64, selon ta plateforme
    >::type basic_uintptr_t;
}
 
typedef ::bits::basic_intptr_t my_intptr_t;
typedef ::bits::basic_uintptr_t my_uintptr_t;

19/01/2011, 17h39
Luc Hermitte

Citation:

Envoyé par Alpha573

Avec boost, ça serait plus simple ?
La prise en main est rapide ?

Je la trouve plus simple que pthread.
Enfin, c'est une vision personnelle, j'ai du mal avec les API C qui baladent des codes de retour.
Le plus complexe est son installation. Et potentiellement dans ton cas : apprivoiser à la volée bind et function.
23/01/2011, 10h51
Alpha573

Merci à tous pour vos réponses.
FInalement j'utilise pthread directement sans wrapper.

J'ai trouvé la solution à mon cast, il faut en fait déclarer une structure qui contiendra les arguments. Caster de void* vers la structue ne pose alors pas de problèmes.
En espérant que celà puisse aider des gens qui ont eu le même problème que moi.

Merci encore ! :D
28/01/2011, 21h25
Joel F

Citation:

Envoyé par Alpha573

En espérant que celà puisse aider des gens qui ont eu le même problème que moi.

on continuera a preconiser std::thread oui :aie: