[Sémaphores] modèle producteur consommateur

[bobo41]

Bonjour à tous, j'ai vraiment du mal avec les sémaphores un peu d'aide serai le bien venu, j'ai cherché partout mais j'ai pas réussi à trouvé
Voilà l'énoncé du programme :
Un processus P crée des bonbons et un processus C en prend. Ils ont une vitrine en commun où sont placés les bonbons.
Les 2 processus tournent indéfiniment.
La vitrine ne peut pas être touché par plus d'une personne à la fois.
Si la vitrine est pleine, le processus P arrête de créer des bonbons.
Si la vitrine est vide, le processus C arrête de prendre des bonbons.
Soit M le nombre max de bonbons que la vitrine peut contenir.

La structure du projet est la suivante :
PC-ini.c : crée les sémaphores
P.c : le producteur qui rajoute un bonbon quand la vitrine n'est pas pleine
C.c : le consommateur qui prend un bonbon quand la vitrine n'est pas vide

J'ai fait PC-ini.c

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
 
#include<stdio.h>
#include<stdlib.h>
#include<errno.h>
#include<sys/types.h>
#include<sys/ipc.h>
#include<sys/sem.h>
 
#define M 25
 
union semun
{
    int val;
    struct semid_ds *buf;
    unsigned short *array;
} arg;
 
int main (void)
{
    key_t key;
    int semid;
 
    key = ftok("/tmp", 'P');
 
    if(key == -1)
    {
        perror("ftok fails ");
        exit(1);
    }
 
    semid = semget(key,3,0600|IPC_CREAT);
    if(semid == -1)
    {
        perror("semget fails ");
        exit(2);
    }
 
    arg.val = M;
    semctl(semid,0,SETVAL,arg); /* nombre de place libre dans la vitrine */
    arg.val = 1;
    semctl(semid,1,SETVAL,arg); /* assure l'exclusion mutuelle */
    arg.val = 0;
    semctl(semid,2,SETVAL,arg); /* nombre de bonbon dans la vitrine */
 
    exit(0);
}

pour le P.c j'ai un soucis, je sais pas comment faire pour qu'il ne fasse rien si la vitrine est pleine

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
 
#include<stdio.h>
#include<stdlib.h>
#include<sys/ipc.h>
#include<errno.h>
#include<sys/sem.h>
#include<sys/types.h>
 
#define M 25
 
int main (void)
{
    int semid, n;
    key_t key;
    struct sembuf in[2] = {{1,-1,0},{2,1,0}}; /* quand on entre on met sem1 à 0  et on incrémente le nombre de bonbon dans la vitrine */
    struct sembuf out = {1,1,0}; /* quand on sort on met sem1 à 1*/
 
    key = ftok("/tmp", 'P');
    if(key == -1)
    {
        perror("ftok fails ");
        exit(1);
    }
 
    semid = semget(key,0,0);
    if(semid == -1)
    {
        perror("semget fails ");
        exit(2);
    }
 
    srand(time(NULL));
 
    while(1)
    {
        n = 1 + rand()%3;
        semop(semid,in,2);
        printf("Nombre de bonbon %d\n", semctl(semid,0,GETVAL,arg.array)); 
		/* je prense pouvoir récupérer arg.array pour tester si c'est égal à M mais je sais pas comment faire pour récupérer cette structure */
        sleep(n);
        semop(semid,&out,1);
    }
}

J'ai pas fait le C.c mais je pense que c'est le même principe que P.c donc une fois que j'aurai compris comment faire avec P ce sera bon, j'espère.

[Médinoc]

J'ai du mal à voir pourquoi tu as besoin d'un troisième sémaphore pour l'exclusion mutuelle, quand tu n'as qu'un seul producteur et un seul consommateur.

Pour faire que le producteur ne fasse rien quand la vitrine est pleine, c'est simple: Tu le fais attendre sur le sémaphore "places libres".

PS: pourquoi déclarer arg comme variable globale?