Crée N processus

Version imprimable

18/12/2008, 17h40
bilred

Crée N processus avec différant politique

Bonjour,

J’ai besoin d’un code qui crée N processus en utilisant la fonction fork() ;
(Pour simplifier en peu dire que N=1..à...7)

Qui ce trouverai à l’intérieur d’une fonction Que j’appellerais fork_n(…)
Si quelqu'un peut me donnés des idées ou un Code qui fait à peu prés la chose.

Sa serai bien :roll:

Merci d’avance
18/12/2008, 19h24
publicStaticVoidMain

Citation:

for( i = 0; i < N ; i++)
fork();

C'est le plus simple non?
18/12/2008, 22h32
dapounet

Bonsoir,

Citation:

Envoyé par publicStaticVoidMain

C'est le plus simple non?

Il faut faire attention à ce que les fils ne parcourent pas la boucle en utilisant la valeur de retour de fork().
18/12/2008, 22h46
publicStaticVoidMain

Citation:

Envoyé par dapounet

Bonsoir,

Il faut faire attention à ce que les fils ne parcourent pas la boucle en utilisant la valeur de retour de fork().

Il voulais créer N Processus, c pour ca c aussi simplifié.

Citation:

for(i = 0 ; i< N ; i++){
if((fork()) == 0){
/* je suis le fils*/
} else {
/* je suis le pere*/
}

}
// Il faut aussi tester le cas d'erreur !!
18/12/2008, 23h47
matafan

En espérant très fort que le fils ne sorte jamais du if...
19/12/2008, 00h35
publicStaticVoidMain

Bah dans ce cas, on met un return alors à la fin du fils ;)

Bonjour, :oops:

voila mon résultat d'aujourd'hui:

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
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
123
124
125
126
127
 
#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<sys/signal.h>
#include<sys/time.h>
#include<sys/wait.h>
#include <sched.h>
#include<errno.h>
 
int nb_papa, nb_fils = 0;
pid_t pid =1; // il faut inisialiser dif !=0 pour que le péres exécute la 1er fois le Fork_n()
int politique,status,priorite;
 
static void  hand_fils()
{
 
   //pid = getpid(); // ??!! ce que elle donne si en peu ce pasés de l'affectation
   printf("je suis le fils ma priorité d'ordonnancement est : %d \n",getpriority(PRIO_PROCESS,pid));
 
politique = sched_getscheduler(pid); 
 
      if(politique==SCHED_RR)
         printf("je suis le fils ma prorité d'ordonnancement est SCHED_RR \n");
      if(politique==SCHED_FIFO)
         printf("je suis le fils, ma prorité d'ordonnancement est SCHED_FIFO \n");
      if(politique==SCHED_OTHER)
         printf("je suis le fils, ma prorité d'ordonnancement est SCHED_OTHER \n");
 
      //en fait ici les Modif de Politique et de prioriter.
      // il faut pour chaque fils  s'a politique !!
printf("fonction hand_Fils \n");
}
 
