+ Répondre à la discussion
Affichage des résultats 1 à 2 sur 2
  1. #1
    Invité de passage
    Homme Profil pro
    Étudiant
    Inscrit en
    juin 2012
    Messages
    3
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations professionnelles :
    Activité : Étudiant
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : juin 2012
    Messages : 3
    Points : 0
    Points
    0

    Par défaut [Sémaphores] modèle producteur consommateur

    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.

  2. #2
    Expert Confirmé Sénior
    Avatar de Médinoc
    Homme Profil pro
    Développeur informatique
    Inscrit en
    septembre 2005
    Messages
    24 346
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 31
    Localisation : France

    Informations professionnelles :
    Activité : Développeur informatique
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : septembre 2005
    Messages : 24 346
    Points : 34 751
    Points
    34 751

    Par défaut

    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?
    SVP, pas de questions techniques par MP. Surtout si je ne vous ai jamais parlé avant.

    "Aw, come on, who would be so stupid as to insert a cast to make an error go away without actually fixing the error?"
    Apparently everyone.
    -- Raymond Chen.
    Traduction obligatoire: "Oh, voyons, qui serait assez stupide pour mettre un cast pour faire disparaitre un message d'erreur sans vraiment corriger l'erreur?" - Apparemment, tout le monde. -- Raymond Chen.

Liens sociaux

Règles de messages

  • Vous ne pouvez pas créer de nouvelles discussions
  • Vous ne pouvez pas envoyer des réponses
  • Vous ne pouvez pas envoyer des pièces jointes
  • Vous ne pouvez pas modifier vos messages
  •