Processus

1. Systèmes
d'exploitation
Processus

2. Linus Torvalds
• Finlandais
• Étudiant à Helsinki
• Git
• Linux

3. Contenu
• Processus
– Rôle
– Attributs
• Planification
• Démarrage de SE
• Hiérarchie de processus
• Créer un processus
– Autres opérations de
traitement
• Fermer un processus
• API pour travailler avec des
processus
3

4. Bibliographie pour aujourd'hui
• Modern Operating Systems
– Chapitre 2
• 2.1
• Operating Systems Concepts
– Chapitre 3
4

5. Processus
• le unité de base du exécution
• en SE, il y a deux abstractions de base
– fichier - abstraction pour l’information / les données
– processus – abstraction pour des actions
5

6. PROCESSUS
6

7. Qu'est-ce qu'un processus?
• Un programme en cours d'exécution
• Encapsulation / abstraction de l'exécution
dans SO
• Abstraction sur processeur, mémoire, E / S
SO: Curs 3: Procese 7

8. 8
Processus
1
Noyau de SE
Processus
2
Processus
3
MemoireCPU
Temps
E/S
Stockage

9. API utilisée par les processus
9
processeur memoire E/S
threads memoire
virtuelle
descripteurs
de fichiers

10. Processeur
• Un processus a un ou plusieurs threads
– Un thread exécute des instructions sur un
processeur
• En règle générale, les processus système sont
plus que des processeurs système
– La planification des processus sur les processeurs
est nécessaire
10

11. Processeur
11

12. Memoire
• Un processus a sa propre mémoire (isolée des
autres processus)
– Code
– Instructions
– Données
• Les instructions sont amenées de la RAM dans
le processeur et exécutées
– Nous disons que le processus s'exécute sur le
processeur
SO: Curs 3: Procese 12

13. Espace d'adressage (virtuel)
• Chaque processus a un espace d'adressage
(virtuel)
– Assure l'isolement des autres processus
– Le processus a l'impression d'utiliser
exclusivement la mémoire
• Toutes les ressources de mémoire (code,
données, bibliothèques, pile) sont référencées
par zones dans l'espace d'adressage virtuel
13

14. Espace d'adressage (virtuel)
14

15. E/S
• Un processus communique avec l'extérieur:
disque, réseau, clavier, moniteur
• La communication se fait généralement par les
descripteurs de fichiers.
– tableau de descripteurs de fichier
– descripteur de fichier: un fichier, un socket, un
terminal, un périphérique, etc.
• Les opérations d'E/S bloque le processus
– E/S est plus lent que le processeur
– le processus attend la fin de l'opération
15

16. Tableau de descripteur de fichier
16
L’interface E/S de processus

17. Types de processus (CPU)
• CPU bound (CPU intensive)
– utilise beaucoup le processeur
• I/O bound (I/O intensive)
– utilise rarement le processeur
– faire des opérations d'E / S -> se bloque
17

18. Types de processus (Utilisateur)
• Interactif (foreground)
– interagir avec l'utilisateur
• Non interactif (batch, background)
– services, démons
18

19. LES ATTRIBUTES D’UN PROCESSUS
19

20. A quoi ressemble un processus SE?
• PID (Process ID)
– le identifiant de processus
• PCB (Process Control Block)
– Une structure de données
– Décrit un processus au niveau SO
• Informations sur les ressources utilisées
• Liens vers d'autres structures
• Sécurité, surveillance, informations comptables
20

21. Ressources
• Temps d’execution sur processeur
• Mémoire (code et données)
• Tableau des descripteurs de fichiers
• Certaines ressources peuvent être partagées
avec d'autres processus
SO: Curs 3: Procese 21

22. Attributs d'un processus
• PID
• parent PID
• pointeurs vers les ressources
– tableau de descripteurs, tableau de mémoire …
• état (en cours, en attente)
• le quantum de temps d'exécution
• comptabilisation des ressources consommées
• utilisateur, groupe
22