static void  hand_papa()
{
 
  //pid = getpid(); // ?? ce que elle donne si en peu ce pasés de l'affectation
  printf("je suis le pére ma priorité d'ordonnancement est : %d \n",getpriority(PRIO_PROCESS,pid));
 
politique = sched_getscheduler(pid); //sched_getscheduler()
 
      if(politique==SCHED_RR)
         printf("je suis le pére ma prorité d'ordonnancement est SCHED_RR \n");
      if(politique==SCHED_FIFO)
         printf("je suis le pére, ma prorité d'ordonnancement est SCHED_FIFO \n");
      if(politique==SCHED_OTHER)
         printf("je suis le pére, ma prorité d'ordonnancement est SCHED_OTHER \n");
       //just pour voire la politique et sa prioriter
 
printf("fonction hand_Papa\n");
}
 
 
void fork_n()
{
//pid_t pid; 
int i;
 
pid = fork();
if (pid == 0)
{ // processus fils
 nb_fils++;
 printf("le flis: N° = %d\n", nb_fils);
 printf("le Fils : mon pid est %d, le pid de Mon papa est %d\n", getpid(), getppid());
 
/* on rempli une structure sigaction en précisant l'action a executer a reception du signal */
struct sigaction action = {.sa_handler = hand_fils};
sigaction(SIGUSR1, &action, NULL);
 
 for (i=0;i<1;i++)
 {
  pause();
  sleep(1);
  kill(getppid(), SIGUSR1);
 }
 
printf("\n");
}
else
 { // processuse pére (c'est le pér qui comance le 1er)
   nb_papa++;
   printf("le pére: N° = %d \n", nb_papa);
   printf("le pére : mon pid est %d, le pid de Mon papa est %d\n", getpid(), getppid());
 
  struct sigaction action = {.sa_handler = hand_papa};
  sigaction(SIGUSR1, &action, NULL);
 
    for (i=0;i<1;i++)
   {
    sleep(1);
    kill(pid, SIGUSR1);
    pause ();
   }
 
printf("\n");
 
 }
 
} 
 
 
int main(){
 
int i;
int return_value;
 
 for(i=0;i < 1; i++)
 {
printf("PID = %d\n", pid);
if (pid !=0)
  { //Voila la il y 'a que le Pére qui crée des fils 
  fork_n();
  }
   else
      { //Pour voir le Scheduling (l'ordonencement) des Fils (il n'y que les fils qui pas par la)
 
      //system("echo " " >> jornal");
      //return_value = system("ps -elf | grep ./TP_sys3 >> jornal");
      //system("echo " " >> jornal");
      }
 
  printf("le Fils ou le pére : mon pid est %d, le pid de Mon papa est %d\n\n", getpid(), getppid());
 }
 
 
}

tout sa pour ariver à voire le journal des Ordenancement de N fils sous diférante politique.

Merci. :roll:

Le principe est simple, à chaque fork(), le nombre de processus double, donc dans l'idéal, le nombre de processus voulu devrait être une puissance de 2, ce qui est le cas: 8 = 2^3, il faut donc 3 fork() pour avoir 8 processus.
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 #include <stdio.h> #include <unistd.h> int main (void) { for(unsigned i = 0; i < 3; i++) { fork(); } printf("mon pid est %ld\n", (long) getpid()); return 0; }
donne bien:
Code:

1 2 3 4 5 6 7 8 mon pid est 4172 mon pid est 4173 mon pid est 4175 mon pid est 4171 mon pid est 4170 mon pid est 4176 mon pid est 4174 mon pid est 4168

Merci Pour les répance. ;)

Voilà après beaucoup de patience je suis arrivé à ce résultat:
J’ai fait en sorte que qu'il n'y a que le père qui crée des processus fils.
et quand je demande la lecture de la priorité et de la politique, les processus fils
son en pause.

Mon Code C: qui à comme nom: TP_sys3.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
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
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
 
#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<sys/signal.h>
#include<sys/time.h>
#include<sys/wait.h>
#include <sched.h>
#include<errno.h>
 
int nb_papa =0, nb_fils = 0;
pid_t pid =1; // il faut inisialiser dif !=0 pour que le péres exécute la 1er fois le Fork_n()
int politique,status,priorite;
struct sched_param param;
 
