Ce document traite des concepts de systèmes d'exploitation, notamment la planification des processus, la communication inter-processus (IPC), et divers algorithmes de planification tels que le round robin et le shortest process next. Il aborde également des problématiques comme l'inversion de priorité, la famine, et la gestion des signaux, illustrant ces concepts par des exemples de code. Enfin, il mentionne les processus orphelins et zombies ainsi que différentes méthodes d'IPC comme les pipes et les sockets.

1. Systèmes
d'exploitation
Planification, IPC

2. Bibliographie pour aujourd'hui
• Modern Operating Systems
– Chapitre 2
• 2.3
• 2.5
• Operating Systems Concepts
– Chapitre 6
2

3. Margaret Hamilton
• Américaine
• MIT Instrumentation Lab
• Apollo Guidance
Computer
3

4. Contenu
• Planification
– Non-préemptif
– Préemptif
• IPC
– signal
– pipe
– socket
4

5. SYSTÈMES INTERACTIFS
5

6. Systèmes Interactifs
• Paramètres optimisé
– Wait Time
– Fairness
• Algorithmes
– Round Robin (RR)
– Classes des Priorisées
– Shortest Process Next (SPN)
6

7. Round Robin
• FCFS Préemptif
– Quantum de temps
• Grand Quantum de temps
– Grand throughput
– Grand Wait Time
• Pietit Quantum de temps
– Petit throughput
• Temps pur le changement
de contexte este grand
– Petit Wait Time
7

8. Classes des Priorisées
• Round Robin
– avec de processus plus important que autres
• Plusieurs files d'attente
8

9. Classes des Priorités
Windows
• Priority
– 0 Système
– 1 a 15 User
– 16 a 30 temps réel
Linux
9
• Priority
– 0 a 99 temps reel
– 100 a 139 user
• Nice
– -20 a 19
• Priority effective
– 100 + 20 + NI

10. Classes des Priorités (Linux)
10

11. Shortest Process Next
• SJF Préemptif
• Estimation basée sur le comportement
précédent
• T0 - quantum de temps estimée
• T1 - quantum de temps réel
• a - âgée
• Quantum de temps suivante
– a * T1 + (1-a) * T0
11

12. TEMPS RÉEL
12

13. Temps Reel
• Limite maximale
– Turnaround
– Wait Time
• Hardware
– ressources alloue
• Software
– Les processus de temps réel ont la priorité
maximale
– Les autres processus sont retardé
13

14. Priority Inversion
• Un processus avec un priorité petit (P1) prend
un ressource
• Un autre processus avec un priorité plus grand
(P2) a besoin de cette ressource
• Processus P2 a la même priorité avec le
processus P1
14

15. Priority Boosting
• Augmenter la priorité pendant un temps
limité
• À la réception des données d’E/S
– En dépendant de Wait Time
• Un autre processus avec un priorité plus
grande attend un ressource bloque par le
processus
15

16. Starvation
• Un processus ne prend pas le CPU pour un
long temps
16

17. FERMER UN PROCESSUS
17

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

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

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

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

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

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

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

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

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

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

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

29. COMPLETELY FAIR SCHEDULER
29

30. Completly Fair Scheduler
• Virtual Runtime (vruntime)
– Temp d’utilisation de CPU
• Arbre Rouge - Noir
– ordonné par la vruntime
• Processus nouveau
– vruntime = vruntime minimale
30

31. Completly Fair Scheduler
31

32. IPC - COMMUNICATION ENTRE
PROCESSUS
32

33. Processus
• processus - une unité d'exécution
• Chaque processus a:
– Propre espace mémoire virtuel
– Tableau de descripteurs
• processus de séjour:
– READY
– RUNNING
– WAITING
• Multitasking
33

34. IPC
• signaux (Linux)
• pipe
• mémoire partagé
• socket
34

35. Signaux
• Une notification à un processus
• SO peut transmettre des évènements a un
processus
• SO découvre un événement (par exemple une
interruption)
– SO arrête le processus (où il est frappé)
– Le signal handler fonctionne
– Le processus continue là où il en reste
35

36. Signaux
36

