cours de systèmes d’exploitation - morere.eu · fonctionnement d’un système informatique ......

Les Systèmes d’Exploitation Yann MORÈRE 2001

1/94

Cours de Systèmes d’Exploitation

Yann Morère

Septembre 2001


2/94

Introduction

Divisions bien distinctes entre la matériel informatique(hardware) et les différentes formes de logiciel (software)

résultat (avec avantages et défauts) d’une longue évolution qui a plusieurs origines : mathématique, philosophique, électronique, cybernétique,autimatique, économique et marketing.


3/94

Chapitre 1Historique des Systèmes Informatiques


4/94

Définition d’un système informatique

4 composants : le matériel, le système d’exploitation,les programmes applications et les utilisateurs.•Le matériel : composé de l’unité centrale (UC), la mémoire et les périphériques d’entrée/sortie, fournit les ressources informatiques de bases.•Les programmes d’applications : compilateurs, SGBD, jeux, programmes bureautiques.•Le système d’exploitation : contrôle et coordonne l’utilisation du matériel.•Les utilisateurs : utilisent les programmes d’applications afin de réaliser les tâches voulues.

SE = programme d’allocation de ressources.

1. Historique des systèmes d’exploitation


5/94

Vue des composants d’un système informatique



6/94

Les Premiers SystèmesLes Automates

•mécaniciens chinois, 2ème millénaire avant J-C : moteurs à eau, à sable, les horloges. •mécaniciens grecs : systèmes à base de poulies, vis sans fin, engrenages, plans inclinés. •mécaniciens Arabes : automates séquentiels à arbre à came.

Le zéro et la notation positionnelle (chiffres arabes)Permet de développer des systèmes de numérotation en bases non décimales, la base 2 (code binaire)

Les machines à calculerWilhelm Schickhard (1623) quatre opérationsPascaline de Blaise Pascal : additionner et soustraire, (1642)La Machine de Leibnitz : multiplier (1675).



7/94

La machine Analytique (1887)

Charles Babbage, Adelaide (ADA) Lovelace inventent la machineanalytique :

• programmable avec des cartes perforées,• composée de 1000 registres de 50 chiffres chacun,• dispositif d’entrée/sortie,• un organe de commande,• un «magasin» (store) permettant de stocker les résultats des calculs intermédiaires,• un moulin (mill) qui constituait l’unité arithmétique,• et un mécanisme d’impression.

première machine de calcul programmable généraliste.Apparition de la notion d’algorithme



8/94

Les systèmes mécanographiques1728 invention des cartes perforées 1889 H. Hollerith invente les machines à statistiques à cartes perforées

Théorie des systèmes et cybernétique1938 les concepts intuitifs (quantité d’information) formalisés par la «théorie de l’information» de C. Shannon.La théorie générale des systèmes (H. Simon, L. Von Bertalanfy, N.Wiener...) modélise de systèmes complexes.

Logique Mathématique19ème, Boole et de Morgan, logique des mathématiques modernes. systèmes logiques, de calcul de propositions.

La machine de Turing1936, Turing, modèle formel d’une machine calculatoire. systèmes informatiques modélisés comme une machine de Turing.



9/94

Le Seconde Guerre MondialeLa guerre va donner d’autres sources de motivation :

• motivation politique,• assimilation des travaux des grands théoriciens des années 30,• collaboration de théoriciens avec des ingénieurs.

Le projet le plus célèbre de calculateur est le Colossus(opérationnel en 1943), décoder les messages de la marine allemande encodés par la machine Enigma.

Première Génération : 1944-1954financement de centres de recherche universitaires : Angleterre,Cambridge (MARK I, 1949), Pennsylvanie (ENIAC, 1944-1946), au MIT (WHIRLWIND, 1945-1952), Illinois (ORDVAC et ILLIAC, 1949-1952).



10/94

Première Génération : 1944-1954

Mêmes caractéristiques :• Système à base de composants mécaniques et d’électronique à lampes,• Machines très complexes et très volumineuses,• Concepteur = constructeur = programmeur = opérateur• Programmation en langage machine absolu et pas en langage d’assemblage (câblage de carte),• Opération de l’ordinateur : réservation de la machine, câblage des cartes, élimination des bugs,

Problèmes traités : calculs numériques (tables de fonctions).

Entrée dans l’ère commercialeIBM, développe le modèle 701, UNIVAC I pour le recensement de lapopulation des E.U.



11/94

Seconde Génération : 1955-1965

Invention des langages de programmation• Assembleur• FORTRAN (FORmula TRANslator), J. Backus 1954, adapté aux calculs scientifiques. •COBOL (COmmon Business Oriented Language), G. Hopper 1959, traitement d’information de gestion et de comptabilité.

Progrès TechnologiqueTransistor en 1947, J. Bardeen, H.W. Brattain et W. Shockley.Apparition des bandes magnétiques.

Éléments de l’informatique actuelleL’ordinateur devient un produit commercial,

Introduction de la notion d’ordonnancement.



12/94

Troisième Génération :1965-1980Apparition des circuits intégrés et des disques magnétiques Apparition de la multiprogrammation. L’UCT travaille sur un autre job, si un job effectue ses E/S.Notion de spooling (Simultaneous Peripheral Operation On Line)apparait.

Apparition des systèmes interactifsApparition du temps partagé, MULTICS ,UNIX



13/94

Quatrième Génération : 1980-1990

Apparition des micro-ordinateurs grand public,PET, AppleII, ZX80Apparition du Postscript,WYSIWYG.La fin des années 90 verra le boum du multimédia et des réseaux informatiques (internet).

Dans un cadre plus sérieux de nouvelles technologies apparaissent :• Les systèmes parallèles (multiprocesseurs).• les systèmes distribués (répartis).• informatique temps réel (industrie).



14/94

Chapitre 2Structure de systèmes informatiques


15/94