int pri[5] = {1, 2, 3, 4, 5};  // pour affecter les prioriter au processuse.
long pol_scheduler[2];
int choix[5] = {0, 1, 2, 0, 1}; // pour affecter les politique de scheduling au processus.
int k;
static int c =0, j =0;
 
 
static void  hand_fils()
{
 
pol_scheduler[0] = SCHED_RR;
pol_scheduler[1] = SCHED_FIFO;
pol_scheduler[2] = SCHED_OTHER;
      //en fait ici les Modif de Politique et de prioriter.
      // il faut pour chaque fils  s'a politique !!
printf("\n");
printf("\nPrioriter de P1(0 a 4)"); scanf("%d", &j); // Prioriter de P1
printf("\nPolitique de P1(0 a 2)"); scanf("%d", &c); // Politique de P1
printf("\n");
 
 
 param.sched_priority = pri[j];  // pour le cas ou il y'a 7 procesuss fils
 setpriority(PRIO_PROCESS, pid, pri[j]);
 
 
 k = choix[c];   // sa ce ra par order puisque nb 1 puis 2, 3, 4 .... par ordre croisant
 if(sched_setscheduler(pid, pol_scheduler[k], &param) == -1)
   perror("problème scheduler");
 
 
 
priorite = getpriority(PRIO_PROCESS, pid);
printf("je suis le fils, ma priorité d'ordonnancement est: %d\n", priorite);
 
politique = sched_getscheduler(pid);
if(politique == SCHED_RR)
printf("je suis le fils, ma politique d'ordonnancement est: SCHED_RR \n");
if(politique == SCHED_FIFO)
printf("je suis le fils, ma politique d'ordonnancement est: SCHED_FIFO \n");
if(politique == SCHED_OTHER)
printf("je suis le fils, ma politique d'ordonnancement est: SCHED_OTHER \n");
 
printf("fonction hand_Fils \n");
}
 
 
static void  hand_papa()
{
 printf("fonction hand_Papa\n");
}
 
 
void fork_n()
{
 
int i;
 
pid = fork();
if (pid == 0)
{ // processus fils
  nb_fils++;
 
/* on rempli une structure sigaction en pr�cisant l'action a executer a reception du signal */
struct sigaction action = {.sa_handler = hand_fils};
sigaction(SIGUSR1, &action, NULL);
 
 for (i=0;i<1;i++)
 {
  printf("le Fils: N° = %d est en PAUSE \n", nb_fils);
  pause();
  printf("le Fils: N° = %d est en A reçu le Signiale de Re_démarage du PAPA \n", nb_fils);
  sleep(1);
  kill(getppid(), SIGUSR1);
  printf("le Fils: N° = %d  A envoyer le Signiale de Re_démarage ou PAPA \n", nb_fils);
 }
 
//wait(&status);
}
else
 { // processuse pére (c'est le pér qui comance le 1er)
   nb_papa++;
   printf("le même pére le passage: N° = %d qui est == au Nb de Fils Crée\n", nb_papa);
 
  struct sigaction action = {.sa_handler = hand_papa};
  sigaction(SIGUSR1, &action, NULL);
 
    for (i=0;i<1;i++)
   {
    sleep(1);
    printf("le pére: N° = %d  A envoyer le Signiale de Re_démarage au Fils \n", nb_papa);
    kill(pid, SIGUSR1);
    printf("le pére: N° = %d est en PAUSE \n", nb_papa);
    pause ();
    printf("le pére: N° = %d est en A reçu le Signiale de Re_démarage du FILS \n", nb_papa);
   }
 
 
 }
 
}
 
 
int main(){
 
int i;
int return_value;
 
 for(i=0;i < 3; i++)
 {
 
if (pid !=0)
  { //Voila la il y 'a que le Pére qui crée des fils 
  printf("\nDans le Main:\n le pére : mon pid est %d, le pid de Mon papa est %d\n\n", getpid(), getppid());
  fork_n();
  }
   else
      { //Pour voir le Scheduling (l'ordonencement) des Fils (il n'y que les fils qui pas par la)
       // printf("le flis est Trminées: N° = %d\n", nb_fils);
        printf("\nDans le Main:\n le Fils : mon pid est %d, le pid de Mon papa est %d\n", getpid(), getppid());
 
        system("echo " " >> journal");
        return_value = system("ps -elf | grep ./TP_sys3 >> journal");
        system("echo " " >> journal");
 
        return(0); // Pour Tuérs le fills il ne Boucle Pas
      }
 
 }
 
 
}

Tout ça c'est pour sortir le diagramme d'exécution de plusieurs processus avec différant priorité et différant politique.

j'ai exécuter en utilisant:

Code:

sudo ./TP_sys3

Le Résultat rechercher est dans le fichier journal.
dans ce cas j'est lencer 3 procesusse Fils
le 1er avec une prioriter de 0 et une politique SCHED_RR
le 2em avec une prioriter de 1 et une politique SCHED_FIFO
le 3em avec une prioriter de 2 et une politique SCHED_OTHER
le pid du pére a tous est : 5649
le pid du 1er fils est : 5650
le pid du 2em fils est : 5656
le pid du 3em fils est : ??

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
 
