Problème Exercice Débutant

**nanoute** · 17/05/2007, 17h12

Bonjour,

Voilà, j'ai un très gros problème. J'ai un exercice à faire pour l'université en programmation système mais je suis totalement perdu. Je vous donne l'énoncé au cas où vous pourriez m'éclairer et me donner des pistes. je ne sais pas du tout par où commencer. Je suis complètement largué dans cette matière. Je ne comprend que très peu de chose.

L'énoncé :

Un boulanger B fabrique deux sortes de pains, le P1 et le P2. Il est ne produit pas plus de 20 pains par jour. Il fournit un pâtissier qui peut stocker jusqu’à 100 pain. Le pâtissier emploie de deux apprentis : A1, qui reçoit les pains, et A2, qui les vends aux clients. Il y a 30 clients achète 0 ou 1 pain par jour (avec probabilité 1/2). Un client a droit d’acheter 1 seul pain par jour, la quantité étant limitée.

Modélisez ce problème en utilisant :

- un processus par client, un pour le boulanger B, un pour A1 et un pour A2,

- une seconde pour modéliser une journée,

- alarm() pour gérer le passage du temps,

- une file IPC entre B et A1,

- un message IPC pour représenter chaque pain envoyé,

- deux entiers partagés entre A1 et A2 pour représenter le stock du revendeur en P1 et en P2,

- deux sémaphores pour éviter des accès simultanés en écriture aux zones de mémoire partagée,

- une file IPC entre A2 et l’ensemble des clients.

Les clients réalisent leurs commandes en envoyant un message IPC à A2. On simule l’envoi du pain par

un message de A2 vers le client dans cette même file. A1 envoie des commandes à B pour lui demander de produire des pain quand les stocks de P1 ou P2 sont bas. La fréquence et le format de ces commandes est libre pour cet exercice.

Merci pour vos réponses.

**kromartien** · 17/05/2007, 21h32

Bonjour. ça a l'air intéressant. Il faut utiliser des signaux et des sémaphores.

DRING ! Ah, c'était le toaster des big mac qui a sonné.

**Shugo78** · 17/05/2007, 23h13

Je suis daccord ça ma l'air intéressant

Désolé je verrais demain(sale gosse bruyant qui veux pas aller ce coucher oblige

)

**nanoute** · 18/05/2007, 17h51

D'autres réponses ? svp. Merci. C'est galère de chez Galère

**Shugo78** · 18/05/2007, 18h15

Si on te donne un exo comme ça tu dois bien avoir des cours, de la doc ou des indics , non ?
Ils te demandent pas d'inventer la roue.
Pour commencer où en es tu dans ton apprentissage ?

**nanoute** · 18/05/2007, 18h22

Bien entendu j'ai des cours, et tout ce qu'il va avec, mais c'est la forme de l'énoncé qui me bloque, en plus du fait que je n'arrive pas à comprendre beaucoup de chose. Je me suis lancée à faire un truc mais j'ai pas mal de mal avec les processus. Pour créer un processus, je suis obligée d'utiliser un fork ? Parce que là je suis partie à faire des procédures Client, ..etc, en guise de processus. Je ne sais pas trop reporté ce que j'ai vu en cours à cet exercice.

**Shugo78** · 18/05/2007, 18h28

On utilise fork(); pour créer un processus plus exactement dupliquer le processus en cours d'éxécution donc le nouveau processus a les mêmes variables(par exemple) que son processu père et leurs contenu est le même bien que ça soit deux processus différent.
Si mes souvenirs sont bons on utilise :

Code :

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

1
2
3
 
int PID;
switch((PID = fork()))

et ensuite on agissait selon les valeurs.

**nanoute** · 18/05/2007, 18h45

Bon je viens de faire un truc vite fait pour créer mes processus, mais à mon avis c'est bidon (je ne suis pas douée) mais je vous le montre quand même.

voila le code vite fait :

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
int main()
{
    int B;
    int A1;
    int A2;
    int Client[i];
    int i;
 
    B=fork();
 
    if(B==0) {
             //instructions
             A1=fork();
             A2=fork();
             if(A2==0) {
                       //instructions
                       for(i = 1; i<=30; i++)
                       {
                             Client[i]=fork();
                       }
             }             
    }
}