Organisation matérielleSystèmes informatiques organisés les principes de l’ordinateur IAS, J. Von Neuman, Institute for Advanced Studies (1946-1952).

Structure de l’ordinateur IASL’implantation : architecture de bus. Connections entre les différents modules du système.

2. Structures de systèmes informatiques


16/94

Architecture générale

Architecture générale d’un ordinateur



17/94

Architecture du processeur

Le processeur est l’organe qui effectue les traitements suivant un «algorithme»

Architecture générale d’un

processeur

CISC (Complex Instruction Set Computer) RISC (Reduced Instruction Set Computer)



18/94

Les entrées/sorties

Principe élémentaire

Les entrées/sorties programméesSimple adaptation des signaux interface. Le processeur adresse directement le périphérique. Le programmeur doit assurer le protocole élémentaire d’échange E/S

entrées/sorties programmées.



19/94

Les entrées/sorties par accès direct à la mémoire (DMA)

Mécanisme d’accès direct à la mémoire

Pour accroître le débit des entrées/sorties et de diminuer la monopolisation du processeur

déporter des fonctionnalités dans le dispositif qui relier le périphérique au bus. l’accès directe à la mémoire (DMA), ou encore le vol de cycle.



20/94

Les entrées/sorties par processeur spécialiséUtilisation d ’un processeur spécialisé d’entrées/sorties

déléguer plus d’automatisme à ce niveau. L’intérêt : Exécution des tâches de bas niveau par un processeur moins performant, moins coûteuxPréservation du processeur principal pour des tâches plus nobles.

Les interruptionsPermettre à un dispositif exécuteur d’interrompre le déroulementnormal du processeur pour lui faire exécuter un traitement spécifique. Fonctionnement du décodeur-séquenceur du processeur :1. lecture mémoire à l’adresse indiquée par le compteur ordinal, et rangement du résultat dans leregistre instruction,2. décodage de cette instruction pour en exécuter les différentes phases,3. s’il y a une demande d’interruption, alors la prendre en compte.



21/94

Les interruptions

Déroulement d’un sous-programme d’interruption



22/94

Fonctionnement d’un système informatiqueUCT (unité de calcul et de traitement) et périphériques (disques, etc...) connectées sur un bus commun, fournissant l’accès à la mémoire partagée.

Structure d’un Système

Informatique



23/94

Structure de StockageLa mémoire principale (RAM) =gigantesque tableau d’octets regroupés en mots qui possède son adresse propre.Pour une question de rapidité, l’idéal = programmes et données résidents en mémoire :

•La mémoire principale est souvent trop petite,•Procédé de stockage volatile.

Nécessité d ’une mémoire auxiliaire (souvent des disques magnétiques, optiques, bandes).

Mécanisme d’un disque dur



24/94

Hiérarchie de stockage en partant des mémoires les plus proche du processeur et donc du plus rapide, aux plus éloignées et plus lentes.

Structure de Stockage

Très grande différence de vitesse de traitement entre les mémoires volatiles et les disques. Pour palliercette différence, les mémoires cache ont été ajoutées.Elle sont chargées de stocker les données qui sont utilisées très souvent, afin que le système n’aie pas à les recharger à partir d’un périphérique lent.



25/94

Protection du système informatique

Passage à des systèmes multitâches, multi-utilisateurs, à temps partagé, apporte de nouveaux problèmes :

•une erreur sur un programme peut se répercuter sur les autres etmême sur le SE,•la sécurité des données.

Nécessité de protéger toutes les composantes du système informatique.

Protéger le système d’exploitation et les données d’un programmequi fonctionne mal et qui risque de tout détruire,

Introduction deux modes d’exécution :• le mode utilisateur,• le mode superviseur, système, moniteur ou encore privilégié.

Protection des routines de traitement d’interruption,Protection de la mémoire.



26/94

Chapitre 3Structures des systèmes d’exploitation


27/94

IntroductionPartie très importante de tout système informatique.Un système d’exploitation (SE ou OS) = programme qui fait la liaison entre l’utilisateur et le matériel.

•Il permet une exécution pratique et efficace des programmes.•Il assure le fonctionnement correct du système informatique. •Il fournit aussi certains services aux programmes et aux utilisateurs (faciliter la programmation par exemple).

Une définition plus commune consiste à expliquer que le SE est le seul programme tournant à tout moment dans l’ordinateur (on parle aussi de noyau ou kernel).

Pour l’utilisateur final, but principal = commodité du système d’exploitation.Cas d’un système partagé multi-utilisateurs, la performance est le critère principal. Deux objectifs contradictoires : commodité et efficacité.

3. Structures des systèmes d’exploitation


28/94

Le modèle processus-ressourcesLe système d’exploitation est un intermédiaire offrant un ou plusieurs niveaux d’abstraction entre les usagers et un ensemble de ressources : UCT, mémoire, disque, périphériques.

Le SE comme intermédiaire entre usagers et ressources systèmes



29/94

Le modèle processus-ressourcesUn autre modèle du système d’exploitation = un intermédiaire présentant des niveaux d’abstraction entre un ensemble de processus et les ressources du système que des processus utilisent.

Modèle révisé : Processus et Ressources



30/94

Composants et fonctionsBut : supporter et exploiter les composants du système informatique.

Gestion de l’UCT : Gestion de processus

L’UCT (Unité de Calcul et de Traitement) = ressource. Le SE doitoptimiser l’utilisation.Processus = programme en cours d’exécution. Processus = programme en mouvement. Processus = entité active.Processus = unité de travail d’un système.

Gestion des processus :•Activer un processus,• Suspendre, réactiver un processus,• Tuer un processus• Surveiller l’opération d’un processus,• Synchronisation de processus

de manière à ce que l’UCT soit utilisée de manière optimale.



31/94

Gestion des fichiers

