CH 2 INF3600

Processus
• Qu’est ce qu’un processus ?
• États d’un processus
• Hiérarchie des processus
• Gestion des processus sous UNIX/LINUX

– Création de processus
– Remplacement d’espace d’adressage
– Attente de la fin d’un processus fils
– Terminaison de processus
– Partage de fichiers entre processus
• Gestion des processus sous Windows

– Création de processus
– Attente de la fin d’un processus fils
– Terminaison de processus
Génie Informatique Chapitre 2. 1

Systèmes d’exploitation
École Polytechnique de Montréal
Qu’est ce qu’un processus ?

• Le concept processus est le plus important dans un système d’exploitation (SE). Tout le
logiciel d’un ordinateur est organisé en un certain nombre de processus (processus
système, processus utilisateur).
Hypothèse : Nous supposons, dans ce qui suit, que chaque
processus a un seul flot d’exécution (un seul thread). Le cas de
plusieurs flots d’exécution sera traité lors de la séance suivante.
• Un processus est un programme en cours d’exécution. Il est caractérisé par :

– Un numéro d’identification unique (PID);
– Un espace d’adressage (code, données, piles d’exécution);
– Un état principal (prêt, en cours d’exécution (élu), bloqué, …);
– Les valeurs des registres lors de la dernière suspension (CO, PSW, Sommet de Pile…);
– Une priorité;
– Les ressources allouées (fichiers ouverts, mémoires, périphériques …);
– Les signaux à capturer, à masquer, à ignorer, en attente ainsi que les actions associées;
– Autres informations indiquant, notamment, son processus père, ses processus fils, son groupe,
ses variables d’environnement, les statistiques et les limites d’utilisation des ressources….
• Le système d’exploitation maintient dans une table appelée «table des processus» les
informations sur tous les processus créés (une entrée par processus : Bloc de Contrôle de
Processus PCB).
• Cette table permet au SE de localiser et gérer tous les processus.

1
Qu’est ce qu’un processus ? (2)
Table des processus
PCB =
informations concernant l’état, la
mémoire et les ressources du
processus


Table des processus
• Dans la plupart des systèmes d’exploitation, le PCB est composé de deux

zones :
– La première contient les informations critiques dont le système a

toujours besoin (jamais swappée);
– La deuxième contient les informations utilisées uniquement lorsque le

processus est à l’état élu.

2
Exemple d’utilisation de la table des processus :
Changement de contexte
Programme A Mode kernel

Programme B
Mode utilisateur
Mode utilisateur
exécution
interruption Sauvegarder état dans PCB A
exécution
Charger état de PCB B
Sauvegarder état en PCB B

interruption
exécution Charger état de PCB A

États d’un processus

Expiration
Attente d’admission File des prêts Fin d’exécution
Processeur
Process eur
File des bloqués Attente d’événement
Terminaison
Fin Nouveau
Exécution
Élection
Mise en attente d’1 evt par le SE
Suspension
par le SE Admission
Arrivée de l’evt
3
États d’un processus (2)
Cas d’Unix
fork
Création
Préemption
Retour Mémoire
Mémoire
à usager insuffisante
suffisante
Exécution suspension
Mode Hors mémoire
user Retour Prêt en Prêt hors
Élection mémoire mémoire
En mémoire
Interruption ou
Appel système Exécution
Mode
noyau Mise en attente
d’un evt
Arrivée de l’evt Arrivée de l’evt
terminaison
Hors mémoire
attente Attente
Zombie en mémoire hors
mémoire

États d’un processus (3)

Cas de Windows XP

4
Hiérarchie des processus
• Le système d’exploitation fournit un ensemble d’appels système qui permettent la

création, la destruction, la communication et la synchronisation des processus.
• Les processus sont créés et détruits dynamiquement.
• Un processus peut créer un ou plusieurs processus qui, à leur tour, peuvent en créer
d’autres.
• Dans certains systèmes (MS-DOS), lorsqu’un processus crée un processus, l’exécution