Désolée si vous êtes effrayé(e)s ^^

**Shugo78** · 18/05/2007, 18h54

Comme ça en relecture rapide et au feeling ça ma pas l'air trop désépéré

.
Mais il y avait pas 30 clients dans l'énoncé ?

**zooro** · 18/05/2007, 18h55

Envoyé par nanoute

Bon je viens de faire un truc vite fait pour créer mes processus, mais à mon avis c'est bidon (je ne suis pas douée) mais je vous le montre quand même.

Ce n'est pas une question d'être douée ou pas. Tout projet (informatique ou non) est composé de plusieurs phases.
La première est la lecture de l'énoncé (ça c'est fait

).
Ensuite, il faut réfléchir un peu. Eventuellement, faire un petit dessin pour voir ce que ça donne. Et essayer de diviser le problème en sous-problèmes plus simples à résoudre.

**Shugo78** · 18/05/2007, 18h58

avant de coder(une dernière chose) il faut établir l'algorithme dans sa tête ou sur feuille, ça aide beacoup et seulement ensuite on commence à coder certes les exemples peuvent se faire comme ça en claquant des doigts mais ce n'est pas le cas d'un exercice complexe(quoi qu'encore celui-ci ça vas j'ai vu pire et c'était pas un exercice

).

Donc établissons déjà la structure général du programme

**nanoute** · 18/05/2007, 18h59

Si exact !

Je vais essayer de construire qqch autour de cela (même si ça va être un peu dur) et je le balancerai après.

Merci pour tes réponses.

**nanoute** · 18/05/2007, 19h08

Les brouillons c'est fait. J'ai même fais un schéma de ce que doivent faire les processus. Je suis un peu plus rassurée. Je vais mangé un petit morceau et je m'y mets à fond !

Je vous montre ça après.

Merci encore

**abdelkaderg54** · 18/05/2007, 19h14

Salut....
Ya pas une chose plus dur que de dire qu'une chose est dur........et portant tout probleme a une solution , il suffit de reflichir un peu et de chercher c'est tout ,et le fait que t'as posté ta question je crois que t'as bien réflichi .......
Bonne courage..

**Shugo78** · 18/05/2007, 19h28

J'attends ça

P-S : tu manges tôt

**nanoute** · 19/05/2007, 10h27

Bonjour tout le monde,

J'ai avancé dans mon exercice, mais je me pose une petite question.
Je veux que mon programme s'exécute en boucle jusqu'à ce qu'on l'interrompe manuellement.
Mais si je prends le code suivant :

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
int main()
{
    int B;
    int A1;
    int A2;
    int Client[i];
    int i;
 
    B=fork();
 
    while(/*condition*/) {
    if(B==0) {
             //instructions
             A1=fork();
             A2=fork();
             if(A2==0) {
                       //instructions
                       for(i = 1; i<=30; i++)
                       {
                             Client[i]=fork();
                       }
             }             
    }
}
}

Cela va me recréer tous mes processus à chaque fois, non?

**zooro** · 19/05/2007, 10h51

Envoyé par nanoute

Cela va me recréer tous mes processus à chaque fois, non?

Oui.

Allez, je te donne un exemple de canvas :

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
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
 
#include <stdlib.h>
#include <stdio.h>
#include <sys/types.h>
#include <unistd.h>
 
/* deux macros pour les traces (plusieurs processus, le PID peut etre utile dans les traces) */
#define ERREUR(msg,...) do { \
        fprintf(stderr, "Processus %d, fonction %s: ERREUR: " msg "\n", getpid(), __FUNCTION__, ##__VA_ARGS__); \
    } while(0)
 
#define TRACE(msg,...) do { \
        printf("Processus %d, fonction %s: " msg "\n", getpid(), __FUNCTION__, ##__VA_ARGS__); \
    } while(0)
 
/* travail du boulanger */
void boulanger(void) {}
 
/* cree le fils qui va jouer le role du boulanger */
void creer_boulanger(void) {
    pid_t pid = fork();
    switch (pid) {
        case -1: /* Erreur */
            ERREUR("Erreur lors du fork. Exit.");
            exit(EXIT_FAILURE);
            break;
 
        case 0: /* Processus fils */
            boulanger();
            break;
 
        default: /* Processus père */
            TRACE("Fils créé avec le PID %d", pid);
            break;
    }
}
 
