Problème lors de l'écriture en continue

**_SamSoft_** · 31/10/2007, 23h39

Bonjour, je developpe un petit programme sans prétention (qui doit même pas être beau d'ailleurs

) qui permet d'incrementer simultanement la valeur i de 8 boucles (en utilisant pthread). Ca sert à rien mais après avoir vu une vidéo d'un gars de chez Intel parlant des thread, j'ai voulu essayer.

Voilà où j'en suis :

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
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
145
146
147
148
149
 
#include <stdio.h>
#include <stdlib.h>
#include "io.h"
#include "pthread.h"
#define MAX 100
void print(char *nbr, int value);
void *boucle1(void *p_data);
void *boucle2(void *p_data);
void *boucle3(void *p_data);
void *boucle4(void *p_data);
void *boucle5(void *p_data);
void *boucle6(void *p_data);
void *boucle7(void *p_data);
void *boucle8(void *p_data);
int main(void)
{
 pthread_t thread_boucle1, thread_boucle2;
 pthread_t thread_boucle3, thread_boucle4;
 pthread_t thread_boucle5, thread_boucle6;
 pthread_t thread_boucle7, thread_boucle8;
 /* first part */
 pthread_create(&thread_boucle1, NULL, boucle1, NULL);
  pthread_create(&thread_boucle2, NULL, boucle2, NULL);
  pthread_join(thread_boucle1, NULL);
  pthread_join(thread_boucle2, NULL);
 /* next part */
  pthread_create(&thread_boucle3, NULL, boucle3, NULL);
  pthread_create(&thread_boucle4, NULL, boucle4, NULL);
  pthread_join(thread_boucle3, NULL);
  pthread_join(thread_boucle4, NULL);
 /* next part */
  pthread_create(&thread_boucle5, NULL, boucle5, NULL);
 pthread_create(&thread_boucle6, NULL, boucle6, NULL);
  pthread_join(thread_boucle5, NULL);
  pthread_join(thread_boucle6, NULL);
  /* last part */
  pthread_create(&thread_boucle7, NULL, boucle7, NULL);
 pthread_create(&thread_boucle8, NULL, boucle8, NULL);
  pthread_join(thread_boucle7, NULL);
  pthread_join(thread_boucle8, NULL);
 /* the end */
 pause("PRESS ENTER");
  return 0;
}
void print(char *nbr, int value)
{
  char nameOfFile[16] = "thread.txt";
 FILE *myFile = fopen(nameOfFile, "w");
 if(myFile != NULL)
 {
  fprintf(myFile, "%s %i\n", nbr, value);
  fprintf(stdout, "(%s) %i\n", nbr, value);
    fflush(stdout);
 }
 else
 {
  fprintf(stderr, "Erreur : myFile = NULL");
 }
 fclose(myFile);
}
void *boucle1(void *p_data)
{
 char nbr = '1';
 int i =0;
 for(i=0;i<MAX;i++)
 {
   print(&nbr, i);
 }
 (void) p_data;
 return NULL;
}
void *boucle2(void *p_data)
{
  char nbr = '2';
 int i = 0;
 for(i=0;i<MAX;i++)
 {
   print(&nbr, i);
 }
 (void) p_data;
 return NULL;
}
void *boucle3(void *p_data)
{
  char nbr = '3';
  int i = 0;
 for(i=0;i<MAX;i++)
 {
   print(&nbr, i);
 }
 (void) p_data;
 return NULL;
}
void *boucle4(void *p_data)
{
  char nbr = '4';
  int i = 0;
 for(i=0;i<MAX;i++)
 {
   print(&nbr, i);
 }
 (void) p_data;
 return NULL;
}
void *boucle5(void *p_data)
{
  char nbr = '5';
  int i = 0;
 for(i=0;i<MAX;i++)
 {
   print(&nbr, i);
 }
 (void) p_data;
 return NULL;
}
void *boucle6(void *p_data)
{
  char nbr = '6';
  int i = 0;
 for(i=0;i<MAX;i++)
 {
   print(&nbr, i);
 }
 (void) p_data;
 return NULL;
}
void *boucle7(void *p_data)
{
  char nbr = '7';
  int i = 0;
 for(i=0;i<MAX;i++)
 {
   print(&nbr, i);
 }
 (void) p_data;
 return NULL;
}
void *boucle8(void *p_data)
{
  char nbr = '8';
  int i = 0;
 for(i=0;i<MAX;i++)
 {
   print(&nbr, i);
 }
 (void) p_data;
 return NULL;
}