Composante la plus visible d’un système d’exploitation = le stockage d’information.Permettre une utilisation pratique, SE propose une vue logique uniforme des ressources de stockage.Définition d ’une unité de stockage : le fichier.Physiquement le fichier est d’une séquence de bits, octets, lignes ou enregistrements.

Le SE est responsable des activités suivantes :•Création et suppression de fichiers,•Création et suppression de répertoires,•Primitives pour manipuler des fichiers et des répertoires,•Correspondances entre les fichiers et la mémoire auxiliaire,•Sauvegarde des fichiers sur des supports d’information stables (non volatiles).



32/94Gestion de la mémoire

Pour être exécuter un programme doit être transférer à des adresses absolues de la mémoire centrale.Pour améliorer l’utilisation de l’UCT, diverses approches de la gestion mémoire existent.Le SE gère les activités suivantes :

•Connaître en permanence les parties de mémoire en cours d’exécution, et par quel programme,•Décider quels processus doivent être chargés en mémoire quand ondispose de l’espace mémoire,•Affecter et désaffecter l’espace mémoire.

Autres composants•La gestion des entrées/sorties,•Système de protection (mémoire, fichier, UCT, E/S...),•Connexion à un réseau dans un système distribué,•Interpréteur de commande (de l’usager) :•interface entre l’usager et le système d’exploitation,



33/94

Services d’un système d’exploitation

Services fournis :•pour les programmes,•pour les utilisateurs de ces programmes.

1. Exécution de programmes,2. Opération d’entrées/sorties,3. Manipulation du système de fichiers,4. Communication entre processus,

(a) par mémoire partagée (processus sur le même ordinateur),

(b) par passage de message (ordinateurs différents),5. Détection et gestion d’erreurs

Services fournis au système d’exploitation lui-même :1. Allocation de ressources,2. Suivi et gestion des comptes,3. Protection.



34/94

Accès aux services du système d’exploitation

L’usager accède au services du SE :en lançant des appels systèmes, à l’intérieur d’un programme,

•Gestion de processuscharger et exécutercréer et terminer un processus...

•Manipulation de fichiercréer et détruire des fichiersouvrir et fermer un fichier…

•Manipulation de périphériquesrequérir et relâcher un périphériquelire, écrire...

•Maintenance de l’information•Communication



35/94

Structure d’un système d’exploitationUne approche courante (linux, Unix) consiste à subdiviser les tâches en composants plus petits, plutôt que d’avoir un gros système monolithique. Chacun de ces modules constitue une portion bien définie du système.

Structure simple (systèmes monolithiques)Pas de structure, le SE est un ensemble de procédures qui peuvent s’appeler, sans restriction.Il s’agit souvent de SE qui on grandit à partir d’un système original simple :

•les premières versions d’Unix,•Mac OS•MS-DOS

Structure d’un système d’exploitation

MS-DOS



36/94

Structure en couches

Systèmes organisés par couches, et une communication se crée entre couches adjacentes.Avantage = modularité. Chaque couche n’utilise que les fonctionnalités de la couche inférieure.L’archétype des structures en couches est le système THE (Technische Hogeschool Eindhoven) conçu par Djikstra en 1968.

Couche 5 programmes utilisateursCouche 4 bufferisation pour les périphériques

d’entrée/sortieCouche 3 driver pour la console de l’opérateurCouche 2 gestion mémoireCouche 1 scheduling de l’UCCouche 0 matériel

Difficulté = détermination des diverses couches. Implémentation moins performantes.



37/94

Structure à noyau (kernel)

L’architecture en couches est conceptuellement élégante, mais peu efficace. Systèmes en couches = peu portables.L’architecture de noyau (kernel) est préférée de nos jours.

Le kernel regroupe des fonctions du système indépendantes du matériel

portabilité.Le kernel gère les accès à l’UCT, aux ressources et au système de fichier. Il communique avec les pilotes (driver) de périphériques pour gérer les appels systèmes en provenance des processus.



38/94


Les processus communiquent avec le kernel à travers les API (Application Programming Interface), qui définissent la syntaxe et la sémantique des appels système.

Le kernel = petit nombre de fonctions et taille réduite.



39/94


Opposition des kernels «monolithiques» indépendant du matériel, et «microkernels» qui n’offrent que 4 services :

•un mécanisme de communication interprocessus,•un système de gestion mémoire,•un niveau minimal de gestion de processus,•un système de gestion des E/S de bas niveau.

Kernels monolithiques : Linux, lesWinNT etc…Microkernel : Mac OS, microkernel Mach, Solaris,

Principaux avantages des deux architectures :•Microkernel : portabilité, maintenance facile,•Kernel monolithique : performance.



40/94

Exemple de systèmes d’exploitation

Unix classique

Caractéristiques principales :•Système d’exploitation à temps partagé. •Système multi-utilisateurs et multi-tâches.

Très portable, écrit en C.Fournit le même environnement sur des plates-formes très différentes.Interface avec l’usager = la ligne de commande ou CLI (Command Line Interface).Shell (coquille) = l’interpréteur de commande = processus quientoure le noyau du système d’exploitation. Shell très connus :

•Bourne Shell (Bourne Again Shell),•C Shell,•TC Shell,•Korn Shell.



41/94

Exemple de systèmes d’exploitation

Le Mac OS

Introduit en 1984. Caractéristiques principales :•Premier ordinateur personnel grand public avec une interface graphique (exclusivement).•Il s’agit d’un système mono-utilisateur.•Son fonctionnement est multi-tâches coopératifs.•Système est composé d’un ensemble de managers.



42/94

Chapitre 4Les Processus


43/94

Premiers systèmes : un seul programme à la fois. De nos jours : chargement de plusieurs programmes en mémoire et exécution en concurrence.

Contrôle plus ferme des programmes. Notion de processus, programme en exécution.

Processus = Unité de travail élémentaire (systèmes en temps partagé)

Le système d’exploitation est responsable des activités de création, suppression, ordonnancement, par rapport à la gestion des processus.

