Forum Programmation.c Sémaphore en C

Posté par . Licence CC By‐SA.
Étiquettes : aucune
-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 décembre 2016 à 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 à celles et ceux qui les ont postés. Nous n’en sommes pas responsables.