io.h contient juste des prototypes des fonctions tels que fclean et pause (ma fonction pause

)

Le problème, je vais vous l'expliquer.

Je veux mettre ce qu'on voit à l'écran dans un fichier. Je ne cherche pas une fonction toute faite mais un moyen d'y parvenir. En effet, chacune de mes 8 boucles, incremente i et l'affiche à l'écran sous la forme :

Code :

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

1
2
 
fprintf(stdout, "(%s) %i", numeroDuThread, i);

Or je voudrais enregistrer tout ca dans un fichier, 3 solutions s'offrent à moi :

1) Trouver une fonction qui permet d'enregistrer le contenu de la console dans un fichier. (j'aime pas ca)

2) Utiliser des variables globales pour permettre une écriture en continue (c'est mal vu que j'ai d'autres choix)

3)Poster ici pour qu'on m'aide.

Je vous laisse réfléchir quand à mon choix.

Merci d'avance

PS: Si le code est améliorable, faites m'en part mais sachez que c'est un projet que j'ai fais sur un coup de tête et je suis depuis seulement 1h30 dessus

(les thread c'est amusant ! )

**granquet** · 01/11/2007, 00h23

tu sais que quand on se met à copier//coller du code en numérotant des variables ça veux dire qu'on as raté un truc ?
ensuite, quand on accède à des ressources partagés de manière concurrente (et avec des opérations non atomique), on prend un minimum de soin de protéger leur accès.

tu as un peu de lecture qui t'attend: http://emmanuel-delahaye.developpez.com/pthreads.htm

**Sve@r** · 01/11/2007, 00h48

Envoyé par _SamSoft_

Je veux mettre ce qu'on voit à l'écran dans un fichier. Je ne cherche pas une fonction toute faite mais un moyen d'y parvenir. En effet, chacune de mes 8 boucles, incremente i et l'affiche à l'écran sous la forme :

Code :

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

1
2
 
fprintf(stdout, "(%s) %i", numeroDuThread, i);

Or je voudrais enregistrer tout ca dans un fichier, 3 solutions s'offrent à moi :

1) Trouver une fonction qui permet d'enregistrer le contenu de la console dans un fichier. (j'aime pas ca)

2) Utiliser des variables globales pour permettre une écriture en continue (c'est mal vu que j'ai d'autres choix)

3)Poster ici pour qu'on m'aide.

J'ai dû rater un truc mais il me semble que tu veux enregistrer dans un fichier un truc que t'écris à l'écran => solution 4) ce que t'écris à l'écran écris le aussi dans le fichier...

**_SamSoft_** · 01/11/2007, 11h56

Pour Dark_Ebola :

Je n'ai pas besoin de protéger leur acces car chacun utilise sa propre variable i.

Je vais me mettre à la lecture approfondie de ce site car je l'avais parcouru hier mais sur les grandes lignes.

En gros on pourrait assimiler mon programmer à un petit logiciel permettant d'émuler 2personnes en train de calculer de 0 à 100 en même temps.
En effet, on a d'abord : boucle1-2 puis 3-4 ... jusqu'à 7-8.

Je voulais le programmer pour voir la différence entre avec thread et sans thread, j'ai d'ailleurs fait un autre programme qui est une suite de huit boucles. Le programme avec thread a finit au moins 20secondes avant l'autre quand MAX vallait 10 000. (Je peux vous dire que j'ai glandé un peu devant mon pc avant d'avoir le résultat)

Pour Sve@r:

Merci

Mais c'est bien ce que je fais :

fonction : print :

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
17
 
void print(char *nbr, int value)
{
  char nameOfFile[16] = "thread.txt";
 FILE *myFile = fopen(nameOfFile, "w");
 if(myFile != NULL)
 {
  fprintf(myFile, "%s %i\n", nbr, value);
  fprintf(stdout, "(%s) %i\n", nbr, value);
    fflush(stdout);
 }
 else
 {
  fprintf(stderr, "Erreur : myFile = NULL");
 }
 fclose(myFile);
}

Le problème c'est que le fichier est recréé à chaque fois

**Sve@r** · 01/11/2007, 11h59

Envoyé par _SamSoft_

Pour Sve@r:

Merci

Mais c'est bien ce que je fais :