23. CREATION D’UN PROCESSUS
23

24. Nouveau processus
• À partir d'un exécutable (programme)
• Un autre processus (parent) crée un processus
(enfant)
• Le nouveau processus (processus enfant) remplit
sa mémoire avec des informations exécutables
– L'action s'appelle également load, load time
– fait par le chargeur (loader)
24

25. Hiérarchie des processus
• Un processus peut créer un ou plusieurs
processus enfants.
• Un procès peut avoir un processus parent
25

26. Démarrage - UNIX
• init est au sommet de la hiérarchie des processus
– PID 1
• init est créé par le noyau au boot
• init crée ensuite les processus de démarrage
• les processus de démarrage créent d'autres
processus, etc.
26

27. Démarrage - Windows
• Il n’existe pas un hiérarchie propre
• csrss.exe - Client Server Runtime Process
• winlogon.exe - Login Manager
• services.exe - Services
27

28. Processus et exécutables
• Un ou plusieurs processus proviennent d'un fichier
exécutable
• Le fichier exécutable contient essentiellement les
données et le code du futur processus
• Le processus a aussi des zones de mémoire non
décrites dans l'exécutable associé
– stack
– heap (malloc)
– zones pour bibliothèques dynamiques
28

29. Espace d'adressage (virtuel)
29

30. Nouveau Processus - Windows
if (!CreateProcess(NULL, "notepad", NULL, NULL,
TRUE, NORMAL_PRIORITY_CLASS, NULL, NULL, &pi)) {
printf("Cannot execute notepad.n");
}
else {
printf("notepad runningn");
printf("notepad handle is 0x%xn", pi.hProcess);
// ...
CloseHandle (pi.hProcess);
}
30

31. Nouveau Processus - UNIX
• Séparation entre la création d'un nouveau
processus et le chargement de données à partir
d'un exécutable
• fork: créer un nouveau processus (enfant)
(presque identique au processus parent)
• exec: chargement d'informations d'un exécutable
dans la mémoire du processus enfant
31

32. fork
• Nouveau processus
• Une clone de processus parent
• retour deux fois
– en parent
– en enfant
• Le nouveau processus a
– Un copie de PCB
– Nouveau PID
– Nouveau tableau des descripteurs (avec les même pointeurs)
– Un copie de la mémoire
32

33. fork bomb
while (1)
{
fork ();
}
33

34. fork bomb
while (1)
{
fork ();
}
34

35. Nouveau Processus - UNIX - fork
pid_t pid = fork ();
if (pid < 0) {
perror ("fork");
}
else if (pid > 0) {
// This is the parent process
printf ("Child process PID is %dn", pid);
}
else {
// This is the child process
printf ("My PID is %dn", getpid ());
}
35

36. exec
• Charge un nouveau exécutable
• Remplace les donnes d’exécutable courent
(l’image) avec les données chargées
d’exécutable
• ne retour pas
36

37. Nouveau Processus - UNIX - exec
int execl(const char *path, const char *arg0, ...
/*, (char *)0 */);
int execle(const char *path, const char *arg0, ...
/*, (char *)0, char *const envp[] */);
int execv(const char *path, char *const argv[]);
int execve(const char *path, char *const argv[],
char *const envp[]);
int execvp(const char *file, char *const argv[]);
37

38. Nouveau Processus - UNIX - exec
if (!execl ("/usr/bin/cowsay", "/usr/bin/cowsay",
"Hello", NULL))
{
perror ("execl");
abort ();
}
// if successful, this is never executed
38

39. Exemple
39

40. Exemple
1. Une chaîne est écrite au stdin
2. La chaîne est interprétée par le shell dans un chemin
d’exécutable (et des arguments)
3. Le processus shell crée un nouveau processus (fork)
– Le processus enfant est planifié par le planificateur
4. Le processus enfant "charge" les données et le code
de l'exécutable (exec)
– Le processus parent du processus enfant est le processus
shell
5. Le processus parent attend le fini du processus enfant
40