/* travail du premier apprentis */
void A1(void) {}
 
/* travail du deuxieme apprentis */
void A2(void) {}
 
/* cree les fils qui vont jouer le role des apprentis du patissier */
void creer_patissier(void) {
    pid_t pid;
 
    /* Créer A1 */
    pid = fork();
    switch (pid) {
        case -1: /* Erreur */
            ERREUR("Erreur lors du fork pour A1. Exit.");
            exit(EXIT_FAILURE);
            break;
 
        case 0: /* Processus fils */
            A1();
            break;
 
        default: /* Processus père */
            TRACE("Fils A1 créé avec le PID %d", pid);
            break;
    }
 
    /* Créer A2 */
    pid = fork();
    switch (pid) {
        case -1: /* Erreur */
            ERREUR("Erreur lors du fork pour A2. Exit.");
            exit(EXIT_FAILURE);
            break;
 
        case 0: /* Processus fils */
            A2();
            break;
 
        default: /* Processus père */
            TRACE("Fils A2 créé avec le PID %d", pid);
            break;
    }
}
 
/* travail d'un client */
void client(int numero_client) {}
 
/* cree les fils qui joueront le role des nb clients */
void creer_clients(int nb) {
    int i = 0;
    pid_t pid = 0;
 
    for(i=0; i<nb; i++) {
        pid = fork();
        switch (pid) {
            case -1: /* Erreur */
                ERREUR("Erreur lors du fork pour le client %d. Exit.", i);
                exit(EXIT_FAILURE);
                break;
 
            case 0: /* Processus fils */
                client(i);
                break;
 
            default: /* Processus père */
                TRACE("Fils %d créé avec le PID %d", i+1, pid);
                break;
        }
    }
}
 
/* point d'entree */
int main(void)
{
    creer_boulanger();
    creer_patissier();
    creer_clients(30);
 
    while (1) {
        sleep(1);
    }
 
    return EXIT_SUCCESS;
}

Il te reste à mettre en place les mécanismes de communication entre les processus, et à écrire le contenu des fonctions boulanger(), A1(), A2(), et client().
Eventuellement, tu peux ajouter une petite supervision dans le main(), pour tuer tous les processus crées quand le processus principal s'arrête.

**nanoute** · 19/05/2007, 11h00

Ok merci, ça va beaucoup m'aider.

Mais si je mets ce code là :

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
38
39
40
41
42
43
44
45
int main()
{
    int B;
    int A1;
    int A2;
    int Client[i];
    int i;
 
//Création des processus
 
    B=fork();
 
    if(B==0) {
             //instructions
             A1=fork();
             A2=fork();
             if(A2==0) {
                       //instructions
                       for(i = 1; i<=30; i++)
                       {
                             Client[i]=fork();
                       }
             }             
    }
 
    while(/*condition*/) {
                         if(B==0) {
                         //instructions
                         }
                         if(A2==0) {
                         //instructions
                         }
                         if(A1==0) {
                         //instructions
                         }
                         for(i = 1; i<=30; i++)
                         {
                               if(Client[i]==0) {
                               }
                         }
             }             
    }
 
}
}

Est ce que ça fera la même chose que le tiens ?

**Shugo78** · 19/05/2007, 11h12

L'essentiel c'est que tu sépare la création des processus de la boucle sinon tes processus seront cré à chaque fois, ensuite plusieurs alternatives sont possibles.
Le code de zooro me semble bien une fois que tu as inséré le code dans les fonctions vides.

**zooro** · 19/05/2007, 11h45

Envoyé par nanoute

Est ce que ça fera la même chose que le tiens ?

Non. Il y a une chose importante à se rappeler à propos de fork: le père et le fils partagent le même code. Et continuent donc l'exécution juste après le fork. Le père ET le fils vont exécuter l'instruction suivante.
Donc quand tu fais

Code :

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

1
2
A1=fork();
A2=fork();

En fait, le père et le fils créé par la première ligne vont chacun faire le deuxième fork. Donc le père va créer 2 fils (c'est ce que tu voulais), mais le fils A1 va aussi créer un fils (ouille !).

Problème Exercice Débutant

C

Discussions similaires

Partager

Partager