du processus créateur est suspendue jusqu’à la terminaison du processus créé
(exécution séquentielle).
• Dans Windows, les processus créateurs et créés s’exécutent en concurrence et sont de

même niveau (exécution asynchrone mais pas de relation hiérarchique explicite gérée
par le SE).

Hiérarchie des processus (2)

Cas d’UNIX
• Le programme amorce charge une partie du système d’exploitation à partir du disque
(disquette ou CD) pour lui donner le contrôle. Cette partie détermine les caractéristiques
du matériel, effectue un certain nombre d’initialisations et crée le processus 0.
• Le processus 0 réalise d’autres initialisations (ex. le système de fichier) puis crée deux
processus : init de PID 1 et démon des pages de PID 2.
• Ensuite, d’autres processus sont crées à partir du processus init.
• Dans le cas de linux, on a, parmi d’autres, les processus kswapd, xfs et khubd.
5
Hiérarchie des processus (3)
Cas de Windows XP
• Chaque processus pointe vers le processus parent (processus créateur).
• Si le parent se termine, il n’y a pas d’actualisation de cette information.
• Il se peut donc qu’un processus pointe vers un parent inexistant. Cela ne cause
aucun problème puisque rien ne dépend de cette information de parenté.
• Windows ne gère de lien qu’avec l’ID du processus parent, pas avec le parent du
parent, etc.

Processus d’UNIX
• Chaque processus a un numéro d’identification unique (PID). L’appel system getpid() permet
de récupérer le PID du processus : int getpid();
• Chaque processus a un père, à l’exception du premier processus créé (structure

arborescente). S’il perd son père (se termine), il est tout de suite adopté par le processus init
de PID 1. L’appel système getppid() permet de récupérer le PID de son processus père.
• Un processus père s’exécute en concurrence avec ses fils (exécution asynchrone).
• Un processus fils peut partager certaines ressources (mémoire, fichiers) avec son processus
père ou avoir ses propres ressources. Le processus père peut contrôler l’usage des
ressources partagées.
• Le processus père peut avoir une certaine autorité sur ses processus fils. Il peut les
suspendre, les détruire (appel système kill), attendre leur terminaison (appel système wait)
mais ne peut pas les renier.
• La création de processus est réalisée par duplication de l’espace d’adressage et de certaines

tables du processus créateur (l’appel système fork). La duplication facilite la création et le
partage de ressources. Le fils hérite des résultats déjà calculés par le père.
• Un processus peut remplacer son code exécutable par un autre (appel système exec).
6
Processus d’UNIX (2) :
Processus shell (très simplifié)


Cas d’UNIX : Lancement de la commande ls à partir du shell

7
Création de processus (appel système fork)
• La création de processus sous UNIX est réalisée au moyen de l’appel système : fork();
• L’appel système fork :

– associe un numéro d’identification (le PID du processus);
– ajoute puis initialise une entrée dans la table des processus (PCB). Certaines
entités comme les descripteurs de fichiers ouverts, le répertoire de travail courant,
la valeur d’umask, les limites des ressources sont copiées du processus parent;
– duplique l’espace d’adressage du processus effectuant l’appel à fork
(pile+données);
– duplique la table des descripteurs….
• La valeur de retour est :

– 0 pour le processus créé (fils).
– le PID du processus fils pour le processus créateur (père).
– négative si la création de processus a échoué (manque d’espace mémoire ou le
nombre maximal de créations autorisées est atteint).
• Au retour de la fonction fork, l’exécution des processus père et fils se poursuit, en

temps partagé, à partir de l’instruction qui suit fork.
• Le père et le fils ont chacun leur propre image mémoire mais ils partagent certaines
ressources telles que les fichiers ouverts par le père avant le fork.

Création de processus
(appel système fork)
Après le fork,
• le père et le fils vont
poursuivre leurs exécutions
(12339) à partir de l’instruction qui
suit l’appel au fork mais
chacun a sa propre zone de
données.
• le père récupèrera dans sa

variable p, le PID du fils
créé;
• le fils récupérera dans sa