4. Les Processus


44/94

Concepts élémentaires

Le processus et son espace adressePartage de l’accès aux ressources pour les processus : UCT, mémoire et périphériques. Cas d’un système à temps partagé, l’exécution des processus doit être en apparence concurrente : une fraction de temps UCT est accordée à chacun des processus.

Un processus exécute une séquence d’instructions dans un espace d’adresse comprenant l’ensemble des locations en mémoire auxquelles le processus est autorisé à accéder.

Cette espace d’adresse est a priori virtuel (il ne correspond pas forcément à la mémoire physique et peut être sur un disque dur en attente d’être chargé).

4. Les Processus


45/94

Le kernel (noyau)

kernel = programme spécial qui implante le modèle de processus et lesautres services du système.

Initialise le système et définit l’environnement pour exécuter des processus. Il demeure en mémoire jusqu’à l’extinction du système.

Interactions entre kernel et programmes usagers définies par l ’interface de programmation des applications (ApplicationProgramming Interface ou API).

Un processus interagit avec le kernel par des appels système (systemcalls). Le kernel exécute des demandes pour le compte des processus appelant.

4. Les Processus


46/94Mode, espace et contexte

Mode : Unix deux modes d’exécution :le mode système (système mode ou kernel mode), privilégié,le mode usager (user mode), moins privilégié.Espace usager et espace système : (user space et kernel space)une partie de l’espace d’adresse de chaque processus correspond à du code et des structures de données kernel. Cette portion de code est appelée espace système (system space ou kernel space) et contient des structures de données globales et des objets relatifs aux processus.L’accès à cette espace système se fait en mode système.

Processus possède deux objets spécifiques gérés par le kernel :l’espace usager (user area ou u area) : qui contient des informations sur le processus qui sont utiles au kernel (liste de fichiers ouverts, valeurs des registres lorsque le processus est interrompu).la pile du kernel (kernel stack) : dans le cas d’un kernel réentrant comme celui d’Unix (c-à-d autorisant plusieurs processus à être engagés concurremment dans des appels système).

4. Les Processus


47/94Contexte processus et contexte système (process context et systemcontext)Le kernel peut opérer en contexte processus, c’est à dire pour le compte d’un processus (en exécutant un appel système ou en traitant uneexception). Il peut aussi opérer en contexte système pour gérer les interruptions en provenance des périphériques.

Résumé des modes, espaces et contextes

4. Les Processus


48/94États d’un processusUn processus est une instance d’un programme en exécution. Un processus peut être dans 5 états différents :• nouveau, le processus est en cours de création,• prêt, le processus attend d’être affecté à un processeur,• élu, les instructions sont en cours d’exécution,• en attente (bloqué), le processus attend qu’un événement se produise (comme l’achèvement d’une entrée/sortie ou la réception d’un signal),• fini, le processus a fini l’exécution.

4. Les Processus


49/94Mécanismes de gestion de processusLe cycle de vie d’un processus est constitué d’une alternance de sections durant lesquelles il est actif, en contrôle de l’UCT («giclées» d’UCT ou CPU bursts), en attente d’E/S.

Déroulement d’un changement de

contexte

4. Les Processus


50/94

L’exécution de ces transitions consomme du temps de processeur physique qui n’est pas utilisé par les processus eux-mêmes. C’est ce qu’on appelle la déperdition (overhead) résultant de la gestion des processus. Deux mécanismes de gestion de processus seront vus en détail :

Ordonnancement (Scheduling) effectué par un Ordonnanceur ou répartiteur (Scheduler) qui «décide» quel processus doivent être admis, lequel doit être activé...

Synchronisation certains processus peuvent avoir à accéder aux mêmes ressources et il faut alors gérer les droits d’accès.

Le dernier mécanisme concerne la gestion des interruptions/activation à proprement parlé, et le maintien à jour des tables de processus et des blocs de contrôle de processus (Processus Control Block ou PCB).

4. Les Processus


51/94

Ordonnancement (Scheduling) de processusNous allons tout d’abord définir quelques termes :•la multiprogrammation : disposer de quelques programmes en exécution à tout moment,•le temps partagé : commuter l’UCT entre les processus de manière à ce que les utilisateurs puissent interagir avec les différents programmes.

Rôles des ordonnanceurs (répartiteurs, Schedulers)choisissent les travaux (jobs) ou processus qui vont accéder à l’UCT. Deux types de répartiteurs :•Traitement par lots (batch processing) le répartiteur de haut niveau (à long terme) sélectionne le prochain travail à charger en mémoire.•Multiprogrammé, le répartiteur de bas niveau (à court terme) sélectionne à chaque fois que l’UCT devient inactive, un processus parmi tous ceux présents en mémoire (prêts). Ce processus devient le nouveauprocessus élu. Cette intervention du répartiteur de bas niveau se produit aussi lorsque la fraction de temps de l’UCT allouée au processus est expirée.

4. Les Processus


52/94

4.2.2 Files d’ordonnancement

Plusieurs processus P0, P1, P2, etc... :• un seul au plus de ces processus peut être élu par l’UCT,• plusieurs processus pourront être en attente d’E/S,• d’autres seront prêt à occuper l’UCT.

Le mécanisme est celui de la file d’attente :•une file d’attente pour tous les processus prêts,•une file d’attente pour chaque périphérique et type d’E/S

Il s’agit maintenant de savoir :•dans quel ordre les processus seront insérés dans la file d’attente,•comment s’effectue le passage entre les files et l’UCT.

4. Les Processus


53/94

Traitements par lots (batch)Ce style de file d’ordonnancement n’a pas de répartiteur de bas niveau : l’UCT reste inactive pendant que le processus courant traite sa demande d’E/S.

4. Les Processus


54/94

Multiprogrammation sans temps partagéDans ce cas les processus ne sont suspendus que s’ils font une demandes d’E/S.

4. Les Processus


