Multi-thread portable

Version imprimable

19/10/2005, 16h56
etranger

Multi-thread portable

Bonjour :)

Je developpe une application GTK portable, mon application est un chiffreur de fichier, elle doit donc effectuer des opperation assez longue, pour cela je shouait utiliser un thread supplementaire et ajouter un progress bar.
Ma question : y aurait il une fonction standard,donc portable pour gerer le mutli-thread ?
Merci d'avance :)
19/10/2005, 17h10
Franck.H

Bha y'a les fonctions de creation et de gestion des Threads fournit avec la GLib, ca tombe bien tu fait aussi du GTK et les deuxs sont etroitement liés :wink:
Et puis ca tombe bien, je cherche moi meme de la doc sur ce sujet car il me faut des Threads d'écoute de messages pour mon client IRC fait aussi en C/GTK donc ca va m'eviter de poster un message identique :wink:
19/10/2005, 17h21
etranger

Oui j'avais deja lu ca : http://www.gtk.org/faq/#AEN482
http://developer.gnome.org/doc/API/2.0/gdk/gdk-Threads.html
19/10/2005, 17h21
Franck.H

Heu sinon je viens de voir les Threads POSIX, cela doit etre portable Windows/Unixoïdes ! Voir ici : POSIX Threads Décidement, on trouve de plus en plus de choses sur ce site ... bravo Emmanuel :ccool:
19/10/2005, 17h58
Franck.H

Citation:

Envoyé par etranger

Oui j'avais deja lu ca : http://www.gtk.org/faq/#AEN482
http://developer.gnome.org/doc/API/2.0/gdk/gdk-Threads.html

Mais alors c'est quoi le problème ? Je vois pas vraiment ... suffit de lire, des Threads tu en créé autant que tu veut, si c'est un programme GTK faut juste faire en sorte de la debloquer pour qu'il puisse gérer des Threads supplémentaires donc endehors de la boucle principale de GTK, tout est dans les liens que tu m'a donné en fait ! C'est sur que des cours supplémentaires sont les bienvenus aussi :lol:

Par contre la question que je me pose, c'est dans mon cas, plusieurs Threads utiliseront la meme fonction qui vérifie en fait l'arrivée de nouveaux messages des serveurs sur lesquels l'utilisateur se connect ... cela ne pas pas de problèmes si plusieurs Threads utilisent la meme fonction ?

Merci pour vos lumières :wink:
19/10/2005, 18h19
etranger

Citation:

Mais alors c'est quoi le problème ?

Il n'y a pas vraiment de probleme, en fait je voulai savoir s'il y avait une solution standard (norm AINSI) donc autre que celle de Glib. apparaiment il n'en a pas.

Cependant encore un peu de doc (ou code) sur l'utilisation des thread de Glib (en Francais sa serait un must) serait la bien venue.

Une aute question : est ce que l'utilisation des pthread (ou un API thread sous Windows) poserait probleme a une application GTK ?
19/10/2005, 18h22
Franck.H

Citation:

Envoyé par etranger

Une aute question : est ce que l'utilisation des pthread (ou un API thread sous Windows) poserait probleme a une application GTK ?

Pour ce qui est de pthread à priori ca ne pose pas de problème, si tu regarde le 2° code source du 2° lien que tu as donné plus haut, tu peut le voir :wink:
19/10/2005, 18h29
etranger

a oui désolé , je m'en était déja rendu compte car j'ai essazer de compiler le code, mais je n'est pas l'entête pthread. en fait je voulai plutop demander si sa posait probléme au cas oû on modifirait làinterface a travers le thread (comme en Delphi avec la VCL).

Je croi donc que je vais opter pour glib. Merci pour vos réponces et bonne chance CSoldier :)

encor un petit lien : http://perso.univ-lr.fr/abouju/informatique/IUP2/thread/index.html
19/10/2005, 18h46
Emmanuel Delahaye

Citation:

Envoyé par etranger

je voulai savoir s'il y avait une solution standard (norm ANSI)

Non, mais il y a des solutions portables.
19/10/2005, 21h23
Franck.H

Je me pose une question !

Dans mon cas, plusieurs Threads utiliseront la meme fonction qui vérifie en fait l'arrivée de nouveaux messages des serveurs et channels sur lesquels l'utilisateur est connecté ... cela peut poser des problèmes si plusieurs Threads utilisent la meme fonction ? Comment faire pour bien gérer ce cas là ?
19/10/2005, 22h14
Emmanuel Delahaye

Citation:

Envoyé par CSoldier

Je me pose une question !

Dans mon cas, plusieurs Threads utiliseront la meme fonction qui vérifie en fait l'arrivée de nouveaux messages des serveurs et channels sur lesquels l'utilisateur est connecté ... cela peut poser des problèmes si plusieurs Threads utilisent la meme fonction ? Comment faire pour bien gérer ce cas là ?

