Discussion :

[rdtech]

Bonjour,

Je code l'algo de rendez vous de N processus (sur une recette de cuisine...). J'ai donc un mutex pour protéger la variable commune qui compte les processus arrivés et un sémaphore initialisé à 0 pour endormir les processus qui arrivent à la barrière.
Et ce sémaphore ne bloque rien.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
 
if(tab_fils[i] == 0)
        {
            //premier travail de préparation
            preparation(i);
            //arrivée à la barrière
            operations_mutex.sem_op = -1;
            semop(semid_mutex, &operations_mutex, 0);   //-1 sur mutex
            memcpy(&nb_arrives, ptr_shm, sizeof(int));
            nb_arrives += 1;             //incrémenter le nombre de processus arrivés
            memcpy(ptr_shm, &nb_arrives, sizeof(int));
            if(nb_arrives < NB_FILS) {
                operations_mutex.sem_op = 1;
                semop(semid_mutex, &operations_mutex, 0);   //+1 sur mutex (on le rend)
                printf("%d processus %d arrive(s) Blocage\n", nb_arrives, i);
                operations_s.sem_op = -1;
                semop(semid_s, &operations_s, 0);   //-1 sur s
                operations_s.sem_num = 0;
                operations_s.sem_flg = 0;
                printf("Fin du blocage\n");
            }
            else {
                operations_mutex.sem_op = 1;
                semop(semid_mutex, &operations_mutex, 0);   //+1 sur mutex
                printf("Reveiller tous les processus arrives.\n");
                for(j=0; j<nb_arrives-1; j++)
                {
                    printf("Reveil du fils %d\n",i);
                    operations_s.sem_op = 1;
                    semop(semid_s, &operations_s, 0);   //+1 sur s
                    operations_s.sem_num = 0;
                    operations_s.sem_flg = 0;
                }
                sleep(5);
            }
            //barrière franchie, on continue
            cuisson(i);

nb_arrives est la variable commune protégée par semid_mutex. J'ai 3 processus qui ont chacun un temps d'exécution différent et dans le if(), je vois les printf qui s'enchaînent l'un derrière l'autre sans blocage. Apparemment, semid_s ne joue pas son rôle quand je fais -1 dessus.
Si le problème vous saute aux yeux... Merci.

[Sve@r]

Bonjour

Je code l'algo de rendez vous de N processus (sur une recette de cuisine...). J'ai donc un mutex pour protéger la variable commune qui compte les processus arrivés et un sémaphore initialisé à 0 pour endormir les processus qui arrivent à la barrière.
Et ce sémaphore ne bloque rien. Apparemment, semid_s ne joue pas son rôle quand je fais -1 dessus.
Si le problème vous saute aux yeux...

Avoir le code complet serait un plus mais déjà je crois que tu as fait deux erreurs:

• Un sémaphore ne doit pas être initialisé à 0 mais à "n", n étant le nombre de ressources disponibles. Chaque processus qui demande une des ressources fait un "-1" sur le sémaphore. Et donc s'il arrive à 0 le "-1" ne peut s'accomplir et le processus est bloqué. Et quand la ressource est libérée le processus libérateur fait un "+1" et un autre peut alors prendre le sémaphore (*)
• le dernier paramètre de semop est le nombre de sémaphores qui doivent être traités en une opération. On peut en effet très bien gérer "s" sémaphores en même temps dans le cas où par exemple un processus doit récupérer "s" ressources d'un coup. Par exemple dans le diner des philosophes, chaque philosophe doit récupérer deux fourchettes en même temps (chaque fourchette étant gérée par un sémaphore particulier). Donc dans ton cas, je pense que c'est "1" puisque tu demandes une opération sur "un" sémaphore. Or toi tu as mis 0.

Ainsi, en jouant sur les valeurs "n" et "s" tu peux tout gérer. "n" c'est le nombre de ressources disponibles et "s" c'est le nombre d'items à prendre quand on demande "une" ressource.

(*) les sémaphores Linux offrent une 3° option: opération "0" => cette opération bloque le processus tant que le sémaphore n'est pas à 0 => pratique pour programmer un "start" pour que tous les processus partent en même temps. Le père met à "1" puis lance les processus. Chaque processus qui est prêt demande l'opération "0" et se fige Et quand tous sont générés, le père met à "0" et tous démarrent ensembles.

[rdtech]

bonjour,
merci pour la réponse, je n'avais pas bien compris le rôle du troisième paramètre.
Ca fonctionne.

Rien n'empêche d'initialiser un sémaphore à 0. Le processus qui fera -1 dessus sera automatiquement bloqué ce qui est l'effet recherché.
Pour la remarque à l'*, je vais regarder, je ne connaissais pas.

Merci.

[Sve@r]

merci pour la réponse, je n'avais pas bien compris le rôle du troisième paramètre.
Ca fonctionne.

Rien n'empêche d'initialiser un sémaphore à 0. Le processus qui fera -1 dessus sera automatiquement bloqué ce qui est l'effet recherché.

Exact. Bon "généralement" un sémaphore est associé à "un" type de ressource donc "généralement" il démarre à "n" (n étant le nombre de ressources du type disponibles) mais bien évidemment si la ressource n'existe pas encore au moment où il est créé ben oui c'est 0. J'avais pas envisagé cette hypothèse.

Pour la remarque à l'*, je vais regarder, je ne connaissais pas.

C'est un truc sympa. Je m'en sers justement quand je m'amuse à faire des "courses de processus"...