55/94Répartiteur pour le temps partagéDans ce cas, on ajoute la notion de quantum de temps après lequel le processus élu perd le contrôle de l’UCT et repasse à l’état prêt.

4. Les Processus


56/94

Algorithmes d’ordonnancementPlusieurs critères, parfois mutuellement contradictoires, à prendre en compte dans le choix d’un algorithme d’ordonnancement.

taux d’utilisation de l’UCT (en %tage de tempsécoulé)

à maximiser

débit (throughput) : le nombre total de processustraités parunité de temps

à maximiser

Prédictabilité : une tâche donnée devrait toujoursavoir les mêmes temps de réponse et de virement

à maximiser

justice : en particulier aucun processus ne devraitsouffrir de famine (starvation)

à maximiser

temps de virement (turnaround time) : temps écouléentre la soumission et la fin de l’exécution

à minimiser

temps d’attente (passé dans la file de bas niveau) à minimiser

temps de réponse (pour un processus interactif,avant la première sortie vers l’usager)

à minimiser

moyenne, variance, minima, maxima de ces critères

4. Les Processus


57/94

Deux grandes classes de répartiteurs :•répartiteurs non préemptif, sans réquisition, (non-preemptive). Quand un processus prend le contrôle de l’UCT, il ne le relâche que lorsqu’il a terminé son exécution ou lorsqu’il bloque sur une attente d’E/S.•répartiteurs préemptifs, à réquisition (preemptive). Un processus qui a pris le contrôle de l’UCT, le relâche lorsqu’il a terminé son exécution ; ou lorsqu’il bloque sur une attente E/S, mais aussi quand le répartiteur le suspend, lorsque le quantum de temps qui lui avait été alloué est terminé.

Par exemple que les répartiteurs d’UNIX, OS/2, Win NT et BeOS sont préemptifs, et que ceux de MacOS, Windows 3.x/9x/Millenium sont non-préemptifs.

Distinguer les différents répartiteurs, par rapport à la manière dont ilsgèrent la liste des processus prêts.

4. Les Processus


58/94

Premier Arrivé, Premier Servi ou PAPS(First Come, First Served ou FCFS)Lorsque l’UCT se libère (soit parce que le processus élu a terminé, soit parce qu’il a fait une demande d’E/S), le processus en tête de la file des processus prêts devient le nouvel élu.

4. Les Processus


59/94Exemple de PAPS pour un répartiteur de bas niveau : 3 processus, A, B et C. Les processus n’attendent pas pour les E/S (chacun leur périphérique). Pour A, 5 UCT, 2 E/S .... Pour B, 4 UCT, 4 E/S, 4 UCT .... Enfin pour C, 1 UCT, 8 E/S, 1 UCT ....En supposant que A arrive en premier suivi de B, une unité de temps plus tard, puis C une unité de temps encore après. Comment les 3processus vont-ils utiliser l’UCT dans les 30 unités à venir ?

4. Les Processus


60/94

Plus court d’abord(Shortest Job First ou SJF)

On fait d’abord passer le processus ayant la plus petite giclée d’UCT. Dans la cas d’ex æquo l’arbitrage est réglé par PAPS. Connaître la longueur des giclées d’UCT des processus. Deux manières :

•demande à l’usager,•estimation à partir des temps de service passés :

où est le temps de service du dernier passage par l’UCT, est la prédiction qui avait été faite avant ce passage, et est la prédiction (corrigée) qui est faite pour la durée de la prochaine giclée d’UCT du processus. Le paramètre indique le poids que l’on veut donner à l’historique.

( )1 1n n ntτ α α τ+ = + −

nt nτ1nτ +

α

4. Les Processus


61/94

Priorité

Forme générale du SJF, mais le critère de choix n’est plus simplement le temps.

Associe à chaque processus une priorité, et l’UCT est allouée auprocessus de plus haute priorité. De même que pour le FJS, les processus de même priorité sont arbitrés par PAPS. Ce type d’ordonnancement peut être fait avec ou sans réquisition.

Problème majeure = blocage indéfini ou famine. Il peut laisser des processus de basses priorités attendre indéfiniment l’UCT.

Solution = vieillissement automatique des processus. Cette technique consiste à augmenter graduellement la priorité des processus attendant dans le système.

4. Les Processus


62/94

Le tourniquet (Round Robin)Algorithme d’ordonnancement avec réquisition spécialement conçu pour les systèmes à temps partagé.Ajoute juste à l’algorithme de PAPS un quantum de temps limitant la durée des giclées de l’UCT. Un processus peut perdre le contrôle de l’UCT de deux manières :

•1. volontairement (similaire à PAPS sans réquisition) :•(a) parce que son exécution est terminée,•(b) parce qu’il a fait une demande d’E/S.

•2. par réquisition :•(a) parce que son quantum de temps a expiré.

Problème majeur = choix du quantum de temps. Si quantum trop long = pénalise les processus courts. Si quantum trop court = trop de changements de contexte.

En général, dans un système Unix, le quantum est fixé aux alentours de 100 ms.

4. Les Processus


63/94

Exemple : on reprend l’exemple précède, mais maintenant en imposant un quantum de 3 unités.

4. Les Processus


64/94

Ordonnancement à listes multiplesProcessus présents = caractéristiques différentes (calculs scientifiques, applications interactives, multimédia, etc...). répartition différente.

Ordonnancement de priorité avec réquisition entre files d’attente.

4. Les Processus


65/94

Évaluation des algorithmes d’ordonnancementQuel est le meilleur algorithme pour un environnement donné ? Comment ajuster ses paramètres ( pour SJF, vitesse de vieillissement pour la priorité, quantum pour le tourniquet, etc...) ?

Essais sur le système en fonctionnement réelAnalyse des résultats (statistiques, réactions des usagers, coût, etc...), Modification des paramètres et obtenir de meilleurs résultats.