variable p la valeur 0.
(12339) (12340)
8
Processus d’UNIX (6)
Création de processus : Exemple 1
// programme tfork.c : appel système fork()
#include <sys/types.h> // pour le type pid_t
#include <unistd.h> // pour fork
#include <stdio.h> // pour perror, printf
int a=20;
int main ( )
{ pid_t x ;
// création d’un fils
switch (x = fork())
{ case –1 : /* le fork a échoué */
perror("le fork a échoué !") ;
break ;
case 0 : /* seul le processus fils exécute ce « case »*/
printf("ici processus fils, le PID %d.\n ", getpid()) ;
a+=10; break ;
default : /* seul le processus père exécute cette instruction*/
printf(" ici processus père, le PID %d. \n", getpid()) ;
a+=100;
}
// les deux processus exécutent ce qui suit
printf("Fin du Process %d. avec a = %d\n", getpid(),a ) ;
return 0 ;
} Génie Informatique Chapitre 2. 17

Création de processus : Exemple 1 (exécution)
a du fils
jupiter% gcc -o tfork tfork.c
jupiter% tfork
ici processus père, le PID 12339.
ici processus fils, le PID 12340.
Fin du Process 12340 avec a = 30. a du père
Fin du Process 12339 avec a = 120.
jupiter% tfork a du père

ici processus père, le PID 15301.
ici processus fils, le PID 15302.
jupiter% a du fils

9
// programme Arborescence.c : appel système fork()

#include <sys/types.h> // pour le type pid_t
#include <unistd.h> // pour fork
#include <stdio.h> // pour printf
int main ( )
{ pid_t p;
int i, n=5 ;
for (i=1; i<n; i++)
{ p = fork();
if (p > 0 )
break ;
printf(" Processus %d de père %d. \n", getpid(), getppid()) ;
}
sleep(1); // dormir pendant 1 seconde
return 0 ;
}


shell Processus (exécution)
23706
i=1 Processus
fork() 23707
sleep(1) printf(..) Processus
i=2
fork() 23708
sleep(1) printf(..)
i=3 Processus
fork()
23709
sleep(1) printf(..)
i=4 Processus
jupiter% gcc -o Arborescence Arborescence.c fork()
jupiter% Arborescence 23710
Processus 23707 de pere 23706 sleep(1)
Processus 23708 de pere 23707 printf(..)
Processus 23709 de pere 23708 i=5
Processus 23710 de pere 23709 sleep(1)
10
Création de processus : Exemple 2 sans l’instruction sleep
shell Processus
jupiter% gcc -o Arborescence Arborescence.c
23706 jupiter% Arborescence
jupiter% Processus 23707 de pere 1
.
Processus Processus 23708 de pere 1
i=1 Processus 23709 de pere 1
fork() 23707
Processus 23710 de pere 1
terminaison printf(..)
i=2 Processus
fork() 23708
terminaison printf(..)
i=3 Processus
fork()
23709
terminaison
Les fils qui deviennent printf(..)
orphelins sont adoptés i=4 Processus
par le processus init fork()
23710
de PID 1 terminaison
printf(..)
i=5


Remplacement d’espace d’adressage
Appel système exec
• Le système UNIX offre une famille d’appels système exec qui permettent à un
processus de remplacer son code exécutable par un autre spécifié par path ou
file.
int execl(const char *path, const char *argv, …….);
int execlp(const char *file, const char *argv, …….);
int execv(const char *path, char *const argv[]);
int execvp(const char *file, char *const argv[]);
• Ces appels permettent d’exécuter de nouveaux programmes.
• Le processus conserve, notamment, son PID, l’espace mémoire alloué, sa table

de descripteurs de fichiers et ses liens parentaux (processus fils et père).
• En cas de succès de l’appel système exec, l’exécution de l’ancien code est

abandonnée au profit du nouveau.
• En cas d’échec, le processus poursuit l’exécution de son code à partir de

l’instruction qui suit l’appel (il n’y a pas eu de remplacement de code).