F S UID     PID  PPID  C PRI  NI ADDR SZ WCHAN  STIME TTY          TIME CMD
 
4 R root    5649  5366  0  80   0 -   408 -      18:18 pts/1    00:00:00 ./TP_sys3
5 S root    5650  5649  0  58   - -   409 -      18:18 pts/1    00:00:00 ./TP_sys3
0 S root    5652  5650  0  58   - -   458 -      18:18 pts/1    00:00:00 sh -c ps -elf | grep ./TP_sys3 >> journal
1 R root    5654  5652  0  58   - -   458 -      18:18 pts/1    00:00:00 sh -c ps -elf | grep ./TP_sys3 >> journal
 
 
4 R root    5649  5366  0  80   0 -   408 -      18:18 pts/1    00:00:00 ./TP_sys3
5 S root    5656  5649  0  57   - -   409 -      18:18 pts/1    00:00:00 ./TP_sys3
0 S root    5658  5656  0  57   - -   458 -      18:18 pts/1    00:00:00 sh -c ps -elf | grep ./TP_sys3 >> journal
1 R root    5660  5658  0  57   - -   458 -      18:18 pts/1    00:00:00 sh -c ps -elf | grep ./TP_sys3 >> journal

La en vois clairement qu’il y'a que 2 fils qui ce son Afficher!!!! :bug:
Il manque le 3eme, je ne c’est pas pour quoi ?

Voila je voudrais aussi votre avise. :roll:

Merci d'avance pour tous veaux répance.

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
 
void fork_n(unsigned n)
{
unsigned i;
int j;
for( i = 0 ; i < n ; i ++ )
{
   j = fork();
   if(j == -1 )
    //erreur
   else if( j == 0)
    break;
 }
 
}

Je crois que ça marche mais j'ai pas testé.

28/12/2008, 23h26
bilred

Mise à jour

Merci pour les répance. :cry:

Citation:

Envoyé par publicStaticVoidMain

Bah dans ce cas, on met un return alors à la fin du fils ;)

Plutôt un exit() pour clore le processus...

Citation:

Envoyé par bilred

Merci pour les répance. :cry:

En tout cas je pige que dalle à ton programme. Peut-être trop de commentaires :roll:
Mais voici comment moi je programmerais de façon simple un code à N fils

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
47
48
#include <sys/wait.h>
#include <sys/types.h>
 
static void fils(void);
 
int main()
{
    pid_t tabFils[N];          // Pour stocker le pid des fils (N étant une constante)
    int fin;                       // Gestion de la fin du fils
    int pid;                      // N° du fils qui se termine
    int i;
 
    for (i=0; i < N; i++)
    {
        switch(tabFils[i]=fork())
        {
              case -1: // Erreur de fork
                    // Cas à gérer
                    break;
 
              case 0: // On est dans le fils
                    fils();
                    exit(0);     // Sûreté
 
              default: // On est dans le père
                   printf("Fils %d (pid=%d) lancé\n", i, tabFils[i]);
        }
    }
 
    // Ici les n fils ont été créés - On va attendre leur fin
    for (i=0; i < N; i++)
    {
          pid=wait(&fin);
          if (WIFEXITED(fin))
              printf("Le fils %d (pid=%d) vient de se terminer normallement par exit(%d)\n", i, pid, WEXITSTATUS(fin));
         else
              printf("Le fils %d (pid=%d) a été tué par kill(%d)(%d)\n", i, pid, WTERMSIG(fin));
     }
}
 
// Gestion d'un fils
static void fils()
{
   ...
   ...
   ...
   exit(...);
}

29/12/2008, 11h22
publicStaticVoidMain

Citation:

Envoyé par Sve@r

Plutôt un exit() pour clore le processus...

Oui oui je suis d'accord. Très pratique pour récupérer la valeur de retour du processus. ;)

Bonjour, :roll:

Et Merci pour les répances.
Bon, apré avoire intégré tout c'est bonne idé. ;)

voila un petit rappel:
1- création de N processus (que le pére qui peu creés)
2- Remplire les file des politique FIFO, RR et SCHED_OTHER
3- voire le résulte apprés avoire changer les politique et les prioriter
Si l'ordre d'execution change.

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
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
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
 