41. Exemple
41
shell
parent
shell
child
fork()
child
exec(“/bin/ls”)
ls
shell
parent
wait()

42. Exemple
int status;
pid_t pid = fork ();
if (pid < 0) {
perror ("fork");
abort ();
}
else
if (pid > 0) {
// This is the parent process
// printf ("Child process PID is %dn", pid);
waitpid (pid, &status, 0);
}
else {
// This is the child process
if (!execl ("/bin/ls", "/bin/ls", "-l", NULL)) {
perror ("Error loading /bin/lsn");
abort ();
}
}
42

43. fork, exec et redirection
int fd;
pid_t pid = fork ();
if (pid == 0)
{
// redirect
fd = open ("output", O_TRUNC | O_WRONLY | O_CREAT, 0644);
dup2 (fd, 1);
if (!execl ("/bin/ls", "/bin/ls", "-l", NULL))
{
perror ("Error loading /bin/lsn");
abort ();
}
}
SO: Curs 3: Procese 43

44. FERMER UN PROCESSUS
44

45. Fermer un processus
• Terminer l’exécution
• Fermé par le SE
45

46. Terminer l'exécution d'un processus
• Le processus termine sa exécution
– arrivé la fin du programme
– appelé exit
• La décision c’est au processus
46

47. Fermé par le SE
• Le SE ferme le processus
– à la demande d'un autre processus (kill)
– le processus a effectué une erreur
• Envoyer un signal (Unix) ou une exception
(Windows)
47

48. Effacer le processus
• Le SE efface toute les informations du
processus
– PCB
– PID
– Tableau des descripteurs
– Mémoire alloue
– …
• Le SE envoie un signal (Unix) / message
(Windows) aux processus parent
48

49. Attendre le fin du processus
• Synchroniser l'action de certains processus
– tu fais X après Y
– le processus qui fait l'action X attend la fin de
l'exécution du processus qui fait l’action Y
• Cela s'appelle "attendre un processus"
• Informations utiles sur le fin du processus
– la valeur de retour
49

50. La valeur de retour
int main ()
{
// do some work ...
if (error)
{
// exit with an error code, here -120
exit (-120);
}
// exit without error, success
return 0;
}
50

51. Exemple
int fd, status;
pid_t pid = fork ();
if (pid == 0)
{
// child
if (!execl ("/bin/ls", "/bin/ls", "-l", NULL))
{
perror ("Error loading /bin/lsn");
abort ();
}
}
else if (pid > 0) {
// parent
waitpid (pid, &status, 0);
printf ("/bin/ls exited with %dn", WEXITSTATUS (status));
}
51

52. Processus orphelin
• Un processus dont le parent a terminé sa
exécution
• Il perd sa connexion dans la hiérarchie des
processus
• Il est adopté par un processus dédié (init sur
Unix)
52

53. Processus zombie
• Un processus qui s'est terminé mais n'était pas
attendu
– Les informations résiduelles restent (elles prouvent
être utilisé par le processus parent)
• Si un processus zombie reste orphelin, il est
adopté par init puis il est terminé
• Les processus zombies plus longs occupent (en
vain) les ressources de système
53

54. Le operateur shell &
• En règle générale, le shell attend le fin des
processus créés
• L'opérateur &: shell n'attend plus la fin du
processus
– le processus s'exécute en background
– le shell contrôle le stdin
54

55. Exemple
55
shell
parent
shell
child
fork()
child
exec(“/bin/ls”)
ls
shell
parent

56. Mot clés
• Processus
• Multitasking
• Planificateur
• Etat
• NEW
• RUNNING
• READY
• WAITING
• TERMINATE
• init
• Hiérarchie des processus
• CreateProcess
• fork
• exec
• exit
• Wait
• valeur de retour
• processus orphelin
• processus zombie
• processus en background
56

57. Questions
57