Discussion :

[nacrotic]

Bonjour

Je suis en train de développer un projet pour l’école et je me retrouve face a un problème de fonctionnement que je n'arrive pas a cerner.

Mon problèmes est que j'ai une section de code qui s'execute plus souvent qu'elle ne devrais.

Voila mon code en l'etat actuelle (compilé sans erreur avec gcc -Wall -pedantic -lpthread -g main.c)

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
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/sem.h>
#include <sys/msg.h>
#include <string.h>
#include <pthread.h>
 
#define NB_CLE 17
#define NB_VOITURE 50
 
typedef struct cars voiture_t;
 
struct cars {
	int current_queue;
	int prio;
	int dest;
	pthread_t thread_voiture;
};
 
void erreurFin(const char* msg);
void clean_queue();
void init_voiture();
static void * fn_voiture(void * p_data);
static int get_random (int max);
 
int i;
int j = 1;
key_t cle[NB_CLE];
int msgid[NB_CLE];
 
 
int main (int argc, char *argv[]) {
    j++;
    printf("\n%d\n", j);
	/*Fil de message*/
	for (i=0; i<NB_CLE; i++) {
		if ((cle[i] = ftok(argv[0],i)) == -1) {
			erreurFin("Impossible de créer la cle");
		}
		/*printf("i : %d\ncle[%d] : %d\n", i, i, cle[i]);*/
		if ((msgid[i] = msgget(cle[i],IPC_CREAT  | IPC_EXCL | 0600)) == -1) {
			erreurFin("Impossible de créer la file de message");
		}
	}
 
	for (i=0; i<NB_CLE; i++) {
		printf("cle : %d\tid : %d\n", (int) cle[i], msgid[i]);
	}
 
	init_voiture();
	/*FIN CORPS*/
 
	/*Nettoyage*/
	clean_queue();
	return 0;
}
 
/********************************************************************
 *                                                      Fonctions globales                                              *
 ********************************************************************/
void erreurFin(const char* msg) {
    perror(msg);
    exit(1);
}
 
void clean_queue() {
    for (i=0; i<NB_CLE; i++) {
        if ((msgctl(msgid[i],IPC_RMID,NULL)) == -1) {
            printf("i : %d\nmsgid[%d] : %d\n", i, i, msgid[i]);
            erreurFin("Impossible de supprimer la file");
        }
    }
}
 
static int get_random (int max)
{
   double val;
 
   val = (double) max * rand ();
   val = val / (RAND_MAX + 1.0);
 
   return ((int) val);
}
 
/********************************************************************
 *                                              Fonctions gestion voiture                                       *
 ********************************************************************/
void init_voiture() {
    voiture_t tab_voiture[NB_VOITURE];
 
    switch(fork()) {
        case -1:
            erreurFin("Impossible de créer le processus voiture");
            break;
        case 0:
            printf("\n\t\tCeci ne doit etre lu qu'une fois\n");
            for (i=0 ; i<NB_VOITURE ; i++) {
                printf("Création de la voiture %d\n", i);
                if ((pthread_create(&tab_voiture[i].thread_voiture,NULL, fn_voiture, (void *) i)) != 0) {
                    erreurFin("Impossible de créer une voiture");
                }
            }
            printf("\n\tCeci ne doit etre lu qu'une fois\n");
            for (i=0 ; i<NB_VOITURE ; i++) {
                pthread_join(tab_voiture[i].thread_voiture,NULL);
            }
            break;
        default :
            usleep(0);
    }
}
static void * fn_voiture(void * p_data) {
    int nb = (int) p_data;
    int entree = get_random (8);
    int sortie = get_random (8);
    FILE* fichier = NULL;
    char fi[2];
    sprintf(fi, "%d", nb);
 
    while (sortie == entree)
        sortie = get_random (8);
    fichier = fopen(fi, "a+");
    if (fichier != NULL) {
        fprintf(fichier, "Je suis la voiture %d\n\tentree = %d\n\tsortie = %d\n", nb, entree, sortie);
        fclose(fichier);
    }
    else /*printf("Je suis la voiture %d\n\tentree = %d\n\tsortie = %d\n", nb, entree, sortie);*/
        printf("erreur");
    pthread_exit(0);
}

Ce code ne devrais s'executer qu'une seule fois, j'ai rajouter 2 printf pour mettre en valeur le comportement annormal.

voila ce que j'aimerais avoir a l'ecran

J = 2


cle : 32 id : 20840448
[...]
cle : 268435488 id : 21364752
Ceci ne doit etre lu qu'une fois
Création de la voiture 0
[...]
Création de la voiture 49
Ceci ne doit etre lu qu'une fois

Ma j'obitent la meme chose repetter 50 ou 60 fois dans un ordre anarchique

Je cherche une solution pour eviter que tout le code (main() compris) soit repetter
Avez vous une idée ?

Merci d'avance pour votre aide

[quetzacoatl]

Bonjour,

Dans votre fonction "init_voiture()" vous castez i qui une variable globale entière en tant que pointeur (void*), c'est peut-être cela qui est la cause de ces ennuis.
Vous pourriez peut-être également éviter d'utiliser tant de variables globales, surtout pour la variable i qui n'est utilisé que dans vos boucles, mais après ce n'est qu'un avis personnel.

[nacrotic]

Pour le cast de la variable i je me suis inspiré du tutoriel : http://franckh.developpez.com/tutoriels/posix/pthreads/ ou il cast la variable i exactement de la même manière.
Pour les variables globales effectivement j'ai fait ca très vite et cela peut largement être amélioré. Cependant ca n'explique pas l'appel en boucle de main()

Résolue
Le problème venais de l'utilisation de la primitive fork, fork exécute la totalité du code (et donc la partie initialisation) ce qui appelais en boucle le main().