Utiliser la même fonction, c'est pas un problème. La question se pose pour les données. Tant qu'on travaille sur des copies (paramètres formels) ou des données appartenant à chaque thread (via une adresse), tout va bien. Les choses se compliquent si 2 threads lisent ou écrivent le même bloc de données (globales, statiques, ...). A ce moment là, il faut mettre en oeuvre des mécanismes de protection comme expliqué dans mon article.
20/10/2005, 11h02
Franck.H

Ok, bon ca ne devrait pas poser de problème car la fonction ne travaillera qu'avec une copie d'une donnée d'apres le paramètre qui lui est passée, à partir de là une ptite lecture de données, une lecture de reception de message ... si le message est a afficher bah on traite l'affichage vers une zone de texte, si le message est pas exemple un Ping, bah on répond directement par un Pong !! Ce genre de chose, mais ca s'arrete là !
20/10/2005, 16h49
Franck.H

J'ai une derniere petite question !

Quand on créé un Thread, il tourne continuellement jusqu'à la fin de l'application ou bien ... ? Car là mes Thread doivent tourner à interval réguliers style toutes les secondes, quelques chose dans ce genre, mais étant donné qu'il utilisent tous la meme fonction, comment les mettre en pause etc... ?

Hé oui tant que j'y pense, comment detruire un Thread ?

Merci pour ces précisions :wink:

PS: C'est ma premiere fois avec les Threads alors bon :oops:
20/10/2005, 17h06
Emmanuel Delahaye

Citation:

Envoyé par CSoldier

J'ai une derniere petite question !

Quand on créé un Thread, il tourne continuellement jusqu'à la fin de l'application ou bien ... ?

Si il n'y a pas de fonction de suspension dans la boucle, oui. Dans un système coopératif (Linux 2.4 ?) ce genre de manip est interdite, car elle prend 100% du CPU. Sinon (Système préemptif comme Windows), elle est peu recommandée, sauf pour la tâche de fond (de priorité la plus basse)

Citation:

Car là mes Thread doivent tourner à interval réguliers style toutes les secondes, quelques chose dans ce genre, mais étant donné qu'il utilisent tous la meme fonction, comment les mettre en pause etc... ?

Windows : Sleep()
Linux : sleep(), usleep()

attention, ce ne sont pas les mêmes unités...

Citation:

Hé oui tant que j'y pense, comment detruire un Thread ?

La suppression se fait quand on quitte la tâche (return).

Un flag en mémoire partagée peut suffire à commander la fin de la boucle d'un thread.

Sinon, il existe une fonction d'auto destruction (pthread_exit()) et une fonction de destruction à distance (pthread_kill())

Moi j'ai ca pour la fonction utilisée par les Threads (Threads qui doivent etre permanent tant que la connection vers un serveur ou channel est etablie:

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
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
void * foncs_messages_monitoring (void *p_data)
{
   int numbytes;
   int current_page;
   char s_buffer[MAX_BUF_SIZE];
   GtkTextBuffer *p_buffer = NULL;
   GtkTextIter i_end;
   gpointer p_st_data;
   gpointer p;
   _tab_srv_s *p_tmp_tab_srv_s = NULL;
   _tab_chan_s *p_tmp_tab_chan_s = NULL;
   _tab_type_e *tab_type_e = NULL;
 
#if defined (WIN32)
   SOCKET tmp_sock;
#endif
 
 
   /* -------------------------------------------
      On recupere le numero de la page courrante
   */
 
   current_page = gtk_notebook_get_current_page (
                     GTK_NOTEBOOK (main_win_s->p_notebook));
 
 
 
 
   /* ---------------------------------------
      Recupere l'element de la liste chainee
   */
 
   if (p_data != NULL)
   {
      p = p_data;
      tab_type_e = (_tab_type_e *)p;
 
 
      /* On recupere la structure des widget */
      p_st_data = g_list_nth_data (p_tab_srv_chan_list, current_page);
 
      switch (*tab_type_e)
      {
         case TAB_TYPE_SERVER:
         {
            p_tmp_tab_srv_s = p_st_data;
            tmp_sock = p_tmp_tab_srv_s->sock;
         }
         break;
 
         case TAB_TYPE_CHANNEL:
         {
            p_tmp_tab_chan_s = p_st_data;
            tmp_sock = p_tmp_tab_chan_s->sock;
         }
         break;
 
         default:
            break;
      }
   }
   else
   {
      return NULL;
   }
 
   if (p_tmp_tab_srv_s == NULL && p_tmp_tab_chan_s == NULL)
   {
      return NULL;
   }
 
 
 
 
   /* -------------------------------------
      Reception et traitement des messages
   */
 
   /* Reception d'un message */
   if ((numbytes = recv (tmp_sock,
                         s_buffer,
                         MAX_BUF_SIZE,
                         0)) < 0)
   {
      return NULL;
   }
 
 
   /* Verification du message. Si c'est un PING, on repond par un PONG.
      Sinon, on affiche le message a l'ecran. */
   s_buffer[numbytes] = '\0';
 
   if (strncmp (s_buffer, "PING", 4) == 0)
   {
      strncpy (s_buffer, "PONG", 4);
 
      /* Envoie de la reponse du PING */
      if ((numbytes = send (tmp_sock,
                            s_buffer,
                            strlen (s_buffer),
                            0)) < 0)
      {
         memset (&s_buffer, 0, sizeof (s_buffer));
         return NULL;
      }
 
      memset (&s_buffer, 0, sizeof (s_buffer));
   }
   else
   {
      /* Recupere le buffer de la zone de texte */
      switch (*tab_type_e)
      {
         case TAB_TYPE_SERVER:
         {
            p_buffer = gtk_text_view_get_buffer (
                           GTK_TEXT_VIEW (p_tmp_tab_srv_s->p_text_view));
         }
         break;
 
         case TAB_TYPE_CHANNEL:
         {
            p_buffer = gtk_text_view_get_buffer (
                           GTK_TEXT_VIEW (p_tmp_tab_chan_s->p_text_view));
         }
         break;
 
         default:
            break;
      }
 
 
      /* Envoie du message */
      gtk_text_buffer_get_end_iter (p_buffer, &i_end);
      gtk_text_buffer_insert (p_buffer, &i_end, s_buffer, -1);
 
      memset (&s_buffer, 0, sizeof (s_buffer));
   }
 
 
 
 
   return NULL;
}

