Forum Programmation.c Sémaphore en C

Posté par . Licence CC by-sa
Tags : aucun
-3
23
déc.
2016

Bonjour,
On nous a demandé de programmer en C un modèle Allocateurs de ressources en C : on a un tableau de ces ressources , et N processus qui veulent utiliser chacun une ressource .La demande ce fait l’aide d’une fonction Allouer qui lui renvoie le numéro de la ressource qui lui a été affectée. Le processus doit libérer la ressource à la fin de son travail à l’aide de la procédure Restituer. Le prof nous demande de faire un jeu d'essai avec au minimum 3 processus . Voila mon code pour le moment

            #include<stdio.h>
            #include<stdlib.h>
            #include<sys/types.h>
            #include<unistd.h>
            #include<sys/wait.h>
            #include<string.h>
            #include<sys/sem.h>        /* semget, semctl, semop */
            #include<sys/ipc.h>        /* ftok   */
            #include<sys/shm.h>
            #include <stdlib.h>        /* malloc */
            #include <stdio.h>         /* perror, printf */
            #include <errno.h>         /* errno */
            /*Clés des sémaphores*/
            #define SNlibre 13 // Sémaphore qui represente le nombre de machine libre
            #define Mutex 12  // Sémaphore d'exlusion mutuelle entre les deux procedure allouer et restituier

            /*Les variables globales*/
            #define N 3//nombre de processus
            typedef enum boul
             {true, false} boul;

             boul booleen ;
             boul mdispo[3]={faux};//toutes les machine sont disponible au début
            /********P(m)********/
            int P (int m)
            {
            struct sembuf operation; 
            operation.sem_num = 0;   
            operation.sem_op = -1;   
            operation.sem_flg = 0;
            return semop (m , &operation , 1); // effectue 1 seule opération sur le sémaphore
            }
            /********V(m)********/
            int V (int m)
            {
            struct sembuf operation; 
            operation.sem_num = 0;   
            operation.sem_op = +1;   
            operation.sem_flg = 0;
            return semop (m , &operation , 1); // effectue 1 seule opération sur le sémaphore
            }
            /***Fonction Allouer*****/
            /*Cette fonction retourne le numero de la machine alloué*/
            int Allouer()
            {
                int num =0;
                P(Mutex);
                P(SNlibre);
                while (mdispo[num]==true)    num++;
                mdispo[num]=false;
                V(Mutex);
                return num;
            }
            /***Procedure Restituer*****/
            /*Procedure pour restituer la machine de numéro "num" après son usage*/
            void Restituer (int num)
            {
                P(Mutex) ;
                mdispo[num] = false ;
                V(Mutex) ;
                V(Nlibre) ;
            }

            int main()
            {
                pid_t pidFils[5];
        int i,j;
         for (i=0; i<2; i++) {//4 proessus 
            pid_t pid = fork();
            if  (pid ==0) {
                Allouer(j);
                printf("Le processus %d utilise la machine numero %d \n\n",pid,j);

                Restituer(j);

            } else {
                pidFils[i] = pid;
            }
        }

        for (i=0; i<4; i++) {
            int status;
            waitpid(pidFils[i], &status, 0);
            // printf("pidFils[%d] = %d (%d)\n", i, pidFils[i], status);
        }
                return 0;
            }

La je suis bloqué ! je ne sais pas si ce que j'ai fait est juste et qu'est ce que je doit mettre entre l'alloue de la ressource et ça restitution ?

Merci d'avance

Cordialement

  • # semops

    Posté par . Évalué à 1. Dernière modification le 26/12/16 à 06:05.

    Tu as 2 problèmes:
    1. Partager la ressources par X (=3) processus. Chaque processus décrément le SNlibre (en mode bloquant), par contre il ne faut pas oublier d'initialiser le SNlibre à X au début (ce que tu as oublié il me semble: à faire dans le parent, logiquement…).
    2. Trouver un numéro de ressource unique. Je te propose l'algorithme suivant: tu essayes de décrémenter de Y(=X) puis d'incrémenter de Y-1 en mode non bloquant, le tout dans une même semop. Si ça ne marche pas, tu réessaye avec avec Y=Y-1 jusqu'à Y=1… Le numéro de ressource vaut Y. À nouveau il faut penser à mettre le sémaphore à X au début…

    Si je ne m'abuse pas, tu peux combiner 2 et 1 et n'utilise qu'un seul sémaphore… ;-)

    Note: par pitié, éviter ce genre d'horreur (au pire… utilise stdbool). Je te laisse chercher pourquoi ça n'est vraiment pas une bonne idée ;-)


    typedef enum boul
    {true, false} boul;

    • [^] # Re: semops

      Posté par . Évalué à 1.

      Note2: Ton while (mdispo[num]==true) num++; n'a aucune chance de marcher avec des forks car tu n'as plus de partage de la mémoire entre les process, ce qui fait qu'on utilise un sémaphore en premier lieu… :p Au contraire, avec des threads, tu peux faire cela et utiliser un mutex (et tu n'as plus besoin de sémaphore…).

Suivre le flux des commentaires

Note : les commentaires appartiennent à ceux qui les ont postés. Nous n'en sommes pas responsables.