#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<sys/signal.h>
#include<sys/time.h>
#include<sys/wait.h>
#include <sched.h>
#include<errno.h>
 
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
 
int f1, f2;
int p[2]; // L/E du paipe (j'uste pour faire passer le nb de fils Crée) // tableau des descripteurs
 
int prio =0, polit =0;
 
int nb_papa =0;
int nb_fils = 1;
pid_t pid; 
int politique,status,priorite, n;
struct sched_param param;
struct timespec quantum;
 
int pri[5];      // = {1, 2, 3, 4, 5};  // pour affecter les prioriter au processuse. // definire le sénario
long pol_scheduler[2];
int choix[5];   // = {0, 1, 2, 0, 1}; // pour affecter les politique de scheduling au processus. // definire le sénario
int k;
 
 
 
static void  hand_fils()
{
 
pol_scheduler[0] = SCHED_RR;
pol_scheduler[1] = SCHED_FIFO;
pol_scheduler[2] = SCHED_OTHER;
      //en fait ici les Modif de Politique et de prioriter.
      // il faut pour chaque fils  s'a politique !!
printf("Le Fils : mon pid est: %d, le pid de Mon papa est: %d\n", getpid(), getppid());
 
read (p[0],&nb_fils,1);
printf ("Le processus Fils N°%d a recu: \n", nb_fils);
 
//int prio;
lseek(f1,-1,SEEK_CUR);
read (f1,&prio,1);
// affectation des prioriter dans tableau de la prioriter de 1 a ...
 
//int polit;
lseek(f2,-1,SEEK_CUR);
read (f2,&polit,1);
//affectation des politique dans tableau de la politique de 0 a ...
 
 
 
 
 param.sched_priority = pri[prio];  // pour le cas ou il y'a 7 procesuss fils
 setpriority(PRIO_PROCESS, pid, pri[prio]);
 
 
 k = choix[polit];   // sa ce ra par order puisque nb 1 puis 2, 3, 4 .... par ordre croisant
 if(sched_setscheduler(pid, pol_scheduler[k], &param) == -1)
   perror("problème scheduler");
 
 
 
priorite = getpriority(PRIO_PROCESS, pid);
printf("je suis le fils, ma priorité d'ordonnancement est: %d\n", priorite);
 
politique = sched_getscheduler(pid);
if(politique == SCHED_RR)
printf("je suis le fils, ma politique d'ordonnancement est: SCHED_RR \n\n");
if(politique == SCHED_FIFO)
printf("je suis le fils, ma politique d'ordonnancement est: SCHED_FIFO \n\n");
if(politique == SCHED_OTHER)
printf("je suis le fils, ma politique d'ordonnancement est: SCHED_OTHER \n\n");
 
 
//printf("fonction hand_Fils \n");
}
 
 
static void  hand_papa()
{
// printf("fonction hand_Papa\n");
}
 
 
int fork_n()
{
 
int i;
 
f1 = open ("./priorite.dat",O_RDWR|O_CREAT,S_IRWXU);
f2 = open ("./politique.dat",O_RDWR|O_CREAT,S_IRWXU);
pipe(p);  //Création du paipe
pid = fork();
 
if (pid == 0)
{ // processus fils
  close(p[1]);
 
/* on rempli une structure sigaction en pr�cisant l'action a executer a reception du signal */
struct sigaction action = {.sa_handler = hand_fils};
sigaction(SIGUSR1, &action, NULL);
 
 for (n=0;n<1;n++)
 {
 
  pause();
  sleep(1);
  kill(getppid(), SIGUSR1);
 
 }
 
 close(p[0]);
 
return(pid); //le pid du fils
}
else
 { // processuse pére (c'est le pér qui comance le 1er)
  close(p[0]);
   nb_papa++;
 
  struct sigaction action = {.sa_handler = hand_papa};
  sigaction(SIGUSR1, &action, NULL);
 
    write (p[1],&nb_fils,1);
    nb_fils = nb_fils + 1 ;
 
    for (n=0;n<1;n++)   // le NB de variable lu/ Ecrie dans un fichier
   {
    write(f1,&prio,1);
    prio = prio + 1;
 
    write(f2,&polit,1);
    polit = polit + 1;
 
    sleep(1);
    kill(pid, SIGUSR1);
   // pause (); //si en ne fait pas: pour que le pére crée des fils son attander la fin du 1er... )
   }
 close(p[1]);
 
 wait(&status); // le pére atant la términésant du fils
 close(f1); close(f2);
return(pid); //le pid du Pére
 }
 
}
 
 
int main(){
 
int i;
int return_value;
 
 
printf("\nDans le Main :\n le pid du grand pére est: %d, le pid de son Bash est: %d\n", (int) getpid(), (int) getppid());
 
for(i=0; i<3 ; i++)
{
 
printf("\nDonnée la Prioriter du processus P%d (une valeur de 1 a 99 )", i+1); scanf("%d", &pri[i]); // Prioriter de P1
printf("Donnée la Politique du processus P%d (une valeur de 0 a 2)", i+1); scanf("%d", &choix[i]); // Politique de P1
// sachant que : 0 = SCHED_RR;
// sachant que : 1 = SCHED_FIFO;
// sachant que : 2 = SCHED_OTHER;
 
}
printf("\n\n");
 
for(i=0;i < 3; i++)
{
 
        switch (fork_n()) 
       {
        case -1: exit(1);
        case 0: { // je suis le Fils
                // printf("\nDans le Main:\n le Fils : mon pid est %d, le pid de Mon papa est %d\n", getpid(), getppid());
 
                 system("echo " " >> journal");
                 return_value = system("ps -elf | grep ./TP_sys3 >> journal");
                 system("echo " " >> journal");
 
                 exit(0); //return(0); // Pour Tuérs le fills il ne Boucle Pas
                }
        default: { // je suis le Pére
 
                  }
 
        }
 
}
 
wait(&status);  // le péré attant la términéson de tous c'est fils
 
}