Moi dans ma pensée, c'est que le Thread utilise la fonction, la quitte, puis dès que son delais d'attente (que j'ai pas fait d'ailleur) est passé bah il rentre à nouveau dans la fonction etc... N'est-ce pas de cette façon que cela fonctionne ? Je suis quelque peu perdu dans tout ca :lol:

20/10/2005, 20h59
Médinoc

Quand tu crées un thread, il commence à la fonction que tu lui as passée, puis se termine lorsque celle-ci retourne (ou si le thread est détruit par un autre moyen). Une fois terminé, c'est comme si le thread n'existait plus: tout ce qu'on peut faire normalement avec son identifiant, c'est vérifier qu'il est terminé.

Pour que la fonction du thread soit à nouveau exécutée, il faut à nouveau démarrer explicitement un nouveau thread sur cette fonction-là.

Généralement, un thread qui doit durer tout au long du programme boucle sur une fonction d'attente (select(), wait(), mq_recv(), accept(), getchar(), etc.) pendant que les autres threads bouclent eux aussi sur une autre fonction d'attente, comme le terminal, etc.
Ensuite, pour terminer un thread, une variable globale déclarée en volatile peut suffire à terminer la boucle, mais sous unixoïde c'est rare (il faut s'arranger pour que la fonction sur laquelle ils attendent finisse par retourner).

Sous Windows, un programme se termine quand son dernier thread se termine (à une subtilité vicieuse près, le main() doit se terminer par un appel à ExitThread() au lieu de return, sinon c'est tout le processus qui se termine).
Sous Posix, je ne sais pas si c'est le cas ou non.

Question subsidiaire : que se passe-t-il quand un processus multithreadé posix reçoit un signal? quel thread le reçoit? (déjà, est-ce qu'un thread particulier le reçoit, ou bien est-ce simplement le thread qui était en train de s'exécuter à ce moment-là, etc.)
20/10/2005, 21h13
Franck.H

Ok, mais là le problème, c'est que je dois surveiller l'arriver de nouveaux messages des serveurs et channels sur lesquelles l'utilisateur se connect (c'est un client IRC que je suis en train de faire) ! Mais le truc c'est que tous les Threads utiliseront la meme fonction, donc je pense que si un Thread boucle sur une fonction, les threads qui attendent, bah ils entrent jamais non ? Car si un thread sort de la fonction, et qu'il n'existe plus, je ne vois pas l'interet d'en faire ! Donc je cherche des infos, des astuces, etc... en prennant en compte que je suis assez debutant avec les Threads ! En fait, c'est ma premiere fois :lol:

En fait, ce que je veut, c'est une fonction qui boucle tout le temps du programme pour vérifier les messages et y repondent dans le cas d'un PING par exemple pour pas que le serveur clos la session et ce genre de chose ! Meme si c'est que 1 Thread qui fait ca pour toutes les connections serveur et channels mais il me faut une fonction de monitoring de ce genre ! Du moins je pense mais c'est ce qui me parait le plus logique en l'occurence !