Analyse déterministeDans ce cadre, on fixe une charge de travail «typique» et on compare les résultats des algorithmes. Le choix de cette charge «typique» est bien entendu crucial (et subjectif).

Modèles de files d’attente & SimulationConstruire des modèles probabilistes --> Modélisation du systèmes --> pour chacun des critères d’évaluation de performance, et de juger de l’influence de chacun des paramètres.À partir des modèles probabilistes déterminés.

4. Les Processus


66/94

Exemple d’évaluation : temps d’attente moyen (TAM)La file d’attente des processus prêts contient quatre processus, A, B, C et D (arrivés dans cette ordre), dont les temps d’exécution respectifs sont 16, 2, 8 et 12 unités de temps. Quel est le TAM pour PAPS ? Pour SJF ?Cas de PAPS

Cas de SJF :

4. Les Processus


67/94

Création de processusProcessus créés de manière dynamique. Opérateurs de création et de destruction. L’opération initialise l’état du nouveau processus.

La plupart des systèmes permettent cette création dynamique des processus.

Relation entre le processus créateur et le processus créé est importante structuration de l’ensemble sous la forme d’un arbre.

le processus créé est relié automatiquement comme fils du processus créateur (père).

Destruction : 2 cas •effective que lorsque tous les fils sont achevés. •entraîne le rattachement de ses fils à l’un de ses ancêtres.

4. Les Processus


68/94Exemple du système UnixLa création dynamique de processus est simplifiée à l’extrême. Le processus fils créé est une copie exacte du créateur le père.

La seule distinction réside dans la valeur que retourne la fonction fork() dans les deux processus (le père et le fils).

La fonction de création retourne l’identificateur du processus créé dans le cas d’un processus père, et la valeur dans le cas d’un processus fils.

4. Les Processus


69/94

Exemple de hiérarchie de processus Unix

4. Les Processus


70/94

La notion de ressourcesressource = toute entité dont a besoin un processus pour s’exécuter (processeur, mémoire, périphériques). Il en est aussi des données dont le processus a besoin et qui seraient momentanément indisponibles. Caractéristique importante = quantité de processus qui peuvent l’utiliser en même temps.

Distinction de 3 cas :•Il peut y en avoir un nombre quelconque et alors il n’y a pas decontrôle à mettre en œuvre.• Il peut y en avoir plusieurs mais en nombre limité, il est alors nécessaire de contrôler lors des allocations que ce nombre n’est pas dépassé.• Il peut y avoir au plus un processus qui utilise la ressource. On dit alors que la ressource est une ressource critique. On dit alors que les processus sont en exclusion mutuelle pour l’accès à cette ressource critique (processeur, imprimante...).

4. Les Processus


71/94

Synchronisation de processus

Processus = entités indépendantes et autonomes peuvent se trouver en conflit pour l’accès à certaines ressources communes. Nécessité de mettre en œuvre des mécanismes dits de synchronisation pour gérer ces conflits.

Conditions de course (race condition)

Situation ou deux processus ou plus doivent accéder à la même ressource. Nécessité d’un mécanisme d’exclusion mutuelle pour éviter le conflit.Section critique = partie de programme où des accès à la ressource partagée ont lieu.

4. Les Processus


72/94

Objectifs d’une bonne solution :

•Au plus 1 processus doit être dans sa section critique ;•Aucune hypothèse ne doit être faite sur la vitesse ou le nombre d’UCT ;•Aucun processus exécutant en dehors de sa section critique ne doit pouvoir bloquer d’autres processus ;•Aucun processus ne devrait avoir à attendre indéfiniment avant de pouvoir entrer en section critique.

On suppose que les processus ne «trichent» pas (n’abusent pas de leur droit d’accès, qu’ils signalent lorsqu’ils entrent dans leur section critique et lorsqu’ils la quittent).

4. Les Processus


73/94

Exclusion mutuelle avec attente active (busy wait)

Variable «de blocage» (lock variable)

Solution : Attendre que la ressource soit disponible, en vérifiant le contenu d’une variable verrou associée à la ressource qui possède deux états libre ou occupé.

...code generiquetant que (etat_verrou == occupe) ; //test de la variable verrou

//(busy wait)etat_verrou = occupe ; //entree en section critique(... acces a la ressource partagee ...) //section critiqueetat_verrou = libre ; //sortie de la sectioncritique...

Problème 1 : reporte le problème sur le verrou (nouvelle ressource partagée).

4. Les Processus


74/94


Problème 2 : Si répartiteur à réquisition : le processus peut être interrompu entre le test du verrou et l’accès à la ressource partagée.

4. Les Processus


75/94

Désactivation des interruptionsAfin d’empêcher qu’un processus soit interrompu à n’importe quel point de son exécution, une solution serait de désactiver les interruptions quand on se prépare à entrer en section critique et de les réactiver en sortant.Problème : généralement il est très dangereux d’autoriser les utilisateurs (programmes utilisateurs) à désactiver les interruptions. En cas d’erreur un processus pourrait complètement bloquer l’ordinateur.

Solution matérielle : TSL (Test and Set Lock)Certains processeurs disposent d’instructions permettant d’effectuer directement le test de la valeur d’un registre ou le contenu d’une location en mémoire et d’assigner une nouvelle valeur si la valeur courante était nulle.De cette manière un processus ne peut plus être interrompu entre le test de la variable verrou et le blocage du verrou.


4. Les Processus


76/94

Exclusion mutuelle avec attente active (busy wait)Alternance stricteExemple entre deux processus P0 et P1.

Problème avec l’alternance stricte•le nombre de processus qui partagent la ressource apparaît directement dans le code,•«à chacun son tour» n’est pas nécessairement la manière la plus efficace et la plus équitable de partager une ressource, •de plus un processus qui a une très longue section non critique peut en bloquer un autre qui attend que sont tour vienne.

4. Les Processus


77/94