11
Remplacement d’espace d’adressage (2)
Appel système exec : Exemple 3
// programme test_exec.c
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
int main ()
{ char* arg[] = {“/bin/ps”, “f”, NULL};
printf(“Bonjour…..\n”);
execvp(“/bin/ps”, arg);
printf(“Echec de execvp\n”);
printf("Erreur %s\n",strerror(errno));
return 0;
}


Attente de la fin d’un processus fils : appel système wait
• Les appels système wait(…) et waitpid(…) permettent à un processus père d’attendre
ou de vérifier la terminaison d’un de ses fils :
– int wait (int * status);
– int waitpid( int pid, int * status, int options);
• wait et waitpid retournent :

– le PID du fils qui vient de se terminer,
– -1 en cas d’erreur (le processus n’a pas de fils).
– des informations concernant la terminaison du fils, dans le paramètre status.
Ces informations peuvent être récupérées au moyen de macros telles que :
• WIFEXITED(status) : fin normale avec exit
• WIFSIGNALED(status) : tué par un signal
• WIFSTOPPED(status) : stopé temporairement
• WEXITSTATUS(status) : valeur de retour du processus fils ( exit(valeur))
• wait(status) et waitpid(-1,status,0) bloquent le processus appelant jusqu’à ce que l’un

quelconque des fils du processus se termine.
• waitpid(pid, status,0) avec pid>0, bloque le processus appelant jusqu’à ce que son
fils pid se termine.
• waitpid(pid, status, WNOHANG) vérifie seulement la terminaison, retourne 0 en cas

de non terminaison (pas d’attente).
12
Attente de la fin d’un processus fils : exemple 4
// programme parent.c // programme fils.c
#include <unistd.h> // pour fork et execl #include <stdio.h>
#include <sys/wait.h> // pour wait #include <unistd.h>
#include <stdio.h> //pour printf int main ( )
#define NULL 0 {
int main () printf(" ici programme fils [%d]\n",
{ int p, child, status; getpid());
p=fork() ; return 0;
if ( p ==- 1) return – 1 ; }
if( p>0) // ce que fera le père
{ printf (" ici père[%d], mon fils[ %d] \n", getpid(), p); Le père attend
if ((child=wait(&status))>0) la fin du fils
printf(" ici père[%d], Fin du fils[%d]\n",getpid(),child);
printf(" Le père[%d] se termine \n", getpid()); Le fils change de
} code exécutable
else // ce que le fils fera
{ if ((status=execl("/home/user/a.out", "a.out", NULL))==-1) jupiter% gcc fils.c
printf("le programme n' existe pas : %d\n",status); jupiter% gcc -o parent parent.c
else jupiter% parent
printf("cette instruction n’est jamais exécutée\n"); ici père[10524], mon fils[10525]
} ici programme fils [10525]
return 0; ici père[10524] Fin du fils[10525]
} Le père[10524] se termine
jupiter%

Attente de la fin d’un processus fils : exemple 5
// programme test de execvp : texecvp.c
#include <unistd.h>
#include <stdio.h>
#include <sys/wait.h>
int main (int argc , char * argv[])
{
if ( fork() == 0) // il s'
agit du fils jupiter% gcc –-o texecvp texecvp.c
{ // exécute un autre programme jupiter% texecvp date
execvp( argv[1], &argv[1]) ; mercredi, 6 septembre 2000,
fprintf(stderr, "on ne peut exécuter %s\n ", argv[1]); 16:12:49 EDT
} Le père détecte la fin du fils
else if( wait(NULL)>0 )
jupiter% texecvp ugg+kjù
printf(" Le père détecte la fin du fils\n"); on ne peut exécuter ugg+kjù
return 0 ; Le père détecte la fin du fils
}
jupiter% gcc -o fils fils.c
jupiter% fils
ici programme fils [18097]
jupiter% texecvp fils
ici programme fils [18099]
Le père détecte la fin du fils

13
Terminaison de processus
• Un processus se termine par une demande d’arrêt volontaire (appel système exit) ou
par un arrêt forcé provoqué par un autre processus (appel système kill) ou une erreur.
void exit(int vstatus);
• Lorsqu’un processus fils se termine :