A savoir aussi que je developpe certes sous Windows mais le programme sera aussi porté sous Linux

Donc si quelqu'un peut me donner des conseils, astuces etc... je suis plus que preneur :wink: :wink: Ca fait quand meme 2 jours que je planche que là dessus, donc si je pouvais avoir une reponse censsée et qui m'aide vraiment ce serais super !

Merci d'avance :wink:
20/10/2005, 21h50
Médinoc

Mais il n'y a absolument aucun problème pour utiliser la même fonction en même temps dans N threads!
Le problème, c'est pour les données: Il ne faut pas que les threads touchent aux mêmes données, aux mêmes fichiers, aux mêmes variables globales et/ou statiques, et à des fonctions non-thread-safe.

Tu peux très bien avoir N threads qui attendent N ressources différentes ave cla même fonction!
20/10/2005, 21h55
Franck.H

Citation:

Envoyé par Médinoc

Mais il n'y a absolument aucun problème pour utiliser la même fonction en même temps dans N threads!
Le problème, c'est pour les données: Il ne faut pas que les threads touchent aux mêmes données, aux mêmes fichiers, aux mêmes variables globales et/ou statiques, et à des fonctions non-thread-safe.

Tu peux très bien avoir N threads qui attendent N ressources différentes ave cla même fonction!

Oui mais comment faire !!!!!! C'est ca que je veut savoir, deja vu le manque de doc sur les reseau et autre threads, et quand y'a c'est tres sommaire et non accompagné de ptits exemples etc... !!! Moi je fournit un code mis j'aimerais bien qu'on me dise ce qui va pas, ce que je dois changer, ce que je peut améliorer, etc... sinon j'avancerais jamais !

Car pour moi, si je boucle dans la fonction par exemple avec un truc du style while (1) ..., bah tu crois que les autres threads arrivont a utiliser la fonction ?

Pour ce qui touche aux données, le seul truc c'est que les threads accederont a une liste chainees qui dans chaque element aura une adresse d'une structure allouée dynamiquement, structure dans laquelle se trouve des infos sur le serveur, socket sur lequelle travailler, etc...

A part un ptit affichage dans une zone de texte mais sinon c'est tout, enfin tu peut le voir sur ma fonction au bas de la page 1 :wink:
Enfin bref, c'est presque un appel au secours que je fait là :lol:
20/10/2005, 22h05
Médinoc

Citation:

Envoyé par CSoldier

Car pour moi, si je boucle dans la fonction par exemple avec un truc du style while (1) ..., bah tu crois que les autres threads arrivont a utiliser la fonction ?

OUI. C'est le principe des threads, ils s'exécutent EN MÊME TEMPS. contrairement à de la programmation événementielle mono-threadée.

Citation:

Pour ce qui touche aux données, le seul truc c'est que les threads accederont a une liste chainees qui dans chaque element aura une adresse d'une structure allouée dynamiquement, structure dans laquelle se trouve des infos sur le serveur, socket sur lequelle travailler, etc...

