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
| #include <stdio.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>
#include <sys/sem.h>
main()
{
/* Initialisation des variables. */
...
int pid;
int tube[2];
struct sembuf operation;
char chaine1[1 /* Un tableau pour un seul élément ??? */], chaine2[2];
...
while (1)
{
...
/* Création d'un ensemble de sémaphores. */
semid = semget( (key_t)999, 1, IPC_CREAT | IPC_EXCL | 0660 );
/*
Concernant la clef, t'as le droit d'utiliser la macro
IPC_PRIVATE qui te garantit l'unicité de ton ipc
Inutile si l'ipc doit être accessible par 2 programmes distincts
mais utile dans le cas d'une communication père-fils...
*/
/* Initialisation d'un Mutex. */
semctl( semid, 0, SETVAL, 1);
...
pid = fork();
if(pid == -1){ perror("fork"); exit(1); }
else if(pid == 0) /* Le fils. */
{
/* Réquisition du Mutex. */
operation.sem_num = 0;
operation.sem_op = -1;
operation.sem_flg = 0;
semop (semid, &operation, 1);
/*
Me semble que si tu veux être sûr que le père attende l'écriture du fils,
tu ne dois faire descendre le sémaphore à 0 que quand
le fils est prêt, c'est à dire qu'il a déjà écrit...
*/
...
/* Libération du Mutex. */
operation.sem_num = 0;
operation.sem_op = 1;
operation.sem_flg = 0;
semop (semid, &operation, 1);
/* Le père tuera le mutex. */
/* tube anonyme créé par le fils. */
pipe(tube);
/* Le fils écrit au père. */
close(tube[0]);
write(tube[1], "A", 1);
write(tube[1], "BC", 2);
// Attention tu n'as pas écrit le '\0'...
close(tube[1]);
exit(0);
}
else /* Le père. */
{
printf("\nLe pere.\n");
/* Attente de l'écriture du fils par le père, contrôlée par la Mutex. */
operation.sem_num = 0;
operation.sem_op = 0;
operation.sem_flg = 0;
semop (semid, &operation, 1);
close(tube[1]);
/* Le père lit le fils. */
read(tube[0], chaine1, 1);
printf("%s\n", chaine1);
read(tube[0], chaine2, 2);
printf("%s\n", chaine2);
/* Attention, le fils a écrit {'A'} puis {'A', 'B'}. Nulle part il n'a écrit le '\0'. Donc tes chaines 1 et 2 n'en sont pas => crash probable ... */
close(tube[0]);
wait();/* Le père attend la fin du fils, de plus, le tube anonyme fils-père est définitivement détruit. */
/* Destruction du Mutex créé par le fils. */
semctl( semid, 0, IPC_RMID, 0);
}//fin du père
}//fin du while
exit(0);
} |
Sémaphore : "sem_op = 0" n'arrive pas à faire attendre le processus père.
Répondre avec citation
Envoyé par siro75
Partager