– son état de terminaison est enregistré dans son PCB,
– la plupart des autres ressources allouées au processus sont libérées.
– le processus passe à l’état zombie (<defunct>).
• Son PCB et son PID sont conservés jusqu’à ce que son processus père ait
récupéré cet état de terminaison.
• Les appels système wait(status) et waitpid.(pid, status, option) permettent au processus

père de récupérer, dans le paramètre status, cet état de terminaison.
• Que se passe-t-il si le père meurt avant de récupérer ces informations?
• Si un processus est tué par un signal kill, ce signal est aussi envoyé à tous ses
processus fils.


Terminaison de processus
fork
Création
Préemption
Retour Mémoire
à usager Mémoire insuffisante
suffisante
Exécution suspension
Mode Hors mémoire
user Retour Prêt en Prêt hors
Élection mémoire mémoire
En mémoire
Interruption ou
Appel système Exécution
Mode
noyau Mise en attente
d’un evt
Arrivée de l’evt Arrivée de l’evtl
terminaison
Hors mémoire
attente Attente
Détruit Zombie en mémoire hors
mémoire
père exécute wait

14
Terminaison de processus : exemple 6
// programme deuxfils.c
#include <sys/wait.h> jupiter% gcc -o deuxfils deuxfils.c
#include <stdio.h> jupiter% deuxfils
#include <unistd.h> fin du fils1
void fils(int i) ; fin du fils2
int main() jupiter% deuxfils
{ int status; fin du fils2
if(fork()) // création du premier fils fin du fils1
{ if ( fork()==0) // création du second fils
fils(2) ;
}
else fils(1) ;
if (wait(&status)>0) printf("fin du fils%d\n", status>>8) ;
if (wait(&status)>0) printf("fin du fils%d\n", status>>8) ;
return 0 ;
}
void fils(int i)
{ sleep(2) ;
exit(i) ;
}

Terminaison de processus : exemple 7
// programme exec_wait.c
#include <unistd.h>
#include <stdio.h> Après le fork, le père remplace son Les liens père /fils
#include <sys/types.h> espace d’adressage par celui du sont maintenus
int main ( ) programme attendre_fils.c
{ pid_t p = fork();
if( p != 0)
{ execlp(“./attendre_fils”, “./attendre_fils”, NULL);
printf( “execlp a échoué\n”);
exit(-1); // programme attendre_fils.c
} #include <unistd.h>
else #include <stdio.h>
{ sleep(5); #include <sys/types.h>
printf(“Je suis le fils \n”); #include <sys/wait.h>
exit(0); int main ( )
{ printf( “J’attends le fils…\n”);
}
wait(NULL);
}
printf(“Le fils a terminé \n”);
exit(0);
}
15
Partage de fichiers entre processus père et fils
• Le fork duplique la table des descripteurs de fichiers du processus
père.

Exercice
Déterminez ce qui sera affiché à l'

exécution de ce programme :
// chaine_fork_wait.c
int main(void)
{
int i, n=5;
pid_t fils_pid;
for (i=1; i<n; i++)
{
fils_pid = fork();
if (fils_pid > 0)
{
wait(NULL);
break;
}
}
printf("Processus %d avec pere %d\n",getpid(), getppid());
}

16
Processus Windows XP
• Windows offre un certain nombre de fonctions pour permettre au programmeur et au

système d’exploitation de manipuler les processus.
• Un processus Windows se compose des éléments suivants:

– Un identificateur unique appelé ID processus.
– Un espace d’adressage virtuel privé qui est un ensemble d’adresses mémoires
virtuelles utilisables par le processus.
– Un programme exécutable qui définit le code et les données initiaux et qui est
mappé dans l’espace d’adressage virtuel du processus.
– Une liste de handles (gestionnaires) ouverts qui pointent vers diverses ressources
systèmes telles que les sémaphores, les ports de communication, les fichiers ….,
qui sont accessibles à tous les threads du processus.
– Un contexte de sécurité appelé jeton d’accès qui identifie l’utilisateur, les groupes
de sécurité et les privilèges associés au processus.
– Au moins un thread d’exécution.
• Les processus, threads, fichiers, sémaphores,… sont considérés comme des objets. À
chaque objet est associé un ou plusieurs handles