1° Ils ont chacun leur propre liste, ou bien est-elle partagée ? (c'est à toi de décider cela selon le fonctionnement de ton programme). S'ils ont chacun la leur, pas de problème.
2° Si elle est partagée, est-ce qu'ils la modifient ? Si ils ne font que la lire, aucun problème. S'ils peuvent la modifier, tu dois utiliser un mutex (EXclusion MUTuelle) pour les empêcher de toucher à la liste en même temps (il ne faut pas qu'un thread la lise pendant qu'un autre la modifie)
20/10/2005, 22h10
Franck.H

Citation:

Envoyé par Médinoc

Citation:

Envoyé par CSoldier

Car pour moi, si je boucle dans la fonction par exemple avec un truc du style while (1) ..., bah tu crois que les autres threads arrivont a utiliser la fonction ?

OUI. C'est le principe des threads, ils s'exécutent EN MÊME TEMPS. contrairement à de la programmation événementielle mono-threadée.

Citation:

Pour ce qui touche aux données, le seul truc c'est que les threads accederont a une liste chainees qui dans chaque element aura une adresse d'une structure allouée dynamiquement, structure dans laquelle se trouve des infos sur le serveur, socket sur lequelle travailler, etc...

1° Ils ont chacun leur propre liste, ou bien est-elle partagée ? (c'est à toi de décider cela selon le fonctionnement de ton programme). S'ils ont chacun la leur, pas de problème.
2° Si elle est partagée, est-ce qu'ils la modifient ? Si ils ne font que la lire, aucun problème. S'ils peuvent la modifier, tu dois utiliser un mutex (EXclusion MUTuelle) pour les empêcher de toucher à la liste en même temps (il ne faut pas qu'un thread la lise pendant qu'un autre la modifie)

En fait c'est une liste unique, chaque element correspond a une connection sur un serveur ou un channel avec toutes les infos possible, compris une reference du thread lui meme (au cas où on sait jamais) et aucune modification ne se fait au sein des données, que de la lecture !
20/10/2005, 22h40
Franck.H

En fait, les seuls changement qui se feront dans la liste, c'est au moment d'une nouvelle connection et ou deconnection ... donc dans ce cas, ajout ou suppression d'un element dans la liste mais sinon c'est tout, et là ce ne sera pas les thread qui le feront (du moins pour la connection, pour la deco c'est pas encore sur, je pense que si le thread se termine, c'est dans le cas de mon programme qu'une connection est finie donc à priori un thread pourra lancer la fonction qui se charge de ca !)

D'ailleurs, je pensais a faire qu'un seul Thread qui serais lancé au debut du programme jusqu'à la fin et qui boucle sur toute la liste et verifie les messages de chaque serveurs et channels ! Ce ne serais pas une meilleure solution que de faire un thread par connection ?
20/10/2005, 23h59
Médinoc

eh bien, pour la façon, je ne sais pas trop.
Mais s'il y a modification de la liste pendant que les threads tournent, il faudra utiliser de la synchonisation si ceux-ci sont capables de parcourir la liste.

Que font tes threads exactement? lire uniquement les informations qui LEUR sont relatives, ou bien font-ils des lectures complètes de la liste?

S'ils ne lisent chacun qu'un seul élément, ils ne sont même pas forcés d'accéder au chaînage (utiliser une structure chaînée contenant une structure de données et passer au thread un pointeur vers la structure de données interne).
Sinon, cela promet d'être plus compliqué.

Sinon, il est également possible de faire tout un serveur en monothreadé, voir le topic "un ou plusieurs threads" vers la fin (solutions monothreadées avec select())
21/10/2005, 00h04
Franck.H

Citation:

Envoyé par Médinoc

eh bien, pour la façon, je ne sais pas trop.
Mais s'il y a modification de la liste pendant que les threads tournent, il faudra utiliser de la synchonisation si ceux-ci sont capables de parcourir la liste.

En fait, ils ne lisent que l'element qui les concernent !

Citation:

Envoyé par Médinoc

Que font tes threads exactement? lire uniquement les informations qui LEUR sont relatives, ou bien font-ils des lectures complètes de la liste?

Ils lisent certaines données qui leur sont relatives et receptions de messages des serveurs distants et des channels, ils peuvent egalement envoyer de message du style une reponse a un PING d'un serveur mais ca s'arrete là !

Citation:

Envoyé par Médinoc

S'ils ne lisent chacun qu'un seul élément, ils ne sont même pas forcés d'accéder au chaînage (utiliser une structure chaînée contenant une structure de données et passer au thread un pointeur vers la structure de données interne).

Pour ce on est d'accord, mais de toutes facons, le code va encore changer, je doit réorganiser certaines choses et mieux le faire !

Citation:

Envoyé par Médinoc

Sinon, il est également possible de faire tout un serveur en monothreadé, voir le topic "un ou plusieurs threads" vers la fin (solutions monothreadées avec select())

Moi je fait un client IRC tout simplement, pas de serveur donc pas pour moi :wink:

Je pense quand meme que faire un seul thread qui gere toutes les connections serais moins lours a gérer mais là, c'est presque une question existentielle que je me pose :lol:
21/10/2005, 00h07
Médinoc

Citation:

Moi je fait un client IRC tout simplement, pas de serveur donc pas pour moi

Oups! oubli.
J'avais oublié que les clients aussi pouvaient avoir plusieurs connexions (enfin, eux aussi peuvent marcher en mono-threadé avec select() dans ce cas-là)
21/10/2005, 00h16
Franck.H

Quel est le role de la fonction selec ? Elle me serais utile si je fait un thread unique pour toutes les connections ?
21/10/2005, 07h03
Médinoc

oui.

select() permet de tester des descripteurs de fichiers OU des sockets (et rien d'autre) pour savoir notamment s'il y a des données à lire ("disponible en lecture") ou si la connexion a été fermée de l'autre coté ("condition d'exception")

En testant smultanément "en lecture" tous les sockets ouverts, tu peux ensuite traiter les requêtes sur les sockets l'un après l'autre, puis à nouveau attendre que des données arrivent, etc.

Une boucle d'attente sur select() est l'idéal pour une application réseau mono-threadée, ou une application qui gère tout le réseau dans un seul thread.

Sous Windows, il y a également d'autres solutions non portables, mais toutes sont basées là-dessus.
21/10/2005, 11h22
Franck.H

Y'a pas des exemples d'utilisation de cette fonction, et voir meme plus ? Parceque, c'est pas que je n'y met pas de la volonté mais je ne suis pas plus avancé là, meme si cette discussion n'a pas du tout été stérile mais j'aurais aimé voir du concret pour voir comment on utilise tout ca !
Et puis ca commence sérieusement à me gaver, ca fait que le 3° jours que je suis là dessus :evil:

En tous je te remercie quand meme Medinoc :wink:

Bon, j'ai un peu remanié mon code, fait du menage, ré-arangées certaines choses, voici le code de la fonction utilisé par le thread (j'ai opté pour un thread unique):

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
void * foncs_messages_monitoring (void *p_data)
{
   int numbytes;
   char s_buffer[MAX_BUF_SIZE];
   GtkTextBuffer *p_buffer = NULL;
   GtkTextIter i_end;
   gpointer p_st_data;
   _tab_s *p_tmp_tab_s = NULL;
   GList *p_list = NULL;
 
 
   /* -------------------------------------
      Reception et traitement des messages
   */
   int i;
   while (1)
   {
      G_LOCK (p_tab_srv_chan_list);
 
      if (p_tab_srv_chan_list != NULL)
      {
         /* On boucle sur toute la liste chainee */
         i = 0;
         for (p_list = g_list_first (p_tab_srv_chan_list);
              p_list;
              p_list = p_list->next)
         {
            /* On recupere la structure des widget */
            p_st_data = g_list_nth_data (p_list, i);
            p_tmp_tab_s = p_st_data;
 
 
            /* Reception d'un message */
            if ((numbytes = recv (p_tmp_tab_s->sock,
                                  s_buffer,
                                  MAX_BUF_SIZE,
                                  0)) < 0)
            {
               perror ("recv");
            }
            else
            {
               /* Verification du message. Si c'est un PING, on repond
                   par un PONG. Sinon, on affiche le message a l'ecran. */
               s_buffer[numbytes] = '\0';
 
               if (strncmp (s_buffer, "PING", 4) == 0)
               {
                  strncpy (s_buffer, "PONG", 4);
 
                  /* Envoie de la reponse du PING */
                  if ((numbytes = send (p_tmp_tab_s->sock,
                                       s_buffer,
                                       strlen (s_buffer),
                                       0)) < 0)
                  {
                     perror ("send");
                  }
                  memset (&s_buffer, 0, sizeof (s_buffer));
               }
               else
               {
                  gdk_threads_enter ();
 
                  /* Recupere le buffer de la zone de texte */
                  p_buffer = gtk_text_view_get_buffer (
                                 GTK_TEXT_VIEW (p_tmp_tab_s->p_text_view));
 
 
                  /* Affichage du message */
                  gtk_text_buffer_get_end_iter (p_buffer, &i_end);
                  gtk_text_buffer_insert (p_buffer, &i_end, s_buffer, -1);
 
                  gdk_threads_leave ();
 
                  memset (&s_buffer, 0, sizeof (s_buffer));
               }
            }
 
 
            i++;
         }
 
 
         p_list = NULL;
         p_st_data = NULL;
         p_tmp_tab_s = NULL;
      }
 
      G_UNLOCK (p_tab_srv_chan_list);
      sleep (1);
   }
 
 
 
 
   return NULL;
}

Je voulais bloquer l'acces à la liste au programme tant que le thread n'aurait pas fini sont tour de boucle en utilisant les fonctions de GDK: G_LOCK et G_UNLOCK mais j'ai effet de bord assez bizzard à la compilation, voici un message d'erreur en les utilisant ainsi dans le code:

Code:

G_LOCK (p_tab_srv_chan_list);

et le message:

Citation:

1134 C:\Documents and Settings\CSoldier\Mes documents\Sauvegardes\Programmation\MOPIC\mopic_foncs.c `g__p_tab_srv_chan_list_lock' undeclared (first use in this function)

8O 8O bizzard me direz-vous mais je ne vois pas quoi faire contre ca en fait donc je me suis un peu attarder sur les fonctions de bloquage et debloquage de phtread. J'ai un peu regardé le site d'Emmanuel qui traite justement de ce sujet mais moi contrairement a lui, je doit bloqué l'acces à la liste complete car lorsqu'une connection est en phase de s'etablir, ca ajoute un nouvel element dans la liste avec ecriture des infos etc...

Comment je peut bloquer ma liste complete ?

21/10/2005, 19h01
Médinoc

1°) Pour select, il y a un exemple qui est en train de prendre forme dans un topic voisin (j'ai pu le titre exact, mais il y a le mot Tchat dedans)
2°) Tu utilises les threads posix, alors pouquoi ne pas utiliser les fonctions de mutex posix ? (cherche du coté de pthread_mutex_create(), pthread_mutex_lock())
21/10/2005, 19h05
Franck.H

Deja cherché du coté des fonctions POSIX mais j'y pige que dal' ! J'ai meme vu un code sur le site d'Emmanuel qui traite de ce sujet mais moi je doit bloquer une liste complete donc je veut des expliquations ! Ca fait juste 2 jours que je bute sur ce sujet ..... :evil:
Merci pour le topic, vais essayer de le retrouver, en espérant que ca puisse m'aider au moins un peu :!:
21/10/2005, 19h12
Franck.H

Est-ce que le développement d'un serveur et d'un client se font de la meme maniere ? Car sinon, bah non ca me sert pas a grand chose, de plus je veut pas betement recopier mais je veut des explication claires et précises, l'ordre des choses, comment utiliser telle ou telle fonction, comment bloquer l'acces à ma liste et la débloquer (POSIX ou GDK, peu importe mais quelques chose qui marche) ... moi sur le net je ne trouve rien de rien ou bien c'est tres tres maigre :cry: :cry: :cry:
21/10/2005, 19h17
Médinoc

Généralement, un serveur et un client sont complètement différents, mais comme ton client a plusieurs sockets actifs, son comportement devient très similaire à celui d'un serveur sans socket d'écoute.

Bref, en excluant toute la partie avec le socket d'écoute, il reste:
* Le maintient d'une liste de sockets actifs, plus les deux fd_set (lecture et exception)
* Le bouclage avec attente sur select()
* Le traitement de chaque client dont l'appel à FD_ISSET renvoie une valeur non-nulle. (partie qui n'est pas encore dans le topic concerné, mais devrait s'y trouver sous peu)
21/10/2005, 19h21
Franck.H

Ok mais j'aimerais qu'on me dise "sur mon code que j'ai fournit sinon ca sert à rien que j'en fournisse un" les parties que je doit modifier parceque pour le moment je suis paumé et ca m'ennerve ! Et bordel qu'on m'explique comment utiliser ces fonctions !

Merci en tous de ta patience avec moi :lol: :lol:
21/10/2005, 19h44
Médinoc

Ben en fait ton code, qui utilise des onfctions gtk en plus, j'ai du mal à le comprendre...

Par contre, j'ai l'impression qu'il est tout sauf non-bloquant puisque tu essaies de lire chaque socket l'un après l'autre, avant de vérifier qu'il y a bien des données dedans... (et puis, je n'ai vu aucun appel à select(), même pas une ébauche...)
21/10/2005, 19h50
Franck.H

Citation:

Envoyé par Médinoc

Ben en fait ton code, qui utilise des onfctions gtk en plus, j'ai du mal à le comprendre...

Par contre, j'ai l'impression qu'il est tout sauf non-bloquant puisque tu essaies de lire chaque socket l'un après l'autre, avant de vérifier qu'il y a bien des données dedans... (et puis, je n'ai vu aucun appel à select(), même pas une ébauche...)

Bah GTK on s'enfout, le seul moment où j'en utilise dans cette fonction, c'est pour afficher des message recu dans la zone de texte adequate.
Bah j'ai une boucle while car le thread doit durer tout au long de la vie du programme, et à chaque tour de boucle (while) il parcours la liste (for) qui correspond à chaque connections effectives ! Et dans chaque tour de boucle for, il regarde si un nouveau message est arrivé, si c'est un PING il repond pas un PONG pour eviter la deconnection de la part du serveur distant !

Pour le select oui je sais, c'est normal, je ne sais pas comment l'utiliser et encore pire, je ne sait pas à quel endroit ou quel moment l'utiliser !
Pourquoi je demande de l'aide à ton avis ? :lol: :lol:
21/10/2005, 20h03
Médinoc

OK, alors on va essasyer un petit algo simple, et on ne va faire des tests qu'en lecture (tant pis pour la fermeture intempestive d'un socket par le correspondant. Après tout, on est client, c'est à nous de le fermer, et au serveur de le garder ouvert)

Déjà, il nous faut un fd_set pour select() (un seul suffira pour l'instant)
Ensuite, il nous faut une liste complète de tous les sockets connectés (dans ta liste chaînée par exemple)

Il me semble que le fd_set doit être régénéré à chaque fois, donc à chaque itération de la boucle:
{
on remplit le fd_set à partir de la liste:
On commence par l'initialiser à zéro.
on ajoute chaque socket de la liste au fd_set avec la mecro FD_SET

Ensuite, on appelle select(). en lui passant l'adresse de notre fd_set dans le premier pointeur (celui pour tester "en lecture");

Puis, on parcourt à nouveau la liste: Pour chaque socket de la liste,
{ on regarde si on a reçu quelque chose dessus avec la macro FD_ISSET qui renvoit une valeur non-nulle s'il y a quelque chose à lire (bref, on fait un "if(FD_ISSET(liste[n]))")
Et si le test est vrai, alors là seulement on peut faire un read() ou un recv() pour lire les données reçues, et si c'est un PING, répondre PONG
}
}

voilà, c'est à peu près ainsi que ça fonctionne...

Bon ok, on avance à ptit pas :lol:
J'ai fait d'apres ce que tu m'as dit, voici le code de ma fonction avec les ajouts:

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
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
void * foncs_messages_monitoring (void *p_data)
{
   int numbytes;
   char s_buffer[MAX_BUF_SIZE];
   GtkTextBuffer *p_buffer = NULL;
   GtkTextIter i_end;
   gpointer p_st_data;
   _tab_s *p_tmp_tab_s = NULL;
   GList *p_list = NULL;
   fd_set fd_read;
 
   /* -------------------------------------
      Reception et traitement des messages
   */
   int i;
   int ret;
   while (1)
   {
      FD_ZERO (&fd_read);
 
      for (p_list = g_list_first (p_tab_srv_chan_list);
           p_list;
           p_list = p_list->next)
      {
         p_st_data = g_list_nth_data (p_list, i);
         p_tmp_tab_s = p_st_data;
 
         FD_SET (p_tmp_tab_s->sock, &fd_read);
      }
 
 
      p_list = NULL;
      p_st_data = NULL;
      p_tmp_tab_s = NULL;
 
 
      if ((ret = select (0, &fd_read, NULL, NULL, NULL)) < 0)
      {
         perror ("select");
      }
      else if (p_tab_srv_chan_list != NULL)
      {
         /* On boucle sur toute la liste chainee */
         i = 0;
         for (p_list = g_list_first (p_tab_srv_chan_list);
              p_list;
              p_list = p_list->next)
         {
            /* On recupere la structure des widget */
            p_st_data = g_list_nth_data (p_list, i);
            p_tmp_tab_s = p_st_data;
 
 
            /* Reception d'un message */
            if (FD_ISSET (p_tmp_tab_s->sock, &fd_read))
            {
               if ((numbytes = recv (p_tmp_tab_s->sock,
                                     s_buffer,
                                     MAX_BUF_SIZE,
                                     0)) < 0)
               {
                  perror ("recv");
               }
               else
               {
                  /* Verification du message. Si c'est un PING, on repond
                      par un PONG. Sinon, on affiche le message a l'ecran. */
                  s_buffer[numbytes] = '\0';
 
                  if (strncmp (s_buffer, "PING", 4) == 0)
                  {
                     strncpy (s_buffer, "PONG", 4);
 
                     /* Envoie de la reponse du PING */
                     if ((numbytes = send (p_tmp_tab_s->sock,
                                           s_buffer,
                                           strlen (s_buffer),
                                           0)) < 0)
                     {
                        perror ("send");
                     }
 
                     memset (&s_buffer, 0, sizeof (s_buffer));
                  }
                  else
                  {
                     gdk_threads_enter ();
 
 
                     /* Recupere le buffer de la zone de texte */
                     p_buffer = gtk_text_view_get_buffer (
                                    GTK_TEXT_VIEW (p_tmp_tab_s->p_text_view));
 
 
                     /* Affichage du message */
                     gtk_text_buffer_get_end_iter (p_buffer, &i_end);
                     gtk_text_buffer_insert (p_buffer, &i_end, s_buffer, -1);
 
 
                     gdk_threads_leave ();
 
                     memset (&s_buffer, 0, sizeof (s_buffer));
                  }
               }
            }
 
            i++;
         }
 
 
         p_list = NULL;
         p_st_data = NULL;
         p_tmp_tab_s = NULL;
      }
 
 
      sleep (1);
   }
 
 
 
 
   return NULL;
}

Mais bon, j'ai un plantage à coup sûr !

21/10/2005, 20h32
Médinoc

Ben la structure générale, ça a l'air d'être ça...

Tu as quel genre de plantage?
Tu as essayé de faire tourner le prog sous un debugguer ou simplement d'afficher des messages sur stderr pour voir où ça plantait? (enfin, si tu as un stderr)

PS: Tu devrais te faire une fonction pour l'affichage (et la tester) pour pouvoir afficher des messages gtk plus simplement dans ton code... Surtout pour le débogage...
21/10/2005, 20h39
Franck.H

Le problème apparement viens du select !

Fuseau horaire GMT +2. Il est actuellement 05h27.