37. Liste des signaux - Linux
1) SIGHUP 2) SIGINT 3) SIGQUIT 4) SIGILL
5) SIGTRAP 6) SIGABRT 7) SIGBUS 8) SIGFPE
9) SIGKILL 10) SIGUSR1 11) SIGSEGV 12) SIGUSR2
13) SIGPIPE 14) SIGALRM 15) SIGTERM 17) SIGCHLD
18) SIGCONT 19) SIGSTOP 20) SIGTSTP 21) SIGTTIN
22) SIGTTOU 23) SIGURG 24) SIGXCPU 25) SIGXFSZ
26) SIGVTALRM 27) SIGPROF 28) SIGWINCH 29) SIGIO
30) SIGPWR 31) SIGSYS 33) SIGRTMIN 34) SIGRTMIN+1
35) SIGRTMIN+2 36) SIGRTMIN+3 37) SIGRTMIN+4 38) SIGRTMIN+5
39) SIGRTMIN+6 40) SIGRTMIN+7 41) SIGRTMIN+8 42) SIGRTMIN+9
43) SIGRTMIN+10 44) SIGRTMIN+11 45) SIGRTMIN+12 46) SIGRTMIN+13
47) SIGRTMIN+14 48) SIGRTMIN+15 49) SIGRTMAX-15 50) SIGRTMAX-14
51) SIGRTMAX-13 52) SIGRTMAX-12 53) SIGRTMAX-11 54) SIGRTMAX-10
55) SIGRTMAX-9 56) SIGRTMAX-8 57) SIGRTMAX-7 58) SIGRTMAX-6
59) SIGRTMAX-5 60) SIGRTMAX-4 61) SIGRTMAX-3 62) SIGRTMAX-2
63) SIGRTMAX-1 64) SIGRTMAX
37

38. Envoyer un signal
• Shell
– kill -numero_signal pid
• POSIX
– int kill(pid_t pid, int sig);
– int sigqueue(pid_t pid, int sig,
const union sigval value);
38

39. Action sur réception d'un signal
• Action implicite
– fermer processus (généralement)
• Action utilisateur
– signal handler
• Ignorance
– sauf SIGKILL et SIGSTOP
39

40. Action Utilisateur
int sigaction(int signum,
const struct sigaction *act, struct
sigaction *oldact);
struct sigaction {
void (*sa_handler)(int);
void (*sa_sigaction)(int, siginfo_t *, void *);
sigset_t sa_mask;
int sa_flags;
};
40

41. Exemple
static void usr2_handler(int signum) {
/* actions that should be taken when the signal signum
is received */
...
}
int main(void) {
struct sigaction sa;
memset(&sa, 0, sizeof(sa));
sa.sa_flags = SA_RESETHAND; /* restore handler to
previous state */
sa.sa_handler = usr2_handler;
sigaction(SIGUSR2, &sa, NULL);
return 0;
}
41

42. Mask des signaux
int sigemptyset(sigset_t *set);
int sigfillset(sigset_t *set);
int sigaddset(sigset_t *set, int signo);
int sigdelset(sigset_t *set, int signo);
int sigismember(sigset_t *set, int
signo);
42

43. PIPE
43

44. Anonymes
• Communication entre processus liés (parent /
enfant)
• Fonction pipe
– Retourne deux descripteurs:
• l'un utilisé pour écrire
• un autre pour lire
44

45. Anonymes
45

46. Pipe Exemple Linux
int p[2];
int rc;
rc = pipe (p);
if (rc < 0)
{
perror ("pipe");
}
else
{
// p[0] <- read from here
// p[1] -> write here
}
46

47. Pipe Exemple Linux
int p[2];
int rc, pid;
char buffer[BUFFER_SIZE];
rc = pipe (p);
if (rc < 0) {
perror ("pipe");
}
else
{
pid = fork ();
if (pid == 0) {
close (p[1]);
read (p[0], buffer, BUFFER_SIZE);
// ...
}
else
if (pid > 0) {
close (p[0]);
memcpy (buffer, ..., BUFFER_SIZE);
write (p[1], buffer, BUFFER_SIZE);
// ...
}
}
47

48. Nommés
• mkfifo / mknod
• Utilisé comme un fichier normal
– open
– read, write
• Half-duplex (Linux)
48

49. Exemple Linux
int mkfifo(const char *pathname, mode_t mode);
49

50. AUTRES SYSTEMES IPC
50

51. Mémoire partagé
• Chaque processus a sa propre mémoire
– Une zone de mémoire peut être partagée entre
processus
• shmget / shmat
• mmap
• Communication sans overhead
– Pas de traversée dans le noyau
– Accès à la mémoire
– Nécessite une synchronisation
51

52. socket
• La forme de IPC la plus répandue
– sockets Unix: similaire aux pipes nommées
• BSD sockets
– TCP / UDP
– Cross-machine
– Synchronisation explicite
• API: flux d'octets fiable
– socket / connect / accepter / envoyer / recv
52

53. Mot clés
• Planification
• Procession en
background
• Job
• Systèmes interactifs
• Process
• Temps réel
• Shortest Job First
• Shortest Remaining Job
• First
• Round Robin
• Shortest Process Next
• Priorité
• Priority Inversion
• Priority Boosting
• Starvation
• Completly Fair
Scheduler
53

54. Questions
54