Problème généraux avec l’alternance stricte•L’attente active gaspille du temps UCT. Il faut réactiver régulièrement tous les processus qui veulent entrer dans leur section critique afin qu’ils puissent vérifier si leur tour est enfin arrivé.•En règle générale, l’alternance stricte ne peut pas garantir qu’un processus n’attende indéfiniment, ou qu’un processus bloque d’autres processus en dehors de sa section critique.

4. Les Processus


78/94

Problèmes classiques de synchronisation de processusCes problèmes sont des représentations théoriques de problèmes réels d’accès à une ou plusieurs ressources partagées. Tout nouvel algorithme (méthode, solution) de synchronisation doit être confronté à cesproblèmes.

Le problème des producteurs et des consommateurs (le bufferlimité)La ressource partagée est constituée d’un buffer de taille limitée N.Les processus sont séparés en 2 types :

•un ou plusieurs producteurs qui produisent des items. Chaque producteur ayant fini de produire (calculer) un item vient l’ajouter aubuffer si celui-ci n’est pas plein. S’il est plein, il s’endort (il attend que lebuffer ne soit plus plein pour pouvoir ajouter sont item).•un ou plusieurs consommateurs qui viennent retirer des items dubuffer. Si un consommateur venant retirer un item du buffer, trouve ce dernier vide, il s’endort en attendant qu’un item soit ajouté au buffer.

Problème = régler la condition de course sur l’accès au buffer partagé.

4. Les Processus


79/94

Le problème des philosophes dîneursN philosophes passent leurs temps soit à manger, soit à penser. Afin de manger, un philosophe doit utiliser 2 fourchettes. Malheureusement, il y a exactement autant de fourchettes que de philosophes.Dès qu’un philosophe à fini de manger, il repose ses fourchettes et pense.

Le problème est de synchroniser les actions des philosophes de manière à ce qu’ils parviennent à manger et à penser.

4. Les Processus


80/94

Le problème du barbier endormi (sleeping barber)Dans ce cas la ressource est un barbier (pouvant modéliser l’UCT d’un système multiprogrammé) et chaises d’attente. Des clients viennent et demandent à être servis ; ils peuvent donc modéliser des processus cherchant à accéder à l’UCT.Tâche du barbier :

•Si au moins un client est présent, il en prend un et lui coupe les cheveux ;•Si aucun client n’est présent, il s’assied dans son fauteuil et s’endort.

Tâche d’un client :•Si le barbier est endormi, le client le réveille et se fait servir ;•Si le barbier est occupé et qu’il reste au moins une chaise disponible, le client s’assied et attend son tour ;•S’il n’y a aucune chaise disponible, le client s’en va.

Le problème est donc de faire en sorte que le barbier puisse traiter de manière «juste» les clients qui se présentent.

4. Les Processus


81/94

Les SémaphoresUn sémaphores est un mécanisme proposé par E.W. Dijkstra en 1965 plus général que le verrou (variable de blocage). Il se représente comme un distributeur de jetons, mais le nombre de jetons est fixe et non renouvelable. éviter l’attente active.

Définition d’un sémaphoreNécessité de rendre les fonctions d’appel aux sémaphores atomiques. Une commande atomique ne peut pas être interrompue, même si le quantum de temps du processus appelant a expiré. Par conséquent :

•Son temps d’exécution doit être très court.•Comme les interruptions sont bloquées pendant l’exécution de la commande, celle ci doit se faire en mode système.

Un sémaphore = variable qui contrôle l’accès à une ressource partagée et indique le nombre d’éléments de la ressource qui sont disponibles et maintient une liste des processus bloqués en attente de cette ressource (s’il y en a).Si valeur <= 1, sémaphore binaire.

4. Les Processus


82/94

Exemple d’implantation de sémaphorestype semaphore =

recordvaleur : int ;L : list of process ID;

endL = liste de processus bloqués (SLEEP)Sémaphore est >= 0, = nombre d’unités de la ressource disponibles.Sémaphore est <= 0, = nombre de processus bloqués en attente de la ressource.

Opérations atomiques pour modifier l’état (la valeur d’un sémaphore) :•DOWN(S) (ou Wait(S)) décrémente le sémaphore, puis vérifie s’il est toujours >= 0, dans ce cas tout va bien (la ressource était disponible), sinon, on bloque le processus : SLEEP(), sera réveillé quand la ressource sera libre.•UP(S) (ou Signal(S)) incrémente le sémaphore. Si celui ci était <0, il réveille le processus endormi WAKEUP(proc).

4. Les Processus


83/94

Une solution au problème des producteurs et consommateursCette solution utilise 3 sémaphores :

•un sémaphore binaire initialisé à 1, mutex, qui contrôle l’entrée et la sortie des processus de la section critique,•un sémaphore full initialisé à 0 avec une liste vide, qui contrôle le nombre d’items contenus dans le buffer, et donc les processus consommateurs,•un sémaphore empty initialisé à N (dimension du buffer) avec une liste vide qui contrôle le nombre de cases vides demeurant dans lebuffer, et donc les processus producteurs.

Cette initialisation des sémaphores ne peut pas être effectuée par les processus producteurs et consommateurs eux-mêmes puisqu’elle est commune à tous. De plus on ne peut pas laisser un processus usager manipuler directement le contenu d’un sémaphore.L’initialisation est effectuée avant la création des processus producteurs et consommateurs par leur processus parent qui crée et initialise les sémaphores par des appels système.

4. Les Processus


84/94

Une solution au problème des producteurs et consommateurs