Processus Windows XP (2)

• Deux structures sont associés à chaque processus :
– typedef struct _PROCESS_INFORMATION { // pi
HANDLE hProcess, hThread;
DWORD dwProcessId, dwThreadId;
} PROCESS_INFORMATION;
– typedef struct _STARTUPINFO {

DWORD cb;
LPTSTR lpReserved, lpDesktop, lpTitle;
DWORD dwX, dwY;
DWORD dwXSize, dwYSize;
DWORD dwXCountChars, dwYCountChars;
DWORD dwFillAttribute;
DWORD dwFlags;
WORD wShowWindow;
WORD cbReserved2;
LPBYTE lpReserved2;
HANDLE hStdInput, hStdOutput, hStdError;
} STARTUPINFO, *LPSTARTUPINFO;

17
Processus Windows XP (3)
Création d’un processus
• Il y a une création d’un processus Windows lorsqu’une application appelle une
fonction de création de processus comme
– CreateProcess,
– CreateProcessAsUser,
– CreateProcessWithTokenW ou
– CreateProcessWithLogonW.
• BOOL CreateProcess(
LPCTSTR lpApplicationName, // pointer to name of executable module
LPTSTR lpCommandLine, // pointer to command line string
LPSECURITY_ATTRIBUTES lpProcessAttributes, // process security attributes
LPSECURITY_ATTRIBUTES lpThreadAttributes, // thread security attributes BOOL
bInheritHandles, // handle inheritance flag
DWORD dwCreationFlags, // creation flags
LPVOID lpEnvironment, // pointer to new environment block
LPCTSTR lpCurrentDirectory, // pointer to current directory name LPSTARTUPINFO
lpStartupInfo, // pointer to STARTUPINFO LPPROCESS_INFORMATION
lpProcessInformation // pointer to PROCESS_INFORMATION );

Processus Windows (4)

Création de processus sous Windows
#include <windows.h>
#include <stdio.h>
void ErrorExit (LPTSTR lpszMessage)
void ErrorExit (LPTSTR lpszMessage)
{
int main( )
{ STARTUPINFO si; fprintf(stderr, "%s\n", lpszMessage);
PROCESS_INFORMATION pi; ExitProcess(1);
ZeroMemory( &si, sizeof(si) ); } // fonction de gestion d’erreurs
ZeroMemory( &pi, sizeof(pi));
si.cb = sizeof(si);
// Start the child process.
if( !CreateProcess( “Fils.exe”, //name or path of executable
NULL, // no command line.
NULL, // Process handle not inheritable.
NULL, // Thread handle not inheritable.
FALSE, // Set handle inheritance to FALSE.
0, // No creation flags.
NULL, // Use parent's environment block.
NULL, // Use parent's starting directory.
&si, // Pointer to STARTUPINFO structure.
&pi ) // Pointer to PROCESS_INFORMATION structure.
)
{ ErrorExit( "CreateProcess failed." ); }
// Wait until child process exits. void main ( )
WaitForSingleObject( pi.hProcess, INFINITE ); { printf("Child sleeps 5s \n");
// Close process and thread handles.
CloseHandle( pi.hProcess ); sleep(5000);
CloseHandle( pi.hThread ); printf("done \n");
return 0; }//fichier Fils.cpp
} // Fichier Pere.cpp

18
#include <stdio.h>
void main( VOID )
{ STARTUPINFO si;
PROCESS_INFORMATION pi;
DWORD status ; // address to receive termination status
ZeroMemory( &si, sizeof(si) );
si.cb = sizeof(si);
ZeroMemory( &pi, sizeof(pi) );
if( !CreateProcess("child.exe",NULL,NULL,NULL,FALSE,0,NULL,NULL,&si,&pi))
{ printf( "CreateProcess failed (%d).\n", GetLastError() );
ExitProcess(1);
}
WaitForSingleObject( pi.hProcess, INFINITE );
if(GetExitCodeProcess( pi.hProcess, &status))
printf("I am the father. My child has terminated with (%d). \n", status);
else printf( "GetExitCodeProcess failed (%d).\n", GetLastError() );
CloseHandle( pi.hProcess );
CloseHandle( pi.hThread );
printf( “I am the father. Going to terminate.\n");
ExitProcess(0);
} // fichier Father.cpp


#include <stdio.h>
#include <tchar.h>
void main()
{
printf("I am the child. My Pid and Tid: (%d, %d).\n",
GetCurrentProcessId(), GetCurrentThreadId());
printf( "I am the child. Going to sleep for 5 seconds. \n");

Sleep(5000);
ExitProcess(10); // exit code for all threads
}// fichier child.cpp
I am the child. My Pid and Tid (1084, 1404).

I am the child. Going to sleep for 5 seconds.
I am the father. My child [1084:1404] has terminated with (10).
I am the father. Going to terminate.

19

CH 2 INF3600

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

CH 2 INF3600

Transféré par

Droits d'auteur :

Formats disponibles

Processus

• Qu’est ce qu’un processus ?

• États d’un processus

• Hiérarchie des processus

• Gestion des processus sous UNIX/LINUX

• Gestion des processus sous Windows

Génie Informatique Chapitre 2. 1

Qu’est ce qu’un processus ?

• Un processus est un programme en cours d’exécution. Il est caractérisé par :

• Cette table permet au SE de localiser et gérer tous les processus.

Génie Informatique Chapitre 2. 3

Qu’est ce qu’un processus ? (3)

• Dans la plupart des systèmes d’exploitation, le PCB est composé de deux

– La première contient les informations critiques dont le système a

– La deuxième contient les informations utilisées uniquement lorsque le

Génie Informatique Chapitre 2. 4

Programme A Mode kernel

interruption Sauvegarder état dans PCB A

Sauvegarder état en PCB B

Génie Informatique Chapitre 2. 5

États d’un processus

Attente d’admission File des prêts Fin d’exécution

File des bloqués Attente d’événement

Génie Informatique Chapitre 2. 7

États d’un processus (3)

Génie Informatique Chapitre 2. 8

• Le système d’exploitation fournit un ensemble d’appels système qui permettent la

• Les processus sont créés et détruits dynamiquement.

• Dans certains systèmes (MS-DOS), lorsqu’un processus crée un processus, l’exécution

• Dans Windows, les processus créateurs et créés s’exécutent en concurrence et sont de

Génie Informatique Chapitre 2. 9

Hiérarchie des processus (2)

• Ensuite, d’autres processus sont crées à partir du processus init.

• Chaque processus pointe vers le processus parent (processus créateur).

• Si le parent se termine, il n’y a pas d’actualisation de cette information.

Génie Informatique Chapitre 2. 11

• Chaque processus a un père, à l’exception du premier processus créé (structure

• Un processus père s’exécute en concurrence avec ses fils (exécution asynchrone).

• La création de processus est réalisée par duplication de l’espace d’adressage et de certaines

Génie Informatique Chapitre 2. 13

Processus d’UNIX (3) :

Génie Informatique Chapitre 2. 14

• L’appel système fork :

• La valeur de retour est :

• Au retour de la fonction fork, l’exécution des processus père et fils se poursuit, en

Processus d’UNIX (5) :

• le père récupèrera dans sa

• le fils récupérera dans sa

Processus d’UNIX (7)

jupiter% tfork a du père

Génie Informatique Chapitre 2. 18

// programme Arborescence.c : appel système fork()

Génie Informatique Chapitre 2. 19

Processus d’UNIX (9)

Génie Informatique Chapitre 2. 21

Processus d’UNIX (11)

• Ces appels permettent d’exécuter de nouveaux programmes.

• Le processus conserve, notamment, son PID, l’espace mémoire alloué, sa table

• En cas de succès de l’appel système exec, l’exécution de l’ancien code est

• En cas d’échec, le processus poursuit l’exécution de son code à partir de

Génie Informatique Chapitre 2. 22

Génie Informatique Chapitre 2. 23

Processus d’UNIX (13)