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
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
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
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
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
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
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
44. Anonymes
• Communication entre processus liés (parent /
enfant)
• Fonction pipe
– Retourne deux descripteurs:
• l'un utilisé pour écrire
• un autre pour lire
44
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