Syst`emes temps r´eel et syst`emes embarqu´es
Syst`emes d’exploitation
Jacques Gangloff, Lo¨ıc Cuvillon 15 f´evrier 2008
Plan
Plan
Table des mati`eres
1 Introduction 1
1.1 Plan du cours . . . 1
1.2 Bibliographie . . . 2
1.3 D´efinition . . . 2
1.4 Historique . . . 2
1.5 Concepts de base . . . 5
1.6 Architectures de syst`emes d’exploitation . . . 7
2 Processus 8 2.1 Introduction . . . 8
2.2 Communication inter-processus (IPC) . . . . 10
2.3 Ordonnancement (scheduling) . . . . 13
1 Introduction
1.1 Plan du cours
Introduction – D´efinition – Historique – Concepts de base – Appels syst`eme – Architectures
Processus – Introduction – IPC
– Ordonnancement
Entr´ees-sorties – Acc`es au mat´eriel
– Gestionnaire de p´eriph´erique – Situations de blocage Gestion de la m´emoire
– Notions de base – M´emoire virtuelle – Segmentation Syst`eme de fichiers
– Fichiers et r´epertoires – Architecture
– S´ecurit´e et protection
1.2 Bibliographie
A. Tannenbaum et A. Woodhull
Operating systems – Design and implementation Prentice Hall 2006, troisi`eme ´edition.
A. Tannenbaum
Modern operating systems Prentice Hall, deuxi`eme ´edition.
1.3 D´efinition
D´efinition
Un syst`eme d’exploitation (Operating System ou OS en anglais) est un programme r´ealisant les fonctions ´el´ementaires suivantes :
– Gestion des ressources physiques de l’ordinateur (temps cpu, m´emoire, p´eriph´eriques) – Protection de l’int´egrit´e des donn´ees stock´ees et ex´ecut´ees (en m´emoire, sur les
unit´es de stockage)
– Assurer un niveau d’abstraction du mat´eriel pour l’utilisateur
1.4 Historique
La pr´ehistoire 1642 – La Pascaline
Blaise Pascal invente en 1642 une machine `a calculer m´ecanique r´ealis´ee `a l’aide d’en- grenages. Elle permettait de r´ealiser des additions et des soustractions. Environ 50 ex- emplaires furent fabriqu´es mais ce fut un ´echec commercial en raison d’un prix de re- vient ´elev´e. En m´emoire de sa contribution `a l’histoire de l’informatique, Pascal donna son nom `a un langage de programmation.
La pascaline – mus´ee des arts et m´etiers – Paris
1822 – Babbage & Lovelace
Charles Babbage invente la machine `a diff´erence destin´ee `a faire des calculs polynˆomiaux `a l’aide de diff´erences finies, puis la machine analytique qui jette les bases de l’informatique moderne. Il invente ainsi les concepts de machine s´equentielle, de s´eparation des donn´ees et des codes d’ex´ecution, de branchement condition- nel, de boucles d’ex´ecution et de p´eriph´erique d’impression. Il collabore avec la math´ematicienne Ada Lovelace qui ´ecrit pour sa machine ce qui est consid´er´e comme le tout premier programme informatique : un algorithme de calcul des nombres de Bernoulli. Pour des raisons technologiques (elle devait peser 13 tonnes et ´etait con- stitu´ee de 25000 pi`eces), il ne pourra jamais terminer sa machine. Elle fut n´eanmoins achev´ee apr`es sa mort et permis de r´ealiser des calculs avec une pr´ecision de 31 chiffres significatifs.
La machine de Babbage
Ada Lovelace
L’antiquit´e
1945-1955 – Relais et tubes `a vide
A cette ´epoque les ordinateurs sont constitu´es de relais et/ou d’amplificateurs `a base de tubes `a vide (par exemple l’ENIAC, 30 tonnes, 17500 tubes `a vide, 1500 relais, maximum 5 jours sans panne). Alan turing invente la machine qui porte son nom et avec elle la notion d’algorithme. John Von Neumann donne son nom `a l’architecture moderne des ordinateurs : une unit´e de contrˆole, une unit´e arithm´etique et logique, une m´emoire, des entr´ees-sorties. La notion de syst`eme d’exploitation est toujours inconnue
`a cette ´epoque.
ENIAC – U.S. Army’s Ballistic Research Laboratory
La renaissance
1955-1965 – La r´evolution du transistor
L’utilisation du transistor en informatique `a partir de 1955 fut une v´eritable r´evolution.
Le prix et surtout la fiabilit´e des ordinateurs s’am´eliora de mani`ere drastique. Les or- dinateurs de cette ´epoque se nommaient mainframes et ´etaient encore r´eserv´es aux in- stitutions (par exemple l’IBM 7094 avec environ 128 Ko de m´emoire et une fr´equence d’horloge inf´erieure `a 1 MHz). Ils n´ecessitaient un personnel pl´ethorique pour sa main- tenance. On assiste au d´eveloppement d’un embryon de syst`eme d’exploitation : les syst`emes de batch.
Dual IBM 7090 – NASA – Projet mercury
L’´epoque moderne
1965-1980 – La naissance des syst`emes d’exploitation – Apparition des circuits int´egr´es (IBM 360)
– Apparition de la notion de multiprogramming (OS/360)
– Apparition de l’un des premiers syst`emes d’exploitation `a temps partag´e : CTSS (Compatible Time-Sharing System). Invention du concept de shell.
IBM 360
1965-1980 – La naissance des syst`emes d’exploitation
– Invention de l’ancˆetre de tous les syst`emes d’exploitation : MULTICS (MULTi- plexed Information and Computing Service) par le MIT, les Laboratoires Bell et General Electrics. Apports de MULTICS :
– Multi-tˆaches, multi-utilisateurs
– Syst`eme d’invite de commande `a la base du shell actuel
– Notion d’anneaux permettant d’isoler l’ex´ecution du code entre utilisateurs – Segmentation et m´emoire virtuelle
– Syst`eme de fichiers hi´erarchis´e, nom longs, liens symboliques, fichiers p´eriph´eriques – Apparition d’UNIX : 2 principales versions, System V et BSD. Plus tard, IEEE
a d´evelopp´e une norme pour rendre le d´eveloppement sous UNIX compatible : POSIX.
L’´epoque contemporaine
1980-nos jours – La d´emocratisation – Miniaturisation des circuits int´egr´es
– INTEL commercialise le 8086 en 1980 tandis que Motorola sort le 6502 – Apparition de l’IBM PC (Personal Computer) ´equip´e du syst`eme d’exploitation
MS/DOS et du langage de programmation Microsoft BASIC
– Apparition du Macintosh : interface graphique utilisant des fenˆetres et la souris comme pointeur
– Windows 1.0 : pˆale tentative de copie de l’interface d’Apple par Microsoft
IBM PC
1980-nos jours – La d´emocratisation
– Invention de Xwindows par le MIT en 1984
– D´eveloppement de Windows NT (partenariat Microsoft-IBM initi´e en 1990) qui a conduit `a Windows XP (NT 5.1) et Windows Vista (NT 6.0).
– Naissance de Linux en 1991, UNIX-like compatible POSIX, open-source, multi- plateformes
– Apparition de MAC OSX d´eriv´e d’un UNIX BSD 4.4 compatible POSIX – Invention du concept de syst`emes d’exploitation distribu´es
Ordinateur XO du projet OLPC
1.5 Concepts de base
Concepts de base Le Noyau (Kernel)
– Programme r´ealisant toutes les fonctions du syst`emes d’exploitation
– En g´en´eral, le noyau a le degr´e de privil`ege maximum pour l’acc`es aux ressources mat´erielles
– Le syst`eme d’exploitation (Operating Systems ou OS) est constitu´e du noyau et de diverses applications p´eriph´eriques
Les processus (processes) – Programme en ex´ecution – Contexte d’un processus :
– Espace d’adressage propre contenant le code ex´ecutable, les donn´ees, une pile – Liste de zones m´emoire accessibles
– Registres : compteur d’instruction, compteur de pile, indexes, registres de cal- cul en virgule flottante (Floating Point Unit ou FPU), ...
– Dans la plupart des syst`emes d’exploitation, les informations relatives `a la ges- tion du processus sont stock´ees dans la table des processus (process table) – Les processus sont lanc´es par exemple au moyen d’un interpr´eteur de commande
(shell). Sous UNIX, le premier processus lanc´e au moment du d´emarrage est un script nomm´einit
– Un processus peut cr´eer un ou plusieurs processus enfant(s) (child process) – Les processus peuvent communiquer ou se synchroniser entre eux : on parle de
communication inter-processus (Inter-Process Communication ou IPC)
– Le syst`eme d’exploitation peut envoyer des signaux aux processus (alarm sig- nals)
Le mode utilisateur (user) et le mode noyau (kernel)
– Un processeur moderne a plusieurs modes de fonctionnement (rings)
– Dans le mode superviseur ou mode noyau ou mode kernel (ring 0) le processeur a acc`es `a toutes les ressources sans restriction. Le code du noyau d’un syst`eme d’exploitation est ex´ecut´e dans ce mode.
– Dans le mode utilisateur ou user (ring > 0, d´epend de l’OS), le processeur teste en permanence les permissions de ce qu’il ex´ecute et g´en`ere des interrup- tions logicielles (exceptions) en cas d’infraction. Les processus utilisateur sont ex´ecut´es dans ce mode.
Les niveaux de protection d’un processeur
Les fichiers (files)
– Syst`eme de rangement et labelisation des donn´ees ind´ependant du mat´eriel.
– Rangement dans une arborescence de r´epertoires (directories)
– Association d’un nom de fichier et d’attributs (type de fichier, propri´etaire, groupe d’utilisateur, droits en lecture/´ecriture, attributs sp´eciaux)
– Le syst`eme de fichier (filesystem) g`ere le stockage physique des fichiers en max- imisant la robustesse et la performance
– Les fichiers sp´eciaux permettent un interfac¸age simple avec le syst`eme d’ex- ploitation ou le mat´eriel
– Les tuyaux (pipes) sont des fichiers sp´eciaux permettant l’´echange d’information entre processus
Les appels syst`eme (system calls)
– Interface entre le noyau et les processus
– M´ecanisme de tr`es bas niveau souvent en langage machine (assembly code) : int´egr´e dans une biblioth`eque de fonctions (library)
– Le m´ecanisme des interruptions logicielles est utilis´e pour passer le contrˆole au noyau.
– Les diff´erentes cat´egories d’appels syst`eme (liste non exhaustive) :
– Gestion des processus (r´eplication de processus (fork), attente passive de fin d’ex´ecution d’un processus enfant (waitpid), lancement de nouveau processus (exec), ...
– Gestion des signaux (sigaction)
– Gestion du syst`eme de fichier (cr´eation de fichier (creat), lecture (read), ´ecriture (write), ...
– Gestion des volumes de stockage (association (mount), dissociation (unmount), ...
– Gestion des gestionnaires de p´eriph´erique (ioctl) – ...
L’interpr´eteur de commandes (shell)
– Interface primaire entre un utilisateur et le syst`eme
– L’utilisateur saisit la commande au clavier apr`es l’invite de commande (prompt) – La sortie par d´efault (stdout) de la commande se fait sous forme de texte dans la
fenˆetre du shell
– Les sorties peuvent ˆetre redirig´ees soit vers un fichier ou en entr´ee d’un autre processus (stdin)
1.6 Architectures de syst`emes d’exploitation
Architectures de syst`emes d’exploitation Syst`emes monolithiques
– Tout le code du noyau tourne dans le ring 0, gestionnaires de p´eriph´eriques (drivers) compris
– Ces syst`emes n’utilisent que 2 modes de fonctionnement (ring) du processeur : le ring 0 pour le noyau et le ring 1 pour les processus utilisateur.
– Le code du noyau est tr`es volumineux
– Robustesse moindre : plus de code tourne en mode superviseur
– R´eactivit´e meilleure : le protocole d’acc`es au mat´eriel est le plus simple possible – Exemple : linux du type monolithique modulaire (les drivers peuvent ˆetre charg´es
`a la demande).
Syst`emes `a couches (layered systems)
– Ce syst`eme est organis´e en plusieurs niveaux imbriqu´es qui correspondent `a plusieurs rings du processuer
– Dans le sens du plus au moins privil´egi´e : distribution du temps processeur (Com- puter Processing Unit ou CPU), gestion de la m´emoire, communication homme- processus, gestion des entr´ees-sorties (Inputs/Outputs ou IOs), programmes util- isateurs
– Cette architecture logicielle est renforc´ee par le mat´eriel : le pentium supporte au moins 4 rings
– MULTICS est la seule impl´ementation de cette architecture `a l’heure actuelle
Machines virtuelles (virtual machines)
– Id´ee : faire tourner plusieurs syst`emes d’exploitation sur la mˆeme machine – Un nano-noyau assure l’interfac¸age entre le mat´eriel et les syst`emes d’exploita-
tion hˆotes
– On parle d’exo-noyau (exokernel) lorsque seule une partie des ressources est partag´ee. Un exo-kernel ne tourne pas forc´ement en mode superviseur.
Exemples de machines virtuelles
– Machine virtuelle MSDOS sous Windows (exokernel) : le partage des ressources est g´er´e au niveau du noyau de Windows
– VMWare (exokernel) : un module noyau doit ˆetre charg´e pour g´erer le partage des ressources
– Dosbox sous linux : on parle plutˆot d’´emulation car le mat´eriel est acc´ed´e au moyen des m´ecanismes classiques disponibles dans l’espace user.
– Xen (paravirtualiseur ou hyperviseur) : c’est un nano-noyau qui permet d’of- frir aux syst`emes d’exploitation hˆotes une interface avec le mat´eriel qui est nor- malis´ee.
– Adeos (nanokernel) : couche logicielle permettant le partage de ressources mat´erielles par plusieurs syst`emes d’exploitation concurrents, y compris plusieurs instances d’un mˆeme syst`eme. Xenomai et RTAI, 2 syst`emes temps-r´eel bas´es sur linux sont des clients de adeos.
Micro-noyau
– Id´ee : mettre le moins de code possible dans le noyau et d´eporter le maximum de code en mode prot´eg´e. Cette architecture est aussi appel´ee micro-noyau (micro- kernel)
– Ce syst`eme est beaucoup plus robuste qu’un syst`eme monolithique car le nombre de ligne de code en mode supervisuer est tr`es r´eduit
– Les drivers sont d´eport´es en mode utilisateur. Si ils commettent une action in- terdite ils peuvent ˆetre tu´es (killed) et relanc´es. Ce syst`eme est donc tol´erant aux fautes
– Les drivers acc`edent au mat´eriel via un m´ecanisme logiciel de protection d’o`u une perte de r´eactivit´e
– Exemple : Mach, Minix, Windows (de type micro-noyau enrichi car certaines fonctions tr`es sollicit´ees sont mises dans le noyau)
Syst`emes temps-r´eel
– Le noyau permet de respecter des contraintes temporelles fortes – R´eactivit´e par rapport aux interruptions mat´erielles
– Cr´eation de tˆaches p´eriodiques avec une fluctuation de la p´eriode (jitter) mini- male
– Exemples : VXWorks (micro-noyau temps-r´eel), QNX (micro-noyau temps-r´eel UNIX-like), Xenomai (monolithique modifi´e avec micro-noyau sous-jacent tour- nant sur une machine virtuelle nano-noyau adeos)
2 Processus
2.1 Introduction
Introduction D´efinitions
– Processus : s´equence d’instructions ex´ecut´ees par le processeur.
– Sur un syst`eme multitˆaches, l’illusion du parall´elisme est donn´ee en r´ealisant un multiplexage temporel de la ressource CPU et en la distribuant entre les diff´erents processus suivant une loi appel´ee ordonnancement (scheduling).
– Les processus ne sont pas tous ´egaux. Certains sont prioritaires et doivent ˆetre trait´es rapidement car ils servent par exemple au bon fonctionnement du syst`eme d’exploitation.
– Chaque processus fonctionne de mani`ere cloisonn´ee par rapport aux autres. Le contexte d’un processus est l’´etat courant du mat´eriel (processeur principale- ment) lorsque ce processus est en cours d’ex´ecution.
– Le d´ecoupage temporel du temps CPU entre les diff´erents processus implique une commutation de contexte du mat´eriel pour sauvegarder le contexte courant du processus en cours de suspension et la restauration du contexte du processus sur le point d’ˆetre r´eveill´e.
Cr´eation d’un processus
– Les 3 situations de cr´eation d’un processus : – Initialisation du syst`eme
– Cr´eation d’un processus enfant par un processus existant – Cr´eation d’un processus par un utilisateur
– Lors du d´emarrage d’un syst`eme, un programme bien pr´ecis est lanc´e qui est charg´e du lancement de tous les processus n´ecessaires au bon fonctionnement du syst`eme. Sous UNIX, ce programme s’appelleinit.
– Certains processus actifs en permanence lorsque le syst`eme est en marche s’ap- pellent des d´emons (daemons). Ils servent `a effectuer des tˆaches de service telles que la gestion des tˆaches d’impression, la gestion des connexions externes, la gestion de la fenˆetre de login sous Xwindows, ...
Fin d’un processus
– Les 4 situations d’arrˆet d’un processus : – Sortie normale sans erreur (volontaire) – Sortie normale avec erreur (volontaire)
– Le processus commet une erreur fatale (involontaire) – Le processus est tu´e par un autre processus (involontaire)
– Les 2 premi`eres situations de sortie volontaire sont provoqu´ees par une instruc- tion sp´ecifique du processus (exitsous UNIX) avec un code de sortie qui cor- respond soit `a une sortie normale soit `a une sortie avec erreur.
– Les 2 derni`eres situations sont provoqu´ees par le syst`eme d’exploitation qui arrˆete imm´ediatement le processus en cours soit parce qu’il a commis une in- fraction soit parce qu’un autre utilisateur ayant des droits plus ´elev´es a envoy´e un appel syst`eme de type kill.
Hi´erarchie des processus
– Lorsqu’un processus parent cr´e´e un ou plusieurs processus enfant(s), les enfants restent li´es d’une certaine mani`ere aux parents.
– Comme les enfants peuvent eux-mˆemes donner naissance `a des enfants, on peut avoir toute une arborescence ou hi´erarchie de processus li´es entre eux.
– Il est possible d’envoyer un signal `a une hi´erarchie de processus. Lorsqu’un pro- cessus enfant s’arrˆete, le parent en est inform´e.
– Exemple : commandepstreesous UNIX.
Etat des processus
– En cours d’ex´ecution (running) : le CPU ex´ecute le processus `a cet instant – Prˆet (ready) : le processus attend que le CPU ait finit d’ex´ecuter d’autres proces-
sus
– Bloqu´e (blocked) : le processus est en attente d’un ´ev´enement externe
Les processus l´egers (threads)
– Les threads partagent le mˆeme espace d’adressage, donc les mˆemes variables et le mˆeme code. Seuls les registres du processeur diff`erent.
– Les threads peuvent ˆetre g´er´ees dans l’espace user ou par le kernel.
– Les threads impliquent de g´erer certains nouveaux probl`emes :
– Acc`es simultan´e `a un mˆeme fichier : que se passe t’il si un thread ferme le fichier alors que l’autre est en train de le lire ?
– Allocation dynamique : si un thread a besoin de plus de m´emoire en mˆeme temps qu’un autre ?
– Si un thread commet une erreur, affiche la valeur deerrnoet qu’`a ce moment- l`a un autre thread commet une erreur.
– ...
2.2 Communication inter-processus (IPC)
Communication inter-processus Introduction
– Comment communiquer des donn´ees entre processus ? – Comment synchroniser la transmission des donn´ees ? – Comment ´eviter les situations de blocage ?
– Comment g´erer l’acc`es concurrent `a des ressources communes ?
Situation de comp´etition (race condition)
– Deux processus ou plus ´ecrivent puis lisent des donn´ees et le r´esultat d´epend de quel processus a ´et´e le premier.
– Exemple : competition entre 2 threads
Section critique (critical section)
– Pour ´eviter les situations de comp´etition, il faut d´efinir une section critique – Les conditions pour r´ealiser une section critique :
– Il ne peut y avoir plus d’un processus dans sa section critique en mˆeme temps – Un processus en dehors de sa section critique ne peut bloquer un autre proces-
sus
– Aucun processus ne peut bloquer en permanence pour entrer dans sa section critique
Exclusion mutuelle avec attente active (mutual exclusion with busy waiting) – Alternance stricte r´esoulue avec un verrou rotatif (spin lock)
– Algorithme de Peterson (attente active) : r´esolution de la comp´etition entre 2 threads
– Instruction processeur Alternance stricte
while( 1 ) {
while( turn != 0 );
/* section critique */
/* ... */
turn = 1;
/* section non critique */
/* ... */
}
while( 1 ) {
while( turn != 1 );
/* section critique */
/* ... */
turn = 0;
/* section non critique */
/* ... */
}
Algorithme de Peterson
flag[0] = flag[1] = turn = 0;
P0: flag[0] = 1;
turn = 1;
while( flag[1] && turn == 1 );
// do nothing // critical section ...
// end of critical section flag[0] = 0;
P1: flag[1] = 1;
turn = 0;
while( flag[0] && turn == 0 );
// do nothing // critical section ...
// end of critical section flag[1] = 0;
Instruction processeur i86 : XCHG
LOCK: ; mutex pointer is in EBX; clobbers EAX XOR EAX, EAX ; EAX = 0
XCHG EAX, [EBX] ; atomic exchange AND EAX, EAX ; test if EAX = 0
JZ LOCK ; if we got a zero, spin-wait RET
UNLOCK: ; mutex pointer is in EBX MOV [EBX], 1 ; release the lock RET
Probl`eme d’inversion de priorit´e
– Consid´erons 2 processus H de priorit´e haute et B de priorit´e basse qui partagent un acc`es `a une ressource commune
– La strat´egie d’ordonnancement fait que H est plac´e en mode((running))d`es qu’il est((ready))
– Supposont que B soit dans une section critique et qu’`a ce moment H passe du mode((blocked))au mode((ready)).
– H est donc mis en mode((running))et B est mis en mode((ready)). Or H veut acc´eder `a la section critique et bloque donc sur le m´ecanisme d’exclusion mutuelle sans aucun espoir que B passe en mode((running))et lib`ere le verrou.
Sommeil et r´eveil d’un processus (Sleep and wakeup)
Pour ´eviter les attentes actives, utilisation desleepetwakeup.
S´emaphore
– Methode classique pour acc´eder `a une ressource commune
– Le s´emaphore est un compteur qui est initialis´e `a la valeur du nombre de ressources partag´ees `a prot´eger
– Lorsqu’il n’y a qu’une seule ressource `a partager, on parle de s´emaphore binaire ou mutex
S´emaphores : exemple du producteur-consommateur BufferSize = 3;
semaphore mutex = 1; // access to critical section semaphore empty = BufferSize; // number of empty slots semaphore full = 0; // number of full buffer slots Producer() {
int widget;
while (TRUE) { // loop forever
make_new(widget); // create a new widge
down(empty); // decrement the empty semaphore down(&mutex); // enter critical section
put_item(widget); // put widget in buffer up(&mutex); // leave critical section
up(&full); // increment the full semaphore }
}
S´emaphores : exemple du producteur-consommateur
Consumer() { int widget;
while (TRUE) { // loop forever
down(&full); // decrement the full semaphore down(&mutex); // enter critical section
remove_item(widget);// take a widget
up(&mutex); // leave critical section
up(empty); // increment the empty semaphore consume_item(widget);// consume the item
} }
Mutex
– Un mutex est un cas particulier d’un s´emaphore qui n’aurait que 2 ´etats : 0 ou 1 – Un mutex est typiquement utilis´e lorsqu’il faut prot´eger une section critique
Moniteurs (monitors)
– Ensemble de proc´edure, variables, structures de donn´ees regroup´ees dans un ob- jet sp´ecial appel´e moniteur
– Les processus externes au moniteur peuvent appeler les proc´edures du moniteur mais une seule proc´edure du moniteur ne peut ˆetre active `a la fois
– La synchronisation est g´er´ee par le compilateur qui sait que le moniteur est une structure sp´eciale. C’est le compilateur qui rajoute les m´ecanismes de synchro- nisation ad´equats.
Transmission de message (message passing) – Transmission de messages inter-processus
– Les fonctionsendetreceivepermettent de passer des messages en garantis- sant l’int´egrit´e des donn´ees
2.3 Ordonnancement (scheduling)
Ordonnancement Introduction
– Partage du temps CPU entre les processus. Le passage d’un processus `a un autre s’appelle la commutation de processus. C’est l’ordonnanceur du noyau qui ef- fectue cette commutation.
– La prise de d´ecision des commutations s’effectue de mani`ere p´eriodique (”tic”
du syst`eme)
– Deux principaux types de comportement des processus : processus d´edi´es aux entr´ees-sorties et processus d´edi´es aux calculs
– Quand commuter les processus : quand un processus se termine, quand un pro- cessus bloque sur une entr´ee/sortie, un s´epaphore, ... Eventuellement : quand un nouveau processus est cr´e´e, quand une interruption mat´erielle intervient.
– Diff´erents objectifs d’ordonnancement : ´equit´e, veiller `a ce qui la politique d’or- donnencement soit respect´ee, ´equilibre. Pour les syst`emes interactifs : temps de r´eponse court, ergonomie adapt´ee aux attentes des utilisateurs. Pour les syst`emes temps-r´eel : respect strict des d´elais, d´eterminisme.
Ordonnancement FCFS ou FIFO
– First Come First Served : les processus sont d´emarr´es dans l’ordre o`u ils sont lanc´es et tournent jusqu’`a ce qu’ils bloquent
– Inconv´enient : pas adapt´e aux syst`emes interactifs
Ordonnancement round robin
– Chaque processus obtient un quantum de temps CPU. L’ordonnanceur distribue de mani`ere cyclique ces quantums aux processus.
– Exemple de Pb : avec un quantum de 100ms, si 10 utilisateur appuient simul- tan´ement sur une touche du clavier, les 10 processus correspondants vont ˆetre r´eveill´es successivemnt et consommer leur quantum. Le dernier utilisateur servi devra attendre 1s.
Ordonnancement par priorit´e (priority scheduling)
– Tout les processus ne sont pas ´egaux : certains doivent ˆetre trait´es prioritairement – Avec un ordonnancement par priorit´e, le syst`eme donne toujours la main `a la
tˆache de plus haute priorit´e
– La priorit´e peut ˆetre modifi´ee dynamiquement `a chaque periode de l’ordon- nanceur pour ´eviter qu’un seul processus n’occupe tout le temps CPU
Ordonnancement garanti (guaranteed scheduling)
– Garanti un partage ´equitable du temps CPU entre utilisateur ayant une mˆeme priorit´e
– Le syst`eme conserve un historique du temps CPU cumul´e de tous les processus afin de r´ealiser l’´equilibre
Ordonnancement par lotterie (lottery scheduling) – L’ordonnancement garanti est difficile `a impl´ementer.
– Une des solutions consiste `a tirer au sort quel processus a droit au CPU
– Plus un processus est prioritaire, plus il dispose de tickets parmis l’ensemble des tickets soumis au tirage al´eatoire
Ordonnancement de processus l´eger (thread scheduling)
– L’ordonnancement des threads n’est possible que pour les threads noyau – Il est possible de d´efinir un politique d’ordonnancement des threads diff´erente
de celle des processus
Ordonnancement temps-r´eel (real-time scheduling) – Doit ˆetre d´eterministe en temps
– Les tˆaches p´eriodiques doivent ˆetre r´eveill´ees avec une p´eriodicit´e parfaite (er- reur<100 micro-secondes)
– Le temps de r´eponse aux interruptions doit ˆetre le plus court possible.
