Le document traite des processus dans les systèmes d'exploitation, expliquant leur définition, leur structure, ainsi que leurs états (exécution, attente, prêt). Il couvre également des concepts comme la planification des processus, la création de nouveaux processus via fork et exec, et la gestion des processus orphelins et zombies. Des exemples de fonctionnement sur Unix et Windows illustrent la création, l'exécution et la terminaison des 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. PLANIFICATION DES PROCESSUS
23

24. Processus et processeurs
• Pour exécuter un processus, il faut un
processeur
• Le processeur exécute les instructions de
processus
• Les processus dans un système sont plus que
des processeurs
• Le système d'exploitation fournit un accès
équilibré aux processeurs pour les processus
24

25. Multitasking
• SE traite rapidement les processus sur les
processeurs
• Après un certain temps (quantum, time slice), un
processus est supprimé du processeur et mis en
place un autre.
– on dit que "le quantum expire"
– l'action s'appelle "changement de contexte"
• Le quantum est millisecondes
– les processus changent très rapidement
– l'impression de courir simultanément

26. Le statut d'un processus
• exécution (RUNNING)
– Le processus s'exécute sur un processeur
• attendre (WAITING)
– le processus a exécuté une action bloquante (par exemple, lecture
d'E/S) et attend l'arrivée des données; ne peut pas s’exécuter
• prêt d’exécution (READY)
– le processus peut s'exécuter sur le processeur
• Combien de processus peuvent être trouvés dans les
chaque état?
• Comment assureriez-vous la gestion des processus dans les
trois états?
26

27. Transitions entre les états
27

28. Transitions entre les états
• RUNNING -> READY
– le quantum de processus a expiré
– il y a un autre processus dans l'état
READY avec une priorité supérieure
• RUNNING -> WAITING
– le processus a exécuté une opération
bloquante
• WAITING -> READY
– l'événement de processus attendu
s'est produit
• READY -> RUNNING
– un processeur a été libéré
– le processus est le premier dans la
file d'attente des processus READY
28

29. Multitasking
29

30. Planification (scheduling)
• Un processus est amené de l'état READY à
RUNNING
– Il est amené s'il y a un processeur libre
• Un processeur est libre si
– il n'y a pas de processus en cours d'exécution
• On dit qu'il y a un changement de contexte
(context switch)
30

31. Types de SE (dpdv. planificateur)
• Préemptive
– les processus sont arrêtés à l'expiration de la
quantum de temps
• Windows, macOS, Linux, UNIX, Minix etc.
• Non-préemptive (coopératif)
– les processus doivent s'arrêter (s'ils le souhaitent)
à l'expiration de la quantum de temps
• mac OS <= 9
31

32. Changement de contexte
• Un processus est remplacé sur le processeur par un
autre processus
• Enregistre l'ancien processus / contexte
• Restauration du nouveau processus / contexte
• Un changement de contexte signifie des overhead
– plus de changements de contexte: plus de overhead
– moins de changements de contexte: moins d'interactivité
32

33. Changement de contexte
33

34. Planificateur de processus
• Composant de SE
• Agent de planification des processus
– assurer l'accès de processus aux processeurs
– compromis (tarde-off) entre équité et productivité
34

35. CREATION D’UN PROCESSUS
35

36. 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)
36

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

38. 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.
38

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

40. 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
40

41. Espace d'adressage (virtuel)
41

42. 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);
}
42

43. 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
43

44. 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
44

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

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

47. 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 ());
}
47

48. 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
48

49. 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[]);
49

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

51. Exemple
51

52. 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
52

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

54. 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 ();
}
}
54

55. 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 55

56. FERMER UN PROCESSUS
56

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

58. 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
58

59. 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)
59

60. 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
60

61. 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
61

62. 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;
}
62

63. 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));
}
63

64. 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)
64

65. 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
65

66. 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
66

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

68. 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
68

69. Questions
69