Code Producteurvoid producteur(void){objet item ;while(TRUE)

{produire_item(&item);down(&empty);down(&mutex);ajouter_item(&item); //section critiqueup(&mutex);up(&full);}

}

Code Consommateurvoid consommateur(void){objet item ;while(TRUE)

{down(&full);down(&mutex);retirer_item(&item); //section critiqueup(&mutex);up(&empty);consommer_item(&item);}

}

4. Les Processus


85/94

Processus poids-legers et threadsIntroductionSelon le modèle classique, les notions d’application, de tâche, de job, et de processus sont à peu près équivalentes. Une application en cours d’exécution est modélisée, du point de vue du SE, par un processus.

Chaque processus a son espace d’adresse propre. Mais ce modèles possède des inconvénients :

•très souvent certaines parties d’une application pourraient êtreexécutées de manière concurrente, en «parallèle», mais elles ne peuvent être exécutées que de manière sérielle,•le modèle de processus classique n’exploite pas de manière satisfaisante les architectures multiprocesseurs.

Définitions de concurrence et parallélisme d ’une application:•le parallélisme multiprocesseurs est son degré réel d’exécution parallèle, et il est donc limité par le nombre de processeurs,•le degré de concurrence (concurrency) est le parallélisme maximal qu’elle pourrait atteindre avec un nombre illimité de processeurs.

4. Les Processus


86/94Notion de threadUne application correspond toujours à un seul processus, mais ceprocessus est composé de plusieurs chaînes de contrôle, ou threadspartageant le même espace d’adresse (et en particulier les mêmesvariables globales).

Chaque thread s’exécute de manière séquentielle (sérielle) et dispose pour cela de son propre compteur programme, de ses registres et de sa propre pile.

Les threads d’un même processus partagent le même espace d’adresse, ce qui signifie qu’il n’y a pas de protection entre threads. Un thread peut donc par exemple complètement détruire la pile d’un autre thread du même processus.

Selon ce nouveau modèle, on voit que les différents threads d’un même processus peuvent progresser à des vitesses différentes.

4. Les Processus


87/94Un thread peut être dans l’un des états suivants :

•nouveau, quand il vient d’être créé,•élu ou actif, quand il a accès à un processeur,•bloqué ou en attente (d’entrée/sortie),•terminé.

Le modèle de thread permet d’exploiter de manière bien plus efficace les architectures multiprocesseurs.

4. Les Processus


88/94

Abstraction fondamentales

Concurrence système Le kernel offre la possibilité de concurrence système (system concurrency) en reconnaissant des chaînes de contrôles multiples à l’intérieur d’un processus, et en ordonnançant ces chaînes de contrôle (souvent appelées hot threads) indépendamment.Dans le cas d’un système multiprocesseurs, plusieurs threads peuvent être simultanément activés : le répartiteur les multiplexe sur les différentes UCT disponibles.Même un système monoprocesseur peut bénéficier de la concurrencesystème ; car si l’un des threads bloque, d’autres peuvent poursuivre leur exécution.

4. Les Processus


89/94

Abstraction fondamentales

Concurrence usager Il est aussi possible d’offrir la possibilité de concurrence par le biais de librairies de threads qui peuvent être appelées par l’application. Ce type de threads, communément appelés cold threads ou coroutines, ne sont pas reconnues par le kernel. Le répartiteur continue donc à partager le temps de calcul diponible entre des processus, et non entre leurs threads.

Chaque application est donc en charge des ses propres threads, et en particulier leur alloue leur temps d’accès à l’UCT à l’intérieur du segment de temps qui lui a été alloué par le répartiteur.

C’est de cette manière que les versions classiques d’Unix et MacOSimplantent le concept de thread.

4. Les Processus


90/94

Thread du kernelUn thread du kernel n’est pas nécessairement associé à un processus usager. Il est créé et détruit, selon les besoins, de manière interne par lekernel et est chargé de l’exécution d’une fonction particulière.Il partage le texte et les données globales du kernel, mais il a sa propre pile. Il peut être ordonnancé indépendamment et utilise les mécanismes de synchronisation standards du kernel, tels que SLEEP() ou WAKEUP().

Les threads du kernel sont utilisés par exemple pour des opérations d’E/S asynchrones. La requête est gérée de manière synchrone à l’intérieur de la chaîne de contrôle, mais paraît asynchrone au restedu kernel.

Les threads du kernel sont peu coûteux à créer et à utiliser. En particulier, les changements de contexte entre threads du kernel sont rapides.

4. Les Processus


91/94

Processus poids-léger (lightweight process ou LWP)

Un processus poids-léger est un thread usager supporté par le kernel.

C’est une abstraction de haut niveau basée sur la notion de thread dukernel. Les PPL (processus poids-léger) sont ordonnancés indépendamment et partage l’espace d’adresse et les ressources du processus.

Pratiquement toutes les opérations sur les PPL (création, destruction, synchronisation) demandent l’exécution d’appels système, c’est à dire à chaque fois deux changement de mode : usager à kernel, puis kernel à usager, avec à chaque fois le passage d’une frontière de protection et la copie d’information entre l’espace kernel et l’espace usager.

4. Les Processus


92/94

Les processus poids-léger (lightweight process) sont vus par lekernel et en particulier par le répartiteur qui leur offre l’accès au(x) processeur(s) disponible(s)

4. Les Processus


93/94

Threads au niveau de l’usager

Il est aussi possible de présenter l’abstraction de thread entièrement au niveau de l’usager, sans que le kernel aie connaissance de leur existence. Ceci est accompli par des librairies telles que Cthreads de Mach etpthreads de POSIX. Dans ce cas, les interactions entre threads n’impliquent pas

le kernel et sont donc par conséquent très rapides.

L’inconvénient majeur de ce type de thread est qu’ils ne permettent pas de tirer parti des architectures multi-processeurs : quel que soit le nombre d’UCT, au plus un thread de chaque processus peut être élu à un instant donné.

4. Les Processus


94/94

Cas des threads implantés par des librairies comme C-threadsou pthreads : le répartiteur ne voit que les processus

4. Les Processus


95/94

1. Présentation des réseaux de neuronesTravaux de DEA :Identification par Réseaux de Neurones Réc

cours de systèmes d’exploitation - morere.eu · fonctionnement d’un système informatique ......

Documents