Communication entre processus et planification

1. Systèmes
d'exploitation
Communication entre
processus
Planification

2. Ingo Molnar
• Hongrois
• RedHat
• Completly Fair Scheduler
2

3. Contenu
• IPC
– signaux
– pipe
– mémoire partagé
– socket
• Planification
– Non-préemptif
– Préemptif
3

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

5. IPC - COMMUNICATION ENTRE
PROCESSUS
5

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

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

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

9. Signaux
9

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

11. 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);
11

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

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

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

15. 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);
15

16. PIPE
16

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

18. Anonymes
18

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

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

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

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

23. AUTRES SYSTEMES IPC
23

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

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

26. PLANIFICATION
26

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

28. 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?
28

29. Transitions entre les états
29

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

31. Fonctionnement d’un processus
31

32. Changement de contexte
32

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

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

35. Definition
Definition Description
WT Wait Time Temps d'attente pour recevoir le CPU
MWT Mean Wait Time Temps d'attente moyen pour la réception du CPU
TT Turnaround Time Temps d'exécution total du processus
MTT Mean Turnaround Time Le temps total moyen d'exécution du processus
J Job Processus en background
P Process Processus interactif
35

36. Systeme ideal
• Wait Time Minimale
– les processus attendent le moins possible en READY
– interactif
• Turnaround Minimale
– processus à s’exécuter le plus rapidement possible
– productif
• Fairness
– toutes le processus doit avoir accès aux CPU
36

37. Types de systemes
• Procession en background
– Batch Job
– N’a pas d’interaction avec l’utilisateur
• Interactif
– Process
– Interaction avec l’utilisateur
• Temps réel
37

38. PROCESSION EN BACKGROUND
38

39. Procession en background
• Paramètres optimisé
– Throughput
• Numéro de processus fini / unité de temps
– Turnaround time
– Utilisation de CPU
• Algorithmes
– First Come First Served (FCFS)
– Shortest Job First (SJF)
– Shortest Remaining Time First (SRTF)
39

40. First Come First Served
• Simple d’implémenter
• Les processus CPU Bound ralentissent les
processus I/O Bound
• Grand MWT et TT
40

41. Exemple
Job Temp d’execution
J1 24
J2 3
J3 3
J4 5
• Calculez
– TT
– MTT
• J1, J2, J3, J4
• J2, J1, J4, J3
41

42. Shortest Job First
• Simple d’implémenter
• Le temps d'exécution de chaque processus
doit être connu
42

43. Exemple
Job Temp d’execution
J1 12
J2 9
J3 5
J4 20
• Calculez
– TT
– MTT
• FCFS
– J1, J2, J3, J4
• SJF
– J3, J2, J1, J4
43

44. Shortest Remaining Time First
• Version préemptif pour SJF
• Simple d’implémenter
• Le temps d'exécution de chaque processus
doit être connu
44

45. Exemple
Job Temp d’execution Temp d’arrive
J1 8 0
J2 4 1
J3 9 2
J4 4 3
• Calculez
– TT
– MTT
• FCFS
– J1, J2, J3, J4
• SJF
– J3, J2, J1, J4
• SRTF
45

46. SYSTÈMES INTERACTIFS
46

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

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

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

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

51. Classes des Priorités (Linux)
51

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

53. TEMPS RÉEL
53

54. 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é
54

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

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

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

58. COMPLETELY FAIR SCHEDULER
58

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

60. Completly Fair Scheduler
60

61. Mot clés
• Signaux
• Pipe
• Mémoire partage
• Socket
• 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
61

62. Questions
62