Problème lors de l'écriture en continue

Version imprimable

Bonjour, je developpe un petit programme sans prétention (qui doit même pas être beau d'ailleurs :aie:) 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:

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:

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 ! )

01/11/2007, 00h23
granquet

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
01/11/2007, 00h48
Sve@r
Citation:
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:

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

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:

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 :(

Citation:
Envoyé par _SamSoft_
Pour Sve@r:

Merci :) Mais c'est bien ce que je fais :

fonction : print :
Code:

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"

Merci la solution avec le "a" fonctionne super bien :D Mais la première solution je l'avais trouvé mais il fallait une variable globale pour la mettre en place (enfin 2 vars globales).

Citation:

'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 :aie:

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:

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 :D

Citation:
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:

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 :D
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) ???

01/11/2007, 20h08
_SamSoft_

Eh ben, un simple oubli \0 est c'est le bordel sur la console :aie:
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 :D
Donc j'enregistre le tout sur un fichier pour garder une trace de tout cela :)

Merci pour tout :king:
01/11/2007, 20h54
Sve@r

Citation:

Envoyé par _SamSoft_

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

Ben comment te dire... tu oublies un élément de repérage donc les fonctions peuvent plus se repérer...:bug:
01/11/2007, 20h55
_SamSoft_

Merci encore :)