fonction : print :

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
17
 
void print(char *nbr, int value)
{
  char nameOfFile[16] = "thread.txt";
 FILE *myFile = fopen(nameOfFile, "w");
 if(myFile != NULL)
 {
  fprintf(myFile, "%s %i\n", nbr, value);
  fprintf(stdout, "(%s) %i\n", nbr, value);
    fflush(stdout);
 }
 else
 {
  fprintf(stderr, "Erreur : myFile = NULL");
 }
 fclose(myFile);
}

Le problème c'est que le fichier est recréé à chaque fois

Ah oui, c'est que ça !!!
Tu ouvres ton fichier en mode "w" => il est réécrasé à chaque ouverture
Solution 1 => tu l'ouvres une fois avant les thread et chaque thread ne fait qu'écrire
Solution 2 => tu l'ouvres en mode "a"

**_SamSoft_** · 01/11/2007, 12h03

Merci la solution avec le "a" fonctionne super bien

Mais la première solution je l'avais trouvé mais il fallait une variable globale pour la mettre en place (enfin 2 vars globales).

'a' - Ouvre en écriture seule; place le pointeur de fichier à la fin du fichier file. Si le fichier nÌexiste pas, on tente de le créer.

Je m'étais arreté à la ligne où l'on parle de w

Sinon pourquoi m'affiche t'il :

8thread.txt 99
1thread.txt 0
2thread.txt 0
1thread.txt 1
2thread.txt 1
2thread.txt 2
1thread.txt 2
...

Au lieu de :

(8) 99
(1) 0
(2) 0
...

Voilà le code de la fonction print :

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
void print(char *nbr, int value)
{
  char nameOfFile[16] = "thread.txt";
 FILE *myFile = fopen(nameOfFile, "a");
 if(myFile != NULL)
 {
  fprintf(myFile, "%s %i\n", nbr, value);
  fprintf(stdout, "(%s) %i\n", nbr, value);
    fflush(stdout);
 }
 else
 {
  fprintf(stderr, "Erreur : myFile = NULL");
 }
 fclose(myFile);
}

Merci d'avance

**Sve@r** · 01/11/2007, 19h46

Envoyé par _SamSoft_

Sinon pourquoi m'affiche t'il :

8thread.txt 99
1thread.txt 0
2thread.txt 0
1thread.txt 1
2thread.txt 1
2thread.txt 2
1thread.txt 2
...

Au lieu de :

(8) 99
(1) 0
(2) 0
...

Voilà le code de la fonction print :

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
void print(char *nbr, int value)
{
  char nameOfFile[16] = "thread.txt";
 FILE *myFile = fopen(nameOfFile, "a");
 if(myFile != NULL)
 {
  fprintf(myFile, "%s %i\n", nbr, value);
  fprintf(stdout, "(%s) %i\n", nbr, value);
    fflush(stdout);
 }
 else
 {
  fprintf(stderr, "Erreur : myFile = NULL");
 }
 fclose(myFile);
}

Merci d'avance

Ben parce que la variable "nbr" que tu reçois en paramètre ne contient pas le fameux '\0' qui en fait une chaîne et qui est nécessaire à tout traitement ultérieur (hé oui, je viens de relire ton code et nulle part tu ne l'y as mis et comme en C rien ne se fait tout seul...).
Donc la fonction "printf()" part de ce "nbr" qu'elle reçoit et affiche tout ce qu'il y a jusqu'à ce qu'elle trouve un '\0' qu'elle trouve heureusement un peu plus loin (sinon tu partais en torche)...

Sinon étant donné que l'affichage est le même (mais qu'il part dans 2 endroits différents), pourquoi tu crées pas une fonction destinée à afficher dans un flux et que t'appellerais 2 fois (une avec MyFile et l'autre avec stdout) ???

**_SamSoft_** · 01/11/2007, 20h08

Eh ben, un simple oubli \0 est c'est le bordel sur la console

Alors pour le "double" affichage et bien c'est tout simple, chez moi, lors de l'affichage de toutes les valeurs, les premières sont effacés (dans ma console) pour faire place aux autres, je ne sais pas au bout de combien de lignes ont effaces celles du dessus mais ca arrive dans mon programme car 80 000 (si MAX vaut 10 000) ne vont pas rester sur la console

Donc j'enregistre le tout sur un fichier pour garder une trace de tout cela

Merci pour tout