Le Résultat rechercher est dans le fichier journal.

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
 
dans ce cas j'est lencer 3 procesusse Fils 
le 1er avec une prioriter de 0 et une politique SCHED_RR
le 2em avec une prioriter de 1 et une politique SCHED_FIFO
le 3em avec une prioriter de 5 et une politique SCHED_OTHER
le pid du péré a tous est :  7484
le pid du 1er fils est : 7485
le pid du 2em fils est : 7491
le pid du 3em fils est : 7497
 
F S UID        PID  PPID  C PRI  NI ADDR SZ WCHAN  STIME TTY          TIME CMD
 
4 R root      7484  6721  0  80   0 -   409 -      14:48 pts/1    00:00:00 ./TP_sys3
5 S root      7485  7484  0  58   - -   409 -      14:48 pts/1    00:00:00 ./TP_sys3
0 S root      7487  7485  0  58   - -   458 -      14:48 pts/1    00:00:00 sh -c ps -elf | grep ./TP_sys3 >> journal
1 R root      7489  7487  0  58   - -   458 -      14:48 pts/1    00:00:00 sh -c ps -elf | grep ./TP_sys3 >> journal
 
 
4 R root      7484  6721  0  80   0 -   409 -      14:48 pts/1    00:00:00 ./TP_sys3
5 S root      7491  7484  0  57   - -   409 -      14:48 pts/1    00:00:00 ./TP_sys3
0 S root      7493  7491  0  57   - -   458 -      14:48 pts/1    00:00:00 sh -c ps -elf | grep ./TP_sys3 >> journal
1 R root      7495  7493  0  57   - -   458 -      14:48 pts/1    00:00:00 sh -c ps -elf | grep ./TP_sys3 >> journal
 
 
4 S root      7484  6721  0  80   0 -   409 -      14:48 pts/1    00:00:00 ./TP_sys3
1 S root      7497  7484  0  85   5 -   442 -      14:48 pts/1    00:00:00 ./TP_sys3
0 R root      7499  7497  0  85   5 -   458 -      14:48 pts/1    00:00:00 sh -c ps -elf | grep ./TP_sys3 >> journal

Apré une mise à jour. je voudré confirmer si c'est logice tout sa.

Voila je voudrais aussi votre avise.

Merci d'avance pour tous veaux répance. ;)