Table des Matières - Notes de coursnotesdecours.drivehq.com/courspdf/Cours...

ECI Support de cours : Systèmes d'exploitation

Version 1.1 1

Table des Matières

Chapitre I : Introduction et généralités 3

I.1. Les plus connus 6 I.2. Topologie 8

Chapitre II : Composition 10

II.1. Interface de programmation 12 II.2. L'ordonnanceur 13

II.3. La communication inter-processus 14

II.4. Gestion de la mémoire 15 II.5. La mémoire virtuelle 16

II.6. Pilotes 18 II.7. Système de fichiers 19

II.8. Réseau 21 II.9. Contrôle d'accès 23

II.10. Interface utilisateur 25 II.11. L'interface utilisateur graphique 26

II.12. Logiciels utilitaires 27

Chapitre III : Le noyau 29 III.1. Organisation générale 30

III.2. Généralités 32 III.3. Fonctions généralement remplies par un noyau 35

III.4. L’ordonnanceur 37

III.5. Gestionnaire de mémoire 39 III.6. Appels système 41

III.7. Gestion du matériel 42 III.8. Différents types de noyaux 43

III.9. Noyaux monolithiques non modulaires 44 III.10. Noyaux monolithiques modulaires 46

III.11. Systèmes à micro-noyaux 48 III.12. Noyaux hybrides 52

III.13. Noyaux temps réel 53

Chapitre IV : Ordonnancement dans les systèmes d'exploitation 55 IV.1. Commutation de contexte et élection 57

IV.2. Types d'algorithmes 61 IV.3. Round-robin 62

IV.4. Rate-monotonic scheduling (RMS) 64

IV.5. Earliest deadline first scheduling (EDF) 67 IV.6. FIFO 68

IV.7. Shortest job first (SJF, ou SJN-Shortest Job Next) 69 IV.8. Completely Fair Scheduler (CFS) 70


Version 1.1 2

Chapitre V : Communication inter-processus 74

V.1. Échange de données 76

V.2. Synchronisation 78 V.2.1. Les sémaphores … 79 V.2.2. Exemple d'usage du sémaphore 82 V.3. Échange de données et synchronisation 85

Chapitre VI : La mémoire virtuelle 86

VI.1. Mémoire virtuelle paginée 88 VI.2. Allocation à la demande 90 VI.2.1. Anomalie de Belady 92 VI.3. Efficacité 94

VI.4. Principe de localité 95 VI.4.1 Le working set 95

Chapitre VII : Système de fichiers 97

VII.1. Généralités 98

VII.2. Principe de stockage 99 VII.3. Fonctions remplies par le SGF 101

VII.4. Systèmes de fichiers et systèmes d'exploitation associés ou compatibles

103

VII.5. Exemples 104

Chapitre VIII : Réseau informatique 106 VIII.1. Généralités 107 VIII.1.1. Infrastructures 108 VIII.2. Protocoles et services 109

VIII.3. Le modèle OSI 110 VIII.3.1. Aperçu 110 VIII.3.2. Présentation de la norme 111 VIII.3.3. Architecture en couches 112 VIII.3.4. Le modèle TCP/IP 114

VIII.4. Suite des protocoles Internet 115 VIII.4.1. Couches dans la pile TCP/IP 116


Version 1.1 3

Chapitre I : Introduction et

généralités


Version 1.1 4

Le système d'exploitation, abrégé SE (en anglais operating system, abrégé OS), est l'ensemble de programmes central d'un appareil informatique qui sert d'interface entre le matériel et les logiciels applicatifs.

Intermédiaire entre les logiciels applicatifs et le matériel, voire entre les middlewares et le matériel, le système d'exploitation offre une large gamme de

services utilisés par les logiciels : il facilite l'exploitation des périphériques matériels dont il coordonne et optimise l'utilisation ; il met à disposition des logiciels une interface de programmation standardisée d'utilisation des matériels et réalise enfin différentes fonctions visant à assurer la fiabilité (tolérance aux pannes, isolation des fautes) et la sécurité informatique (traçabilité,

confidentialité, intégrité et disponibilité).

Un système d'exploitation peut servir à coordonner l'utilisation du ou des processeur(s), et accorder un certain temps pour l'exécution de chaque processus ; à réserver de l'espace dans les mémoires pour les besoins des programmes et à organiser le contenu des disques durs ou d'autres mémoires de masse en fichiers et répertoires. Il peut aussi servir à créer l'image numérique qui contiendra les interfaces homme-machine des différents programmes et à l'envoyer au moniteur ainsi qu'à recevoir les

manipulations effectuées par l'utilisateur via le clavier, la souris ou d'autres périphériques, et les transmettre aux différents programmes.


Version 1.1 5

Les systèmes d'exploitation sont souvent vendus avec les appareils informatiques - c'est le cas de Windows, Mac OS, Irix ou Symbian OS. Divers logiciels utilitaires sont fournis avec le système d'exploitation. Ils permettent à l'utilisateur de régler des paramètres de configuration du système d'exploitation, ou d'effectuer des opérations basiques de manipulation des fichiers.

Les premiers systèmes d'exploitation ont été créés dans les années

1960. En 2010 les deux familles de systèmes d'exploitation les plus populaires sont Unix (dont Mac OS X et Linux) et Windows, la famille Windows détient le quasi-monopole sur les ordinateurs personnels, avec plus de 90 % de part de marché depuis 15 ans. Les parts de marché des systèmes d'exploitation Unix sont de presque 50% sur les serveurs, et Symbian OS est le système d'exploitation le plus populaire sur téléphone mobile, avec 50% de part de marché en 2009.


Version 1.1 6

I.1. Les plus connus

Microsoft Windows (dernière version : Windows 7) : les systèmes d'exploitation de Microsoft sont actuellement pré-installés sur plus de 90 % des ordinateurs personnels. Pourtant, au moins en France, la méthode de vente de bon nombre de ses systèmes d'exploitation est contestable aux regard du code de la consommation.

Dérivés d'UNIX (sous différentes déclinaisons : BSD, System V,

etc.) dont :

GNU/Linux : un système d'exploitation libre s'appuyant sur le noyau Linux et les outils GNU installés sur + de 1 % du parc informatique mondial toutes distributions confondues

Distributions majeures : Debian, Ubuntu, Mandriva, Gentoo, Red Hat, Fedora, SuSE, Slackware, EduLinux,…

La famille BSD : un effort réussi pour rendre sa liberté au système de Berkeley comprenant :

NetBSD, OpenBSD et son dérivé OliveBSD, FreeBSD et ses dérivés PicoBSD, DragonFly BSD et PC-BSD; Darwin (sur lequel est construit Mac OS X, semi-propriétaire), OpenSolaris deSun.

Les UNIX propriétaires :

AIX (IBM, SystemV), A/UX (Apple, SystemV), BOS (Bull Operating System), IRIX (Silicon Graphics, SystemV), HP-UX (Hewlett Packard, SystemV), LynxOS (LynuxWorks), NeXTSTEP(NeXT, BSD), Sinix (Siemens), Solaris (Sun, SystemV), SunOS (Sun, BSD), Tru64 (Compaq).

Mac OS : le premier système d'exploitation des ordinateurs Apple Macintosh, qui a succédé aux systèmes Lisa et Apple II, et a été suivi de Mac OS X et d'iOS (ex-iPhone OS);


Version 1.1 7

OS/2 d'IBM ;

OS/400 présent sur les moyens systèmes IBM (AS/400 - ISéries) ;

VMS et OpenVMS (Supporté par HP qui a acheté Compaq, ex-Digital) ;

Les systèmes d'exploitation grands systèmes (mainframes) :

Multics (père d'UNIX) et héritier de CTSS

IBM : MVS, VM, DOS/VSE, TPF

Bull : GCOS

Siemens : BS2000

ITS, TOPS-10 et TOPS-20


Version 1.1 8

I.2. Topologie

Chaque système d'exploitation est conçu pour fonctionner avec une gamme particulière de machines (type de processeur, constructeur, architecture). Si un système d'exploitation est disponible pour plusieurs gammes de machines différentes, alors le même code source est compilé et adapté à chaque gamme de machine. La palette de pilotes inclus dans le système d'exploitation est adaptée au matériel informatique disponible sur le marché pour cette gamme de machine.

Selon sa construction, un système d'exploitation peut être multi-tâches ou mono-tâche, multi-utilisateurs ou mono-utilisateur, il peut aussi être multiprocesseurs et/ou en temps réel :

Un système d'exploitation est dit multi-tâches quand il permet l'exécution simultanée de plusieurs programmes. Les premiers systèmes d'exploitation multi-tâches sont apparus dans les années 1960, et tous les systèmes d'exploitation contemporains sont multi-tâches.

Il est dit multi-utilisateurs quand il est conçu pour être utilisé simultanément par plusieurs usagers, souvent à travers un réseau informatique. De tels systèmes d'exploitation sont typiquement utilisés pour des serveurs ainsi que des mainframes ou des superordinateurs. Ils sont multi-tâches et en général sécurisés, c'est-à-dire qu'ils vont refuser d'exécuter toute opération pour laquelle l'usager n'a pas préalablement reçu la permission.

Il est dit multi-processeurs quand il est conçu pour exploiter un ordinateur équipé de plusieurs processeurs. Dans de tels systèmes d'exploitation, plusieurs programmes sont exécutés

simultanément par les différents processeurs.

Il est dit temps réel quand il garantit que les opérations seront effectuées en respectant des délais très stricts, et ce quelles que soient les conditions d'utilisation. De tels systèmes d'exploitation sont utilisés dans l'industrie, l'aéronautique ou l'électronique grand public pour créer des systèmes temps réel.


Version 1.1 9

Par exemple OS/2 est un système d'exploitation multi-tâches et mono-utilisateur pour les ordinateurs personnels à l'architecture compatible PC, alors que Solaris est un système d'exploitation multi-tâches, multi-utilisateurs et multiprocesseurs pour les stations de travail, les serveurs et les superordinateurs construits par Sun Microsystems.


Version 1.1 10

Chapitre II : Composition


Version 1.1 11

Un système d'exploitation est composé d'une large palette de programmes. La composition exacte dépend de l'usage cible et du type d'appareil informatique auquel le système est destiné (ordinateur personnel, serveur, superordinateur ou encore système embarqué).

Si le système d'exploitation est destiné à être utilisé sur un ordinateur personnel ou une console de jeu vidéo, l'interface graphique sera raffinée et ergonomique. S'il est destiné à être utilisé sur un serveur, il comprendra une large palette de protocoles et de pilotes pour du matériel réseau, sera multi-tâches et muni de

contrôles d'accès. Au contraire, le nombre de pilotes sera restreint au minimum et le système d'exploitation sera prévu pour être enregistré sur une mémoire morte s'il est destiné à un assistant personnel ou un téléphone mobile. Un système d'exploitation destiné à des superordinateurs sera massivement multiprocesseur, c'est-à-dire qu'il pourra être utilisé sur un ordinateur équipé de centaines voire de milliers de processeurs.

http://fr.wikipedia.org/wiki/Ordinateur_personnel

http://fr.wikipedia.org/wiki/Serveur_(informatique)

http://fr.wikipedia.org/wiki/Superordinateur

http://fr.wikipedia.org/wiki/Syst%C3%A8me_embarqu%C3%A9

http://fr.wikipedia.org/wiki/Syst%C3%A8me_embarqu%C3%A9

http://fr.wikipedia.org/wiki/Ordinateur_personnel

http://fr.wikipedia.org/wiki/Console_de_jeu_vid%C3%A9o

http://fr.wikipedia.org/wiki/Serveur_(informatique)

http://fr.wikipedia.org/wiki/M%C3%A9moire_morte

http://fr.wikipedia.org/wiki/Assistant_personnel

http://fr.wikipedia.org/wiki/Assistant_personnel

http://fr.wikipedia.org/wiki/T%C3%A9l%C3%A9phone_mobile

http://fr.wikipedia.org/wiki/Superordinateur

http://fr.wikipedia.org/wiki/Processeur


Version 1.1 12

II.1. Interface de programmation

Le système d'exploitation effectue de nombreuses actions sur demande des logiciels applicatifs. Le point de contact entre un logiciel applicatif et le système d'exploitation est appelé interface de programmation (anglais Application Programming Interface abrégé API). Ce peut être des fonctions mises à disposition dans des bibliothèques logicielles, ou des logiciels serveur qui répondent aux requêtes envoyées par les logiciels applicatifs.

L'utilisation de la même interface de programmation quel que soit le matériel, le protocole ou le système de fichier concerné assure la portabilité des logiciels applicatifs : un logiciel applicatif donné pourra fonctionner sur différents ordinateurs, quelle que soit leur configuration, en particulier quel que soit le matériel, le système de fichier ou le protocole utilisé.

POSIX (acronyme de l'anglais Portable Operating System Interface) est une norme relative à l'interface de programmation du système d'exploitation. De nombreux systèmes d'exploitation sont conformes à cette norme, notamment les membres de la famille Unix.


Version 1.1 13

II.2. L'ordonnanceur

L'ordonnanceur (anglais scheduler) est le programme du système d'exploitation qui contrôle le déroulement des autres programmes. Dans un système d'exploitation multitâches l'ordonnanceur assure l'exécution simultanée de plusieurs programmes (concurrence).

L'exécution simultanée de plusieurs programmes est réalisée de la manière suivante: l'ordonnanceur commande l'exécution à tour de

rôle de chaque programme par le ou les processeurs de l'ordinateur, chaque processeur exécute les instructions d'un programme pendant une fraction de seconde, puis l'ordonnanceur effectue une commutation de contexte (anglais context switch), suspend l'exécution du programme en cours et passe au programme suivant.


Version 1.1 14

II.3. La communication inter-processus

Les systèmes informatiques sont typiquement composés de nombreux programmes qui coopèrent en s'échangeant des informations. Les échanges d'informations entre les processus (programmes en cours d'exécution) peuvent se faire à l'aide de messages stockés en mémoire, le système d'exploitation s'occupant de collecter les messages et les mettre à disposition de chaque destinataire. Tout processus qui attend un message sera interrompu

jusqu'à l'arrivée d'un message et l'ordonnanceur évitera toute commutation de contexte vers un processus en attente.

Le système d'exploitation s'assure également que les processus qui partagent un espace de stockage commun (en lecture ou écriture) ne se trouvent pas en situation de compétition, c'est-à-dire dans une situation où le résultat d'une opération dépend de l'ordre dans lequel les processus accèdent à l'espace partagé.


Version 1.1 15

II.4. Gestion de la mémoire

Le système peut être chargé de plusieurs tâches relatives à la mémoire. Toutes ses fonctionnalités ne sont pas toujours disponibles, en fonction du type d'architecture matériel et du système d'exploitation.

Allocation de la mémoire : réserver de la mémoire, et la mettre à disposition d'une application, d'un pilote ou une autre

partie du système d'exploitation.

Protection de la mémoire : s'assurer que la mémoire est utilisée uniquement par le programme pour lequel elle a été réservée et empêcher un programme de modifier par inadvertance ou volontairement les informations propres à un autre programme.

Pagination de la mémoire : décomposer la mémoire en zones de taille fixe: les pages.

Mémoire virtuelle et swap : simuler la présence de mémoire centrale en utilisant un autre type de mémoire. Les pages de mémoire centrale sont alors échangées (anglais swap) avec des pages contenues dans une mémoire secondaire - par exemple un disque dur - en vue de limiter l'utilisation de la mémoire centrale.


Version 1.1 16

II.5. La mémoire virtuelle

Le mécanisme dit de mémoire virtuelle est destiné à simuler la présence ou l'absence de mémoire centrale par manipulation de l'unité de gestion mémoire - un composant électronique (anglais Memory Management Unit abrégé MMU). C'est un mécanisme courant dans les systèmes d'exploitation contemporains.

La mémoire virtuelle permet d'exécuter simultanément plus de

programmes que ce que la mémoire centrale peut contenir. Chaque programme n'ayant pas besoin de la totalité des informations qu'il manipule dans la mémoire centrale, une partie des informations sont stockées dans la mémoire de masse (en général dans un fichier ou une partition de disque dur) habituellement plus importante mais plus lente et sont transférées en mémoire centrale lorsque le programme en a besoin.

Les programmes disposent d'un (ou plusieurs) espaces virtuels de mémoire continus pour travailler. Les adresses des données sont dites virtuelles dans la mesure où l'information adressée ne se trouve pas forcément en mémoire centrale, et pas forcément à l'adresse indiquée. Lorsque le programme essaie de lire ou écrire une donnée dans sa mémoire virtuelle, l'unité de gestion de mémoire cherche l'adresse physique correspondant à l'adresse virtuelle sollicitée grâce à une table de correspondance. Si l'emplacement n'est pas présent en mémoire centrale, il n'y aura évidemment aucune adresse physique correspondante. Le système d'exploitation devra alors chercher à libérer un espace en mémoire centrale en échangeant (anglais swap) le contenu d'un

emplacement donné de mémoire centrale avec le contenu sollicité, qui se trouve en mémoire de masse. Cette opération s'effectue automatiquement, à l'insu des programmes.


Version 1.1 17

Des mémoires associatives, incorporées dans l'unité de gestion de mémoire, accélèrent le calcul des adresses. Les systèmes d'exploitation utilisent généralement deux mémoires associatives : une pour le mode kernel et une pour le mode utilisateur. La mémoire du mode kernel est arrangée de manière à permettre au processeur d'utiliser la totalité de la mémoire centrale disponible - lors de l'exécution des programmes du noyau du système d'exploitation. Tandis que celle du mode utilisateur est arrangée de manière à protéger le noyau (qui est ainsi invisible pour le programme en question) - lors de l'exécution des programmes hors

du noyau.

Chaque programme dispose de sa propre table de correspondance, ce qui permet de les isoler les uns des autres. Lors d'une commutation de contexte, le système d'exploitation placera la table du programme courant dans la mémoire associative. Le système d'exploitation crée également de nouvelles tables pour les programmes qui démarrent et décide quels emplacements de mémoire virtuelle seront ou ne seront pas présents en mémoire centrale.


Version 1.1 18

II.6. Pilotes

Un pilote (anglais driver) est un programme qui contient les instructions à exécuter pour utiliser un certain périphérique informatique. Les pilotes sont fournis par l'auteur du système d'exploitation ou le fabricant du périphérique. Un système d'exploitation contient typiquement de nombreux pilotes correspondant à de nombreux composants matériels susceptibles d'être montés dans l'ordinateur.

L’interface de programmation est similaire sur tous les pilotes, tandis que les instructions du programme diffèrent en fonction des caractéristiques de chaque composant matériel, ce qui assure l'utilisation banalisée du périphérique.

Le système d'exploitation dirige l'utilisation des pilotes par les logiciels applicatifs. Il intervient lorsque plusieurs logiciels applicatifs tentent d'utiliser le même matériel en même temps, et active ou désactive les pilotes en fonction du matériel présent dans l'ordinateur.

Lors de chaque événement survenu sur un périphérique (réception d'informations, fin d'un envoi, manipulation effectuée par l'utilisateur...), ce dernier provoque une interruption matérielle, un mécanisme électronique qui provoque une commutation de contexte ; le système d'exploitation déclenche alors l'exécution des instructions du pilote concerné.

Les logiciels applicatifs ainsi que le système d'exploitation peuvent également, au besoin, déclencher l'exécution des instructions d'un pilote.


Version 1.1 19

II.7. Système de fichiers

Un système de fichier (anglais file system) est une structure en arbre dans laquelle sont stockés des fichiers ainsi que d'autres informations. Divers programmes du système d'exploitation s'occupent de répartir les fichiers sur les mémoires de masse tels que les disques durs et de les relier pour former la structure du système de fichiers.

Il existe diverses manières de disposer les fichiers dans une mémoire de masse. Une mémoire de masse qui a été remplie avec un système d'exploitation selon une disposition donnée sera reconnue par un autre système d'exploitation uniquement si celui-ci reconnaît la disposition en question. Les mémoires amovibles telles que les CD ou les DVD ont une disposition normalisée dont les spécifications sont publiques, ce qui assure leur reconnaissance par tous les systèmes d'exploitation (voir ISO 9660 et UDF).

Un système d'exploitation contient typiquement différents programmes qui servent à manipuler un système de fichier. Chaque programme manipule les fichiers conformément à une disposition donnée. Ces programmes effectuent des opérations telles que créer des fichiers, les copier, les supprimer, créer et supprimer des répertoires ainsi que formater la mémoire de masse c'est-à-dire créer une structure vide (FAT, HFS ou ext2fs).

Lorsque le système de fichier est distribué, c'est-à-dire que les fichiers sont stockés sur différents ordinateurs d'un réseau

informatique, le système d'exploitation envoie une requête à l'ordinateur qui stocke le fichier pour chaque opération à effectuer (NFS ou CIFS).


Version 1.1 20

Dans un système d'exploitation multi-utilisateurs, les programmes qui manipulent le système de fichier effectuent des contrôles pour vérifier qu'aucun fichier n'est manipulé par une personne non autorisée. Le système d'exploitation refusera toute manipulation non autorisée.


Version 1.1 21

II.8. Réseau

Dans un réseau informatique, deux ordinateurs reliés arrivent à communiquer du moment que les communications se font de part et d'autre selon les mêmes protocoles réseau. Selon le modèle OSI, les différents protocoles existants sont répartis sur sept niveaux, où un protocole d'un niveau donné peut être combiné avec n'importe quel protocole des niveaux situés en dessus et en dessous (cf Cours de M. Bawin en 2éme).

Un système d'exploitation contient typiquement plusieurs programmes nécessaires pour des échanges d'informations dans différents protocoles des niveaux 1 à 4. Tandis que les niveaux 5 à 7 sont pris en charge par les logiciels applicatifs et les middleware.

Pour les échanges d'informations selon les protocoles de niveau 1 et 2, le système d'exploitation demande l'opération au matériel de l'ordinateur par l'intermédiaire d'un pilote informatique, pilote qui peut faire partie intégrante du système d'exploitation ou être fourni par le constructeur du matériel.

Lors de l'envoi d'informations sur le réseau, un logiciel applicatif crée une information, la met en forme conformément aux protocoles des niveaux 7 à 5, puis la transmet au système d'exploitation. Divers programmes du système d'exploitation vont découper cette information en trames, puis vont mettre en forme les trames et les envoyer conformément aux protocoles des niveaux 4 à 1.

Lors de la réception de trames depuis le réseau, divers programmes du système d'exploitation vont tenter de les décoder conformément à différents protocoles des niveaux 1 à 4, puis transformer la suite de trames en un flux continu, qui sera envoyé au logiciel applicatif destinataire. Le logiciel va alors décoder le flux conformément aux protocoles de niveaux 5 à 7. Le logiciel applicatif effectue


Version 1.1 22

préalablement une connexion, c'est-à-dire une liaison logique par laquelle il va s'associer avec un flux particulier.

Le choix exact des protocoles utilisés dépend de l'ordinateur concerné et des liaisons réseau qui vont être utilisées. Divers paramètres de configuration permettent d'influencer le choix des protocoles. Ils permettent par exemple d'empêcher l'utilisation de protocoles interdits sur le réseau concerné.


Version 1.1 23

II.9. Contrôle d'accès

Dans un système d'exploitation multi-utilisateurs, un ensemble de programmes assure la sécurité des informations enregistrées dans les mémoires ainsi que la disponibilité de l'ordinateur, ceci afin de préserver la confidentialité et éviter que de manipulations effectuées par un utilisateur perturbent l'utilisation de l'ordinateur par les autres utilisateurs. Cette fonctionnalité est souvent absente des systèmes d'exploitation pour les appareils personnels.

Dans ces systèmes d'exploitation tout utilisateur doit préalablement décliner son identité avant d'utiliser l'ordinateur. Puis un programme du système d'exploitation vérifie cette identité par rapport à un annuaire ou un référentiel (authentification). Le système d'exploitation établit alors une liste des opérations autorisées ou interdites à l'utilisateur en fonction des règlements - en anglais : policies - qui ont été introduits par l'administrateur sécurité – la personne responsable de la sécurité des informations.

Lors de chaque opération demandée par un logiciel applicatif, le système d'exploitation vérifie préalablement si l'utilisateur qui manipule le logiciel applicatif est autorisé à effectuer cette opération. La vérification se fait sur la base des règlements ainsi que des listes de droits d'accès introduits par l'administrateur sécurité. Le système d'exploitation refusera toute opération non autorisée et inscrira le refus dans un journal d'activité.

En particulier, le système d'exploitation peut refuser à un utilisateur

de lire, de modifier, ou de supprimer un fichier, selon la liste des droits d'accès introduits concernant ce fichier. Le nom des personnes autorisées à modifier les listes de droits d'accès est également indiqué dans la liste de droits d'accès.


Version 1.1 24

Le système d'exploitation va également refuser la mise hors service de programmes centraux tels que les logiciels serveur ou des programmes du système d'exploitation par tout utilisateur qui n'a pas préalablement reçu le privilège d'effectuer cette opération – selon les règlements introduits par l'administrateur de sécurité.

Lorsqu'un logiciel autonome (bot informatique) demande des opérations au système d'exploitation, le logiciel doit préalablement décliner son identité en tant que produit puis, sur la base de cette identité, le système d'exploitation effectue les mêmes vérifications

que pour une personne physique.

Les mécanismes de contrôle d'accès ont aussi pour effet de lutter contre les logiciels malveillants – ceux-ci effectuent souvent des opérations susceptibles de perturber l'utilisation de l'ordinateur.


Version 1.1 25

II.10. Interface utilisateur

Un ensemble de programmes du système d'exploitation reçoit les informations envoyées par les logiciels applicatifs, et les place sur une image numérique qui sera envoyée au matériel par l'intermédiaire d'un pilote. En complément un autre ensemble de programmes reçoit les manipulations effectuées par l'utilisateur par l'intermédiaire de pilotes puis les transmettent au logiciel concerné. Ces deux ensembles créent l'interface homme-machine qui permet

à un utilisateur de dialoguer avec la machine.

Le système d'exploitation peut dialoguer avec un utilisateur par l'intermédiaire d'un autre ordinateur ou d'un terminal (interface distribuée). Les informations envoyées par les logiciels applicatifs seront alors envoyées à l'autre ordinateur selon un protocole prévu à cet effet, tandis que l'autre ordinateur enverra les manipulations effectuées par l'utilisateur (SSH, RFB ou X Window System).

Lorsque l'interface est en mode texte, l'image numérique est une grille dans laquelle sont placés des caractères d'imprimerie, la grille comporte typiquement 80 colonnes et 35 lignes. L'interface se manipule avec un clavier. Ce type d'interface, qui existe depuis les débuts de l'informatique est aujourd'hui remplacé par les interfaces graphiques.


Version 1.1 26

II.11. L'interface utilisateur graphique

Dans une interface utilisateur graphique (anglais Graphical User Interface abrégé GUI), l'image numérique est composée par un programme du système d'exploitation par superposition de points, de lignes, de pictogrammes et de caractères d'imprimerie. L'interface se manipule typiquement avec une souris selon le principe WIMP (anglais Windows, Icons, Menus and Pointer device). L'image numérique est créée à l'aide du processeur graphique de

l'ordinateur.

Lors des manipulations de la souris, le système d'exploitation déplace l'élément d'image qu'est le pointeur et effectue les calculs nécessaires pour déterminer quel est l'élément de l'image qui se trouve juste en dessous. À chaque élément de l'image peut être associé un programme. Un widget est un programme qui dessine et anime un élément d'image dont l'aspect peut-être celui d'un bouton poussoir, d'une lampe témoin, d'un ascenseur, d'une zone texte, d'un menu, etc. Divers widgets sont fournis avec le système

d'exploitation.

Les programmes pour interface graphique sont aujourd'hui (2011) inclus dans tous les systèmes d'exploitation contemporains. Le X Window System est l'ensemble des programmes pour interface utilisateur graphique inclus dans tous les systèmes d'exploitation de la famille Unix.


Version 1.1 27

II.12. Logiciels utilitaires

Un logiciel applicatif sert à assister l'utilisateur dans une activité. Les logiciels utilitaires sont des logiciels applicatifs qui permettent à l'utilisateur d'effectuer des manipulations basiques telles que démarrer des programmes, copier des fichiers ou modifier des paramètres de configuration. Divers logiciels utilitaires sont fournis avec les systèmes d'exploitation.

Un interpréteur de commandes est un programme qui permet d'exécuter d'autres programmes en écrivant leur nom éventuellement suivi de divers paramètres. Il est accompagné de plusieurs programmes qui permettent la manipulation des fichiers (copie, changement de nom...). Ce type de programme est utilisé pour effectuer des manipulations ou exécuter des scripts – suites de manipulations pré-enregistrées (commande informatique).

Un environnement de bureau est un programme dans lequel les différents éléments de l'ordinateur (programmes, fichiers, disques durs) sont présentés sous forme de pictogrammes sur lesquels il est possible d'effectuer différentes actions. Il permet d'exécuter des programmes, d'effectuer différentes opérations sur les fichiers (copie, changement du nom, déplacement ou suppression)...

Certains programmes permettent à l'utilisateur de modifier les paramètres de configuration du système d'exploitation. Ceux-ci proposent des listes à choix multiples et effectuent des contrôles de validité avant le modifier les paramètres.

D'autres programmes servent à installer des logiciels, c'est-à-dire copier les fichiers dans les emplacements prévus à cet effet, et effectuer les modifications de configuration nécessaire pour rendre le logiciel opérationnel. Ces programmes peuvent aussi servir à consulter la liste des logiciels actuellement installés dans l'ordinateur.


Version 1.1 28

Un système d'exploitation multi-utilisateurs est en général fourni avec des programmes permettant de surveiller l'utilisation - par autrui - de l'ordinateur – consultation de journaux d'activité – ou de modifier les listes de droits d'accès en vue d'autoriser ou d'interdire un fichier à certains utilisateurs.


Version 1.1 29

Chapitre III : Le noyau


Version 1.1 30

III.1. Organisation générale

Les différents programmes du système d'exploitation sont typiquement répartis en couches distinctes.

La couche supérieure est l'interface de programmation avec les logiciels applicatifs (dont font partie les logiciels utilitaires fournis avec le système d'exploitation).

Au centre, on trouve une ou plusieurs couches qui contiennent les composants principaux du système d'exploitation tels que : les programmes pour les systèmes de fichiers et le réseau, la gestion de mémoire, les pilotes, l'ordonnanceur, le gestionnaire d'interruption.

La couche inférieure, appelée couche d'abstraction matérielle (anglais hardware abstraction layer abrégé HAL), est chargée de masquer les particularités matérielles et les différences qu'il existe entre les machines sur lesquelles le système d'exploitation sera utilisé.


Version 1.1 31

Un noyau de système d’exploitation, ou simplement noyau, ou kernel, est la partie fondamentale de certains systèmes d’exploitation. Il gère les ressources de l’ordinateur et permet aux différents composants — matériels et logiciels — de communiquer entre eux.

En tant que partie du système d’exploitation, le noyau fournit des mécanismes d’abstraction du matériel, notamment de la mémoire, du (ou des) processeur(s), et des échanges d’informations entre logiciels et périphériques matériels. Le noyau autorise aussi

diverses abstractions logicielles et facilite la communication entre les processus.

Le noyau d’un système d’exploitation est lui-même un logiciel, mais ne peut cependant utiliser tous les mécanismes d’abstraction qu’il fournit aux autres logiciels. Son rôle central impose par ailleurs des performances élevées. Cela fait du noyau la partie la plus critique d’un système d’exploitation et rend sa conception et sa programmation particulièrement délicates. Plusieurs techniques

sont mises en œuvre pour simplifier la programmation des noyaux tout en garantissant de bonnes performances.


Version 1.1 32

III.2. Généralités

En informatique, le noyau d’un système d’exploitation est le logiciel qui assure :

La communication entre les logiciels et le matériel ;

La gestion des divers logiciels (tâches) d’une machine (lancement des programmes, ordonnancement…) ;

La gestion du matériel (mémoire, processeur, périphérique, stockage…).

La majorité des systèmes d’exploitation est construite autour de la notion de noyau. L’existence d’un noyau, c’est-à-dire d’un programme unique responsable de la communication entre le matériel et le logiciel, résulte de compromis complexes portant sur des questions de performance, de sécurité et d’architecture des processeurs.

L’existence d’un noyau présuppose une partition virtuelle de la mémoire vive physique en deux régions disjointes, l’une étant réservée au noyau (l’espace noyau) et l’autre aux applications (l’espace utilisateur). Cette division, fondamentale, de l’espace mémoire en un espace noyau et un espace utilisateur contribue beaucoup à donner la forme et le contenu des actuels systèmes généralistes (GNU/Linux, Windows, Mac OS X, etc.), le noyau ayant de grands pouvoirs sur l’utilisation des ressources matérielles, en particulier de la mémoire. Elle structure également le travail des développeurs : le développement de code dans l’espace noyau est a priori plus délicat que dans l’espace utilisateur car la mémoire n’y

est pas protégée. Ceci implique que des erreurs de programmation, altérant éventuellement les instructions du noyau lui-même, sont potentiellement beaucoup plus difficiles à détecter que dans l'espace utilisateur où de telles altérations sont rendues impossibles par le mécanisme de protection.


Version 1.1 33

Le noyau offre ses fonctions (l’accès aux ressources qu’il gère) au travers des appels système. Il transmet ou interprète les informations du matériel via des interruptions. C’est ce que l’on appelle les entrées et sorties.

Diverses abstractions de la notion d’application sont fournies par le noyau aux développeurs. La plus courante est celle de processus (ou tâche). Le noyau du système d’exploitation n’est en lui-même pas une tâche, mais un ensemble de fonctions pouvant être appelées par les différents processus pour effectuer des opérations

requérant un certain niveau de privilèges. Le noyau prend alors en général le relais du processus pour rendre le service demandé et lui rend le contrôle lorsque les actions correspondantes ont été réalisées.

Il peut arriver cependant que le processus puisse poursuivre une partie de son exécution sans attendre que le service ait été complètement réalisé. Des mécanismes de synchronisation sont alors nécessaires entre le noyau et le processus pour permettre à

celui-ci, une fois qu'il est arrivé au point où il a besoin que le service ait été rendu, d'attendre que le noyau lui notifie l'exécution effective du service en question.

Un processeur est capable d’exécuter un seul processus, un multiprocesseur est capable de gérer autant de processus qu’il a de processeurs. Pour pallier cet inconvénient majeur, les noyaux multitâches permettent l’exécution de plusieurs processus sur un processeur, en partageant le temps du processeur entre les processus.


Version 1.1 34

Lorsque plusieurs tâches doivent être exécutées de manière parallèle, un noyau multitâche s’appuie sur les notions de :

Commutation de contexte ;

Ordonnancement ;

Temps partagé.

Les entrées et les sorties font l’objet d’un traitement spécifique par

l’ordonnanceur.


Version 1.1 35

III.3. Fonctions généralement remplies par un noyau

Les noyaux ont comme fonctions de base d’assurer le chargement et l’exécution des processus, de gérer les entrées/sorties et de proposer une interface entre l’espace noyau et les programmes de l’espace utilisateur.

À de rares exceptions, les noyaux ne sont pas limités à leurs fonctionnalités de base. On trouve généralement dans les noyaux

les fonctions des micro-noyaux : un gestionnaire de mémoire et un ordonnanceur, ainsi que des fonctions de communication inter-processus.

En dehors de fonctions précédemment listées, de nombreux noyaux fournissent également des fonctions moins fondamentales telles que :

La gestion des systèmes de fichiers ;

Plusieurs ordonnanceurs spécialisés (batch, temps réel, entrées/sorties, etc.) ;

Des notions de processus étendues telles que les processus légers ;

Des supports réseaux (TCP/IP, PPP, pare-feu, etc.) ;

Des services réseau (NFS, etc.).

Enfin, la plupart des noyaux fournissent également des modèles de pilotes et des pilotes pour le matériel.

En dehors des fonctionnalités de base, l’ensemble des fonctions des points suivants (y compris les pilotes matériels, les fonctions réseaux et systèmes de fichiers ou les services) n'est pas nécessairement fourni par un noyau de système d’exploitation. Ces fonctions du système d’exploitation peuvent être implantées tant dans l’espace utilisateur que dans le noyau lui-même. Leur


Version 1.1 36

implantation dans le noyau est faite dans l’unique but d’augmenter les performances. En effet, suivant la conception du noyau, la même fonction appelée depuis l’espace utilisateur ou l’espace noyau a un coût temporel notoirement différent. Si cet appel de fonction est fréquent, il peut s’avérer utile d’intégrer ces fonctions au noyau pour augmenter les performances.

Ces techniques sont utilisées pour pallier des défauts des noyaux tels que les latences élevées. Autant que possible, il est préférable d’écrire un logiciel hors du noyau, dans l’espace utilisateur. En effet,

l’écriture en espace noyau suppose l’absence de mécanismes tels que la protection de la mémoire. Il est donc plus complexe d’écrire un logiciel fonctionnant dans l’espace noyau que dans l’espace utilisateur, les bugs et failles de sécurité sont bien plus dangereux.


Version 1.1 37

III.4. L’ordonnanceur

L’ordonnanceur d’un système d’exploitation n’a de sens qu’en système multitâche. Il gère l’ordre dans lequel les instructions de différentes tâches sont exécutées et est responsable de la sauvegarde et de la restauration du contexte des tâches (ce contexte est constitué des registres processeurs), appelée également commutation de contexte.

La plupart des ordonnanceurs modernes permettent d’indiquer sur quel processeur sont exécutées les tâches. Certains permettent également de migrer des tâches sur d’autres machines d’une grappe de calcul.

L’algorithme d’ordonnancement détermine quelle tâche doit s’exécuter en priorité et sur quel processeur. Cet algorithme doit permettre d’utiliser efficacement les ressources de la machine.

L’ordonnancement peut être de type « coopératif » : les tâches doivent être écrites de manière à coopérer les unes avec les autres et ainsi accepter leur suspension pour l’exécution d’une autre tâche. L’ordonnancement peut être également de type préemptif : l’ordonnanceur a la responsabilité de l’interruption des tâches et du choix de la prochaine à exécuter. Certains noyaux sont eux-mêmes préemptifs : l’ordonnanceur peut interrompre le noyau lui-même pour faire place à une activité (typiquement, toujours dans le noyau) de priorité plus élevée.


Version 1.1 38

Une étude plus détaillée sera faite dans les prochains chapitres …


Version 1.1 39

III.5. Gestionnaire de mémoire

Le gestionnaire de mémoire est le sous-ensemble du système d’exploitation qui permet de gérer la mémoire de l’ordinateur. Sa tâche la plus basique est d’allouer de la mémoire à des processus lorsqu’ils en ont besoin. Cette mémoire allouée est par défaut propre au processus qui en fait la demande.

Sur les noyaux récents, le gestionnaire de mémoire masque la localisation physique de la mémoire (en mémoire vive ou sur disque dur, dans l’espace de mémoire paginée) et présente au programme une mémoire globale uniforme dite mémoire virtuelle. Ainsi, tout processus croit manipuler une mémoire "logique" qui a les propriétés suivantes :

La mémoire peut être étendue jusqu’aux capacités théoriques de la machine;

La mémoire est privée (protégée), un processus ne peut pas accéder à la mémoire d’un autre processus (sauf allocations et autorisations spécifiques).


Version 1.1 40

L’intérêt de ne pas indiquer au processus l’emplacement physique des données est de permettre au gestionnaire de mémoire de placer et déplacer à sa convenance les données en mémoire, sans affecter les processus. Ces données peuvent notamment être fragmentées dans la mémoire vive lorsqu’un processus demande un bloc de mémoire d’une taille supérieure au plus grand bloc physique libre. Le contenu de la mémoire peut aussi être migré. Cette migration est faite sur les différents supports mémoires tels que dans la mémoire physique (plus ou moins proche du processeur),

dans la mémoire paginée, dans la mémoire accessible par réseaux (grappe de calcul).

La virtualisation de la mémoire permet aussi une gestion optimiste des ressources : la mémoire allouée mais pas encore utilisée peut être virtuellement allouée à plusieurs processus (noyau Linux).

Les programmes dans l’espace utilisateur disposent de pouvoirs restreints sur la mémoire : ils doivent demander au noyau de la

mémoire. Le noyau fait appel à son gestionnaire de mémoire pour allouer (ou non) la mémoire au processus qui la demande. Si un processus tente d’utiliser des zones de mémoire ne lui appartenant pas, il est évincé automatiquement. Le mécanisme d’éviction repose sur un mécanisme du processeur, nommément une unité de gestion de la mémoire, ou MMU, qui signale au noyau l’existence d’un accès fautif. C’est le noyau lui-même qui prend la décision de suspendre ou détruire immédiatement le processus fautif.


Version 1.1 41

III.6. Appels système

Les appels système sont des fonctions :

Appelées depuis un programme de l’espace utilisateur ;

Dont l’exécution (le traitement) est effectuée dans l’espace noyau ;

Dont le retour est effectué dans le programme appelant dans l’espace utilisateur.

En plus d’un changement de mode d’exécution, l’appel système suppose au moins deux commutations de contextes :

Contexte du programme appelant ;

Changement de contexte ;

Contexte du noyau ;

Changement de contexte ;

Contexte du programme appelant.

Le coût d’un appel système est nettement plus élevé qu’un simple appel de fonction intra-processus : alors qu’un appel de fonction ne suppose que quelques instructions primitives (chargement et exécution d’une zone mémoire), le coût d’un appel système se compte en milliers ou dizaines de milliers d’instructions primitives, générant à la fois une charge et des délais d’exécution supplémentaires. Pour ces raisons, les fonctions qui sont utilisées de manière intense sont déplacées dans l’espace noyau. Les programmes utilisateurs font alors un nombre restreint d’appels

système de haut niveau. Les nombreuses interactions de bas niveau générées par ces appels système sont effectuées dans l’espace noyau. Cela concerne notamment les pilotes de périphériques.

Les entrées/sorties font également l’objet d’un traitement par l’ordonnanceur.


Version 1.1 42

III.7. Gestion du matériel

La gestion du matériel se fait par l’intermédiaire de pilotes de périphériques. Les pilotes sont des petits logiciels légers dédiés à un matériel donné qui permettent de faire communiquer ce matériel. En raison du très grand nombre d’accès à certains matériels (disques durs par exemple), certains pilotes sont très sollicités. Ils sont généralement inclus dans l’espace noyau et communiquent avec l’espace utilisateur via les appels système.

En effet, comme cela a été vu dans le précédent paragraphe, un appel système est coûteux : il nécessite au moins deux changements de contexte. Afin de réduire le nombre des appels système effectués pour accéder à un périphérique, les interactions basiques avec le périphérique sont faites dans l’espace noyau. Les programmes utilisent ces périphériques au travers d’un nombre restreint d’appels système.

Cependant, indépendamment de l’architecture, de nombreux périphériques lents (certains appareils photographiques numériques, outils sur liaison série, etc.) sont/peuvent être pilotés depuis l’espace utilisateur, le noyau intervenant au minimum.

Il existe des couches d’abstraction de matériel (HAL) qui présentent la même interface à l’espace utilisateur et simplifient ainsi le travail des développeurs d’applications. Dans les systèmes de type UNIX, l’abstraction utilisée est le système de fichiers : les primitives open, close, read et write sont présentées à l’espace utilisateur pour

manipuler toutes sortes de périphériques. On parle dans ce cas de système de fichiers synthétique.


Version 1.1 43

III.8. Différents types de noyaux

Il existe toutes sortes de noyaux, plus ou moins spécialisés. Des noyaux spécifiques à une architecture, souvent monotâches, d’autres généralistes et souvent multitâches et multiutilisateurs. L’ensemble de ces noyaux peut être divisé en deux approches opposées d’architectures logicielles : les noyaux monolithiques et les micro-noyaux.

On considère généralement les noyaux monolithiques, de conception ancienne, comme obsolètes car difficiles à maintenir et moins « propres ». Le noyau Linux était déjà qualifié d’obsolète par Andrew Tanenbaum, dès sa création en 1991. Il ne croyait pas, à l’époque, pouvoir faire un noyau monolithique multiplate-forme et modulaire. La mise en place de micro-noyaux, qui consiste à déplacer l’essentiel des fonctions du noyau vers l’espace utilisateur, est très intéressante en théorie mais s’avère difficile en pratique. Ainsi les performances du noyau Linux (monolithique) sont supérieures à celles de ses concurrents (noyaux généralistes à

micro-noyaux), sans compter qu’il fut finalement porté sur de très nombreuses plates-formes et qu’il est modulaire depuis 1995.

Pour ces raisons de performance, les systèmes généralistes basés sur une technologie à micro-noyau, tels que Windows et Mac OS X, n’ont pas un « vrai » micro-noyau enrichi. Ils utilisent un micro-noyau hybride : certaines fonctionnalités qui devraient exister sous forme de mini-serveurs se retrouvent intégrées dans leur micro-noyau, utilisant le même espace d’adressage.

Ainsi, les deux approches d’architectures de noyaux, les micro-noyaux et les noyaux monolithiques, considérées comme diamétralement différentes en termes de conception, se rejoignent quasiment en pratique par les micro-noyaux hybrides et les noyaux monolithiques modulaires.


Version 1.1 44

III.9. Noyaux monolithiques non modulaires

Certains systèmes d’exploitation, comme d’anciennes versions de Linux, certains BSD ou certains vieux Unix ont un noyau monolithique. C’est-à-dire que l’ensemble des fonctions du système et des pilotes sont regroupés dans un seul bloc de code et un seul bloc binaire généré à la compilation.

De par la simplicité de leur concept

mais également de leur excellente vitesse d’exécution, les noyaux monolithiques ont été les premiers à être développés et mis en œuvre. Cependant, au fur et à mesure de leurs développements, le code de ces noyaux monolithiques a augmenté en taille et il s’est avéré difficile de les maintenir. Le support par les architectures monolithiques des

chargements à chaud ou dynamiques implique une augmentation du nombre de pilotes matériels compilés dans le noyau, et par suite, une augmentation de la taille de l’empreinte mémoire des noyaux. Celle-ci devint rapidement inacceptable. Les multiples dépendances créées entre les différentes fonctions du noyau empêchaient la relecture et la compréhension du code. L’évolution du code s’est faite en parallèle à l’évolution du matériel, et des problèmes de portage ont alors été mis en évidence sur les noyaux monolithiques.


Version 1.1 45

En réalité les problèmes de la portabilité de code se sont révélés avec le temps indépendants de la problématique de la technologie des noyaux. Pour preuve, NetBSD est un noyau monolithique et est porté sur un très grand nombre d’architectures, alors que des noyaux tels que HURD ou celui de Windows XP utilisent des micro-noyaux censés faciliter le portage mais n’existent que pour quelques architectures.


Version 1.1 46

III.10. Noyaux monolithiques modulaires

Pour répondre aux problèmes des noyaux monolithiques, ces derniers sont devenus modulaires. Dans ce type de noyau, seules les parties fondamentales du système sont regroupées dans un bloc de code unique (monolithique). Les autres

fonctions, comme les pilotes matériels, sont regroupées en différents modules qui peuvent être séparés tant du point de vue du code que du point de vue binaire.

La très grande majorité des systèmes actuels utilise cette technologie :

Linux, la plupart des BSD ou Solaris. Par exemple avec le noyau Linux, certaines parties peuvent être non compilées ou compilées

en tant que modules chargeables directement dans le noyau. La modularité du noyau permet le chargement à la demande de fonctionnalités et augmente les possibilités de configuration. Ainsi les systèmes de fichiers peuvent être chargés de manière indépendante, un pilote de périphérique changé, etc. Les distributions Linux, par exemple, tirent profit des modules chargeables lors de l’installation. L’ensemble des pilotes matériels sont compilés en tant que modules. Le noyau peut alors supporter l’immense variété de matériel trouvé dans les compatibles PC. Après l’installation, lors du démarrage du système, seuls les pilotes correspondants au matériel effectivement présent dans la machine

sont chargés en mémoire vive. La mémoire est économisée.

Les noyaux monolithiques modulaires conservent les principaux atouts des noyaux monolithiques purs dont ils sont issus. Ainsi, la facilité de conception et de développement est globalement maintenue et la vitesse d’exécution reste excellente. L’utilisation de


Version 1.1 47

modules implique le découpage du code source du noyau en blocs indépendants. Ces blocs améliorent l’organisation et la clarté du code source et en facilitent également la maintenance.

Les noyaux monolithiques modulaires conservent également un important défaut des noyaux monolithiques purs : une erreur dans un module met en danger la stabilité de tout le système. Les tests et certifications de ces composants doivent être plus poussés.

D’un point de vue théorique, le grand nombre de lignes de code exécutées en mode noyau engendre des problèmes de portabilité. La pratique contredit largement la théorie et les noyaux modulaires sont aujourd’hui les plus portés.


Version 1.1 48

III.11. Systèmes à micro-noyaux

Les limitations des noyaux monolithiques ont amené à une approche radicalement différente de la notion de noyau : les systèmes à micro-noyaux.

Les systèmes à micro-noyaux cherchent à minimiser les fonctionnalités

dépendantes du noyau en plaçant la plus grande partie des services du système d’exploitation à l’extérieur de ce noyau, c’est-à-dire dans l’espace utilisateur. Ces fonctionnalités sont alors fournies par de petits serveurs indépendants possédant souvent leur propre espace d’adressage.

Un petit nombre de fonctions fondamentales est conservé dans un noyau minimaliste appelé « micro-noyau ». L’ensemble des fonctionnalités habituellement proposées par les noyaux monolithiques est alors assuré par les services déplacés en espace utilisateur et par ce micro-noyau. Cet ensemble logiciel est appelé « micro-noyau enrichi ».

Ce principe a de grands avantages théoriques : en éloignant les services « à risque » des parties critiques du système d’exploitation regroupées dans le noyau, il permet de gagner en robustesse et en

fiabilité, tout en facilitant la maintenance et l’évolutivité. En revanche, les mécanismes de communication (IPC), qui deviennent fondamentaux pour assurer le passage de messages entre les serveurs, sont très lourds et peuvent limiter les performances.


Version 1.1 49

Avantages et inconvénients d’un système à micro-noyau :

Les avantages théoriques des systèmes à micro-noyaux sont la conséquence de l’utilisation du mode protégé par les services qui accompagnent le micro-noyau. En effet, en plaçant les services dans l’espace utilisateur, ceux-ci bénéficient de la protection de la mémoire. La stabilité de l’ensemble en est améliorée : une erreur d’un service en mode protégé a peu de conséquences sur la stabilité de l’ensemble de la machine.

De plus, en réduisant les possibilités pour les services de pouvoir intervenir directement sur le matériel, la sécurité du système est renforcée. Le système gagne également en possibilités de configuration. Ainsi, seuls les services utiles doivent être réellement lancés au démarrage. Les interdépendances entre les différents serveurs sont faibles. L’ajout ou le retrait d’un service ne perturbe pas l’ensemble du système. La complexité de l’ensemble est réduite.


Version 1.1 50

Le développement d’un système à micro-noyau se trouve également simplifié en tirant parti à la fois de la protection de la mémoire et de la faible interdépendance entre les services. Les erreurs provoquées par les applications en mode utilisateur sont traitées plus simplement que dans le mode noyau et ne mettent pas en péril la stabilité globale du système. L’intervention sur une fonctionnalité défectueuse consiste à arrêter l’ancien service puis à lancer le nouveau, sans devoir redémarrer toute la machine.

Les micro-noyaux ont un autre avantage : ils sont beaucoup plus

compacts que les noyaux monolithiques. 6 millions de lignes de code pour le noyau Linux 2.6.0 contre en général moins de 50 000 lignes pour les micro-noyaux. La maintenance du code exécuté en mode noyau est donc simplifiée. Le nombre réduit de lignes de code peut augmenter la portabilité du système.

Les premiers micro-noyaux (comme Mach) n’ont pas tout de suite atteint ces avantages théoriques. L’utilisation de nombreux services dans l’espace utilisateur engendre les deux problèmes suivants :

La plupart des services sont à l’extérieur du noyau et génèrent un très grand nombre d’appels système ;

Les interfaces de communication entre les services (IPC) sont complexes et trop lourdes en temps de traitement.

Le grand nombre d’appels système et la communication sous-jacente sont un défaut inhérent à la conception des micro-noyaux. Dans L4 1 , il a été résolu en plaçant encore plus de services en espace utilisateur. La rapidité de traitement des IPC a pu être

améliorée en simplifiant les communications au maximum, par exemple en supprimant toute vérification des permissions, laissant ce soin aux serveurs externes.

1 L4 est un micronoyau de seconde génération conçu et implémenté en C++ par Jochen

Liedtke. L'idée générale de L4 est résumée ainsi par Liedtke lui-même : un concept est toléré

au sein du noyau seulement si son déplacement à l'extérieur du noyau empêcherait

l'implémentation de la fonctionnalité requise par le système.


Version 1.1 51

Ces modifications radicales ont permis d’obtenir de bonnes performances mais elles ne doivent pas faire oublier qu’un micro-noyau doit être accompagné d’un grand nombre de services pour fournir des fonctionnalités équivalentes à celles des noyaux monolithiques. De plus, la grande liberté dont disposent les services au niveau de la sécurité et de la gestion de la mémoire accroît la difficulté et le temps de leur développement (ils doivent fournir leurs propres interfaces).


Version 1.1 52

III.12. Noyaux hybrides

La dénomination de « noyaux hybrides » désigne principalement des noyaux qui reprennent des concepts à la fois des noyaux monolithiques et des micro-noyaux, pour combiner les avantages des deux.

Lorsqu’au début des années 1990 les développeurs et concepteurs se sont aperçus des faiblesses des premiers micro-noyaux, certains

réintégrèrent diverses fonctionnalités non fondamentales dans le noyau, pour gagner en performance. Les micro-noyaux « purs » semblaient condamnés à l’échec.

Alors que la philosophie générale des systèmes à micro-noyaux est maintenue (seules les fonctions fondamentales sont dans l’espace noyau), certaines fonctions non critiques, mais très génératrices d’appels système, sont réintégrées dans l’espace noyau. Ce compromis permet d’améliorer considérablement les performances en conservant de nombreuses propriétés des systèmes à micro-noyaux. Un exemple de ce type de noyau hybride est le noyau XNU de Mac OS X. Il est basé sur le micro-noyau Mach 3.0 mais qui inclut du code du noyau monolithique BSD au sein de l’espace noyau.

Plus rarement, on peut rencontrer le terme « noyau hybride » pour remplacer improprement « noyau monolithique modulaire » ou « micro-noyau enrichi ».


Version 1.1 53

III.13. Noyaux temps réel

Les noyaux temps réel sont fonctionnellement spécialisés. Ce sont des noyaux généralement assez légers qui ont pour fonction de base stricte de garantir les temps d’exécution des tâches. Il n’y a pas à proprement parler de notion de rapidité de traitement ou

de réactivité dans les noyaux temps réel, cette notion est plutôt implicite à la garantie des temps d’exécution en comparaison aux critères temporels de l’application industrielle (la réactivité d’un système de freinage ABS n’a pas les mêmes critères temporels que le remplissage d’une cuve de pétrole).

Très utilisés dans le monde de l’électronique embarquée, ils sont conçus pour tourner sur des plates-formes matérielles limitées en

taille, puissance ou autonomie.

Les noyaux temps réel peuvent adopter en théorie n’importe quelle architecture précédemment listée. Ils fournissent souvent deux interfaces séparées, l’une spécialisée dans le temps réel et l’autre générique. Les applications temps réel font alors appel à la partie temps réel du noyau.

Une des architectures souvent retenue est un noyau hybride qui

s’appuie sur la combinaison d’un micro-noyau temps réel spécialisé, allouant du temps d’exécution à un noyau de système d’exploitation non spécialisé. Le système d’exploitation non spécialisé fonctionne en tant que service du micro-noyau temps réel. Cette solution permet d’assurer le fonctionnement temps réel des applications, tout en maintenant la compatibilité avec des environnements préexistants.


Version 1.1 54

Par exemple, on peut avoir un micro-noyau temps réel allouant des ressources à un noyau non temps réel tel que Linux (RTLinux, RTAI, Xenomai) ou Windows. L’environnement GNU (resp. Windows) peut alors être exécuté à l’identique sur le noyau pour lequel il a été conçu, alors que les applications temps réel peuvent faire directement appel au micro-noyau temps réel pour garantir leurs délais d’exécutions.

VxWorks est un noyau propriétaire temps réel très implanté dans l’industrie bien que les systèmes à base de noyau Linux se

déploient énormément et aient un succès grandissant via RTAI et Xenomai (RTLinux étant breveté).


Version 1.1 55

Chapitre IV : Ordonnancement

dans les systèmes d'exploitation


Version 1.1 56

Dans les systèmes d'exploitation, l’ordonnanceur désigne le composant du noyau du système d'exploitation qui choisit les processus qui vont être exécutés par les processeurs d'un ordinateur. En anglais, l'ordonnanceur est appelé scheduler.

Un processus peut avoir besoin de la ressource processeur pour, par exemple, effectuer des calculs, déclencher une interruption, etc. La plupart des composants matériel, et en particulier le processeur d'un ordinateur, n'est pas capable d'effectuer plusieurs traitements simultanément. Pour la très grande majorité des ordinateurs, avoir

un seul processeur implique de ne pouvoir effectuer qu'un traitement à la fois.

Or, à un instant donné, il est possible qu'il y ait plus de processus à exécuter qu'il n'y a de processeurs. Il est courant que de nombreux programmes soient exécutés en parallèle sur une machine.

Un des rôles du système d'exploitation, et plus précisément de l'ordonnanceur du noyau, est de permettre à tous ces processus de

s'exécuter et d'utiliser le processeur de manière optimale du point de vue de l'utilisateur. Pour arriver à donner l'illusion que plusieurs tâches sont traitées simultanément, l'ordonnanceur du noyau du système s'appuie sur les notions de commutation de contexte et d'ordonnancement.


Version 1.1 57

IV.1. Commutation de contexte et élection

Pour effectuer ces tâches, l'ordonnanceur procède de la manière suivante : à intervalles réguliers, le système appelle une procédure d'ordonnancement qui élit le processus à exécuter. Si le nouveau processus est différent de l'ancien alors survient un changement de contexte, opération qui consiste à sauvegarder le contexte d'exécution de l'ancienne tâche comme, par exemple, les registres du processeur. Cette structure de données est généralement

appelée PCB. Le système d'exploitation restaure le PCB de la nouvelle tâche.

Un bloc de contrôle de processus ou PCB (de l'anglais Process Control Block) est une structure de données du noyau d'un système d'exploitation représentant l'état d'un processus donné.

Diverses implémentations existent selon les systèmes d'exploitation, mais un PCB contient en général :

L'ID d'un processus (PID) ;

Les valeurs des registres correspondant au processus (l'état courant du processus, selon qu'il est élu, prêt ou bloqué) ;

Le compteur ordinal du processus 2;

La MMU du processus ;

Une liste de fichiers et sockets ;

D'autres informations telles que le temps CPU accumulé par le processus, etc.

2 Dans un processeur, le compteur ordinal ou pointeur d'instruction (en anglais : instruction

pointer ou program counter) est le registre qui contient l'adresse mémoire de l'instruction en

cours d'exécution ou prochainement exécutée (cela dépend de l'architecture). Une fois

l'instruction chargée, il est automatiquement incrémenté pour pointer l'instruction suivante.


Version 1.1 58

Lors d'un changement de contexte, le processus en cours est arrêté et un autre processus peut utiliser le CPU. Le noyau doit arrêter l'exécution du processus en cours, copier les valeurs des registres hardware dans le PCB, et mettre à jour les registres avec les valeurs du nouveau processus.

La commutation de contexte (context switch) consiste à sauvegarder l'état d'un processus pour restaurer à la place celui d'un autre dans le cadre de l'ordonnancement d'un système d'exploitation multitâche.

Elle peut être plus ou moins coûteuse en temps processeur suivant l'architecture matérielle, le système d'exploitation, ou le type de processus utilisé. En effet, dans le cas des processus lourds elle nécessite toujours un changement d’espace d’adressage, alors que les processus légers de même père partagent ce dernier, qui n'a alors pas besoin d'être rechargé.

Le contexte sauvegardé doit au minimum inclure une portion

notable de l'état du processeur (registres généraux, registres d'états, etc.) ainsi que, pour certains systèmes, les données nécessaires au système d'exploitation pour gérer ce processus.

La commutation de contexte invoque au moins trois étapes. Par exemple, en présumant que l'on veut commuter l'utilisation du processeur par le processus P1 vers le processus P2 :

Sauvegarder le contexte du processus P1 quelque part en mémoire (usuellement sur la pile de P1).

Retrouver le contexte de P2 en mémoire (usuellement sur la pile de P2).

Restaurer le contexte de P2 dans le processeur, la dernière étape de la restauration consistant à reprendre l'exécution de P2 à son point de dernière exécution.


Version 1.1 59

Certains processeurs peuvent sauvegarder et restaurer le contexte du processeur en interne, évitant ainsi d'avoir à sauvegarder ce contexte en mémoire vive.

Exemple :

Si n tâches doivent être exécutées de manière simultanée et qu'il est physiquement impossible pour l'ordinateur de traiter plus d'une tâche simultanément, le noyau commute rapidement le contexte

d'exécution des n tâches, de manière à ce que :

Une seule tâche soit exécutée à la fois ;

Globalement toutes les tâches soient exécutées.

Par exemple, avec 3 tâches cela peut se décomposer (ordonnancées avec l'algorithme Round-robin (Chacun son tour))

Sauvegarde par le noyau des contextes d'exécutions de 3 tâches,

Commutation de contexte et élection de la nouvelle tâche n°1

Chargement par le noyau du contexte de la tâche 1.

Exécution des instructions de la tâche 1 pendant x milli-secondes

Sauvegarde du contexte de la tâche 1








Version 1.1 60








Version 1.1 61

IV.2. Types d'algorithmes

Du choix de l'algorithme d'ordonnancement dépend le comportement du système. Il existe deux grandes classes d'ordonnancement.

L'ordonnancement en temps partagé

Il est présent sur la plupart des ordinateurs « classiques ». Par exemple l'ordonnancement « decay » ; qui est celui par défaut sous Unix. Il consiste en un système de priorités adaptatives, par exemple il privilégie les tâches interactives pour que leur temps de réponse soit bon.

L'ordonnancement en temps réel

Il fournit la certitude qu'une certaine tâche sera terminée à un instant donné. Ceci est très recherché dans les systèmes embarqués.

Un ordonnanceur temps réel est dit optimal pour un système de tâches s'il trouve une solution d'ordonnancement du système si cette solution existe. S'il ne trouve pas de solution à ce système, alors aucun autre ordonnanceur ne peut en trouver une.

Algorithmes d'ordonnancement :

Round-robin (ou méthode du tourniquet)

Rate-monotonic scheduling (RMS)

Earliest deadline first scheduling (EDF)

FIFO

Shortest job first (SJF, ou SJN -Shortest Job Next-)

Completely Fair Scheduler (CFS)


Version 1.1 62

IV.3. Round-robin

Round-robin (RR) est un algorithme d'ordonnancement courant dans les systèmes d'exploitation. Ce dernier attribue des tranches de temps à chaque processus en proportion égale, sans accorder de priorité aux processus.

Le round-robin est un jeu de parcs : un tourniquet. C'est l'idée intuitive derrière l'algorithme, chaque processus est sur le

tourniquet et ne fait que passer devant le processeur, a son tour et pendant un temps fini.

Plus formellement :

Un nouveau processus est ajouté en fin de liste (pour ne pas doubler des processus déjà existants, ce qui pourrait créer une possibilité de famine3).

L'utilisation par un processus du processeur ne peut pas dépasser un certain quantum de temps ce qui nous assure de nouveau qu'il n'y aura pas de famine.

L'attente maximum est donnée par la multiplication du nombre de processus en cours multiplié par le quantum de temps accordé à chaque processus (NB : Chaque processus dispose du même quantum de temps que les autres),

Un processus qui vient de finir d'utiliser le processeur (quantum écoulé) est placé en fin de liste,

Un processus qui a terminé son travail est sorti de la liste, par conséquent le temps d'attente pour les autres processus diminue.

3 La famine est un problème que peut avoir un algorithme d'exclusion mutuelle. Il se produit

lorsqu'un algorithme n'est pas équitable, c'est-à-dire qu'il ne garantit pas à tous les threads

souhaitant accéder à une section critique une probabilité non nulle d'y parvenir en un temps

fini.

Il est difficile de concevoir des systèmes à l'abri de famines. Pour le cas de l'exclusion mutuelle

par exemple, il existe deux algorithmes garantissant qu'il ne se produira pas de famine,

l'algorithme de Dekker et l'algorithme de Peterson, mais dans les deux cas, cette garantie est

obtenue au prix d'une coûteuse attente active.


Version 1.1 63

Ainsi pour un quantum de temps donné q, un processus attendra au plus n*q où n est le nombre de processus en attente, pour accéder au processeur.

Quand le processeur choisit un nouveau processus à traiter et le charge, cela prend du temps. Il faut donc trouver le juste milieu entre :

Un quantum court : changements de processus réguliers donc perte d'efficacité (overhead) car la commutation de contexte interviendra plus souvent.

Un quantum long : le temps de réponse sera allongé et à la limite (quantum infini), cela devient un algorithme FIFO (first in first out) premier arrivé premier servi.

En général le quantum de temps est défini en fonction du comportement statistique des processus. L'idée est de définir un quantum de temps qui fait que les processus vont à 80 % finir leur utilisation du processeur avant la fin du quantum de temps. Ainsi il n'y a que peu de perte d'efficacité.


Version 1.1 64

IV.4. Rate-monotonic scheduling (RMS)

L'ordonnancement à taux monotone (en anglais, rate-monotonic scheduling) est un algorithme d'ordonnancement temps réel en ligne à priorité constante. Il attribue la priorité la plus forte à la tâche qui possède la plus petite période. RMS est optimal dans le cadre d'un système de tâches périodiques, synchrones, indépendantes et à échéance sur requête avec un ordonnanceur préemptif4. De ce fait, il n'est généralement utilisé que pour

ordonnancer des tâches vérifiant ces propriétés.

Cet algorithme a été proposé la première fois dans un papier publié par Liu et Layland.

Outre l'algorithme à taux monotone, ce papier décrit une modélisation des tâches basée sur un triplet (Ci, Di, Ti), ainsi qu'une méthode de calcul des pires temps de réponses pour des systèmes de tâches à échéance inférieure ou égale à la période.

Ce papier est actuellement considéré comme étant une base de l'ordonnancement temps-réel.

4 En informatique, la préemption est la capacité d'un système d'exploitation multitâche à

exécuter ou stopper une tâche planifiée en cours.

Un ordonnanceur préemptible présente l'avantage d'une meilleure réactivité du système et de

son évolution, mais l'inconvénient vient des situations de compétition (lorsque le processus

d'exécution accède à la même ressource avant qu'un autre processus (préemptif) ait terminé

son utilisation).


Version 1.1 65

Les tâches (ou tasks en anglais) sont les entités manipulées par cet algorithme. Chaque tâche est modélisée par un quadruplet (ri, Ci, Di, Ti), où :

ri correspond à la date réveil de la tâche ;

Ci correspond au pire temps d'exécution de la tâche ;

Di correspond à l'échéance relative de la tâche ;

Ti correspond à la période de la tâche.

Toutefois, l'algorithme n'étant optimal que dans un contexte de

tâches simultanées (i.e. la date de réveil de chaque tâche est nulle) et à échéance sur requête (i.e. Di = Ti), il n'est pas rare de ne modéliser les tâches que par un doublet (Ci, Ti).

Test d'ordonnançabilité :

Conditions nécessaires et suffisantes :

Afin de valider un système de tâches ordonnancé ainsi, deux moyens sont offerts :

Soit, calculer le temps de réponse de chaque tâche, puis, vérifier que toutes les tâches respectent leurs échéances ;

Soit, réaliser une simulation sur un intervalle allant de 0 jusqu'au PPCM des périodes (macrocycle).

Condition suffisante :

Il existe également une condition suffisante portant sur la charge processeur U. Son test d'acceptabilité pour un système composé de n tâches, qui peut être réalisé hors ligne, nous est donné par la formule suivante :

Par exemple, la charge limite pour laquelle ce critère est valable pour n = 2 est U = 0.8284.


Version 1.1 66

Et quand le nombre de tâches tend vers l'infini :

Ainsi, on estime dans le cas général qu'un RMS peut respecter toutes les échéances si l'utilisation du processeur est inférieure ou égale à 69,3 %. Les 30,7 % restants peuvent être dédiés à des tâches de basse priorité et non temps-réel.

Cependant, cette condition est suffisante mais pas nécessaire. Il est tout à fait possible qu'un système de tâche totalisant une charge de 100 % soit ordonnançable, alors qu'un autre système de tâches n'ayant qu'une charge globale de 80 % ne le soit pas. Tout dépend des caractéristiques du système de tâches.


Version 1.1 67

IV.5. Earliest deadline first scheduling (EDF)

Earliest deadline first scheduling ("échéance proche = préparation en premier") est un algorithme d'ordonnancement préemptif, à priorité dynamique, utilisé dans les systèmes temps réel. Il attribue une priorité à chaque requête en fonction de l'échéance de cette dernière selon la règle: Plus l'échéance d'une tâche est proche, plus sa priorité est grande. De cette manière, au plus vite le travail doit être réalisé, au plus il a de chances d'être exécuté.

Avantage et inconvénient :

Cet algorithme est optimal pour tous types de système de tâches, cependant, il est assez difficile à mettre en œuvre et est donc peu utilisé. De plus, il ne prévoit aucun compromis "satisfaisant" en cas de surcharge du système (taux d'utilisation supérieur à 100 %); son implantation est donc un peu dangereuse dans les systèmes temps réel industriels.


Version 1.1 68

IV.6. FIFO

L'acronyme FIFO est l'abréviation de l'expression anglaise First In, First Out, que l'on peut traduire par « premier arrivé, premier servi » (littéralement « premier entré, premier sorti »). Ce terme est employé en informatique pour décrire une méthode de traitement des données. Cette méthode correspond à une méthode de traitement des éléments d'une file (calculs d'un ordinateur, stocks).

Si l'avantage de cette politique d'ordonnancement réside dans sa simplicité, elle pénalise les processus à temps bref d'exécution. En effet, si un processus demandant beaucoup de temps de calcul est lancé, suivi directement par une petite tâche (l'utilisateur appuie sur retour dans son traitement de texte) la petite tâche devra attendre la fin de l'autre pour s'exécuter.

Cet algorithme est également utilisé comme politique de remplacement des lignes de cache en raison de sa simplicité d'implémentation et de son faible coût. Néanmoins, il présente une anomalie connue sous le nom d'anomalie de Belady5 : augmenter le nombre d'étages de la pile peut avoir un effet négatif sur la performance.

5 L'anomalie de Belady est une anomalie de comportement observée en informatique pour

l'algorithme de remplacement des lignes de cache FIFO. Augmenter le nombre de voies de la

mémoire cache peut accroître le taux de défauts de cache. Ce phénomène n'est pas spécifique

aux mémoires caches N-associatives mais est général à toutes les applications où l'algorithme

Fifo est utilisé. Par exemple, dans les mémoires cache de haut niveau (gestion de pages…), ce

phénomène est également observable.


Version 1.1 69

IV.7. Shortest job first (SJF, ou SJN-Shortest Job

Next)

SJF est l’acronyme de Shortest Job First (« plus court processus en premier »). Il s’agit d’un algorithme d'ordonnancement, c'est-à-dire d’un algorithme servant à choisir lequel de plusieurs processus sera traité en premier par le processeur. Le choix se fait en fonction du temps d’exécution estimé du processus. Ainsi, l’ordonnanceur va laisser passer d'abord le plus court des processus de la file

d’attente.

Il existe deux versions de cet algorithme : une version préemptive, et une version non préemptive. Dans cette dernière, un processus ayant pris le contrôle de l’UC ne le quitte qu’une fois la rafale terminée.

La version préemptive, aussi appelée SRTF, Shortest Remaining Time First (« plus court temps restant en premier »), est plus

souple. Si un processus dont le temps d’exécution est plus court que le reste du temps d’exécution du processus en cours de traitement entre dans la file d’attente, alors il prendra sa place. Il y a alors une commutation de contexte, et le traitement du processus interrompu reprendra plus tard là ou il avait été laissé.

SJF s'avère un des algorithmes les plus rentables en ce qui concerne la réduction du temps passé dans la file d’attente des processus. Toutefois il est rarement utilisé en dehors d'environnements spécialisés, car il nécessite une évaluation

précise du temps d'exécution de tous les processus en attente de traitement.


Version 1.1 70

IV.8. Completely Fair Scheduler (CFS)

Le Completely Fair Scheduler (ordonnanceur complètement équitable en français), ou CFS est un ordonnanceur de tâches pour le noyau Linux, qui a fait son apparition avec la version 2.6.23 sortie le 9 octobre 2007, remplaçant ainsi le précédent ordonnanceur qui était apparu dans le noyau 2.5.2-pre10 en janvier 2002.

Il gère l'allocation de ressource processeur pour l'exécution des

processus, en maximisant l'utilisation globale du CPU tout en optimisant l'interactivité. Il a été écrit par Ingo Molnár.

Fonctionnement :

Contrairement au précédent ordonnanceur utilisé par le noyau Linux, CFS n'est pas basé sur des files de processus, mais utilise un arbre rouge-noir implémentant une chronologie des futures exécutions des tâches. En effet, l'arbre trie les processus selon une valeur représentative du manque de ces processus en temps d'allocation du processeur, par rapport au temps qu'aurait alloué un processeur dit multitâche idéal, sur lequel tous les processus s'exécuterait en même temps et à la même vitesse. Ainsi, à chaque intervention de l'ordonnanceur, il "suffit" à ce dernier de choisir le processus le plus en manque de temps d'exécution pour tendre au mieux vers le comportement du processeur multitâche idéal.


Version 1.1 71

De plus, l'ordonnanceur utilise une granularité temporelle à la nanoseconde, rendant redondante la notion de tranches de temps, les unités atomiques utilisées pour le partage du CPU entre processus. Cette connaissance précise signifie également qu'aucune heuristique6 (basée sur des statistiques, donc pouvant commettre des erreurs) n'est requise pour déterminer l'interactivité d'un processus.

Un arbre rouge-noir ???

Un arbre bicolore ou arbre rouge et noir est un type particulier d'arbre binaire de recherche, qui est une structure de données utilisée en informatique théorique. Les arbres bicolores ont été inventés en 1972 par Rudolf Bayer qui les nomma "symetric binary B-trees". Leur principal intérêt réside dans la complexité logarithmique des opérations suivantes : l'insertion, la recherche et la suppression. Ils sont cependant assez complexes à mettre en œuvre, car les opérations d'insertion et de suppression font appel à de nombreuses études de cas.

6 une heuristique est un algorithme qui fournit rapidement (en temps polynomial) une

solution réalisable, pas nécessairement optimale, pour un problème d'optimisation NP-difficile.

Une heuristique, ou méthode approximative, est donc le contraire d'un algorithme exact qui

trouve une solution optimale pour un problème donné. Les algorithmes de résolution exacts

étant de complexité exponentielle, il est généralement plus judicieux de faire appel à des

méthodes heuristiques pour des problèmes difficiles.

http://fr.wikipedia.org/wiki/Algorithmique

http://fr.wikipedia.org/wiki/Th%C3%A9orie_de_la_complexit%C3%A9_des_algorithmes#Classe_P

http://fr.wikipedia.org/wiki/Optimisation_(math%C3%A9matiques)

http://fr.wikipedia.org/wiki/NP-difficile

http://fr.wikipedia.org/wiki/Complexit%C3%A9_algorithmique


Version 1.1 72

Les arbres bicolores, ainsi que les arbres AVL7, offrent la meilleure garantie sur le temps d'insertion, de suppression et de recherche dans les cas défavorables. Ceci leur permet non seulement d'être alors utilisables dans des applications en temps réel, mais aussi de servir comme fondement d'autres structures de données à temps d'exécution garanti dans les cas défavorables, par exemple en géométrie algorithmique.

Un arbre bicolore est un arbre binaire de recherche dans lequel chaque nœud a un attribut supplémentaire : sa couleur, qui est soit rouge soit noire. En plus des restrictions imposées aux arbres binaires de recherche, on ajoute les règles suivantes :

Un nœud est soit rouge soit noir.

La racine est noire.

Le parent d'un nœud rouge est noir.

Le chemin de chaque feuille à la racine contient le même nombre de nœuds noirs.

7 En informatique théorique, les arbres AVL ont été historiquement les premiers arbres binaires

de recherche automatiquement équilibrés. Dans un arbre AVL, les hauteurs des deux sous-

arbres d'un même nœud diffèrent au plus de un.

La dénomination "arbre AVL" provient des noms de ses deux inventeurs, respectivement

Georgii Adelson-Velsky et Evguenii Landis, qui l'ont publié en 1962 sous le titre An algorithm

for the organization of information.


Version 1.1 73

Ces contraintes impliquent une propriété importante des arbres bicolores : le chemin le plus long possible d'une racine à une feuille ne peut être deux fois plus long que le plus petit possible. On a ainsi un arbre presque équilibré. Comme les opérations d'insertion, de recherche et de suppression requièrent dans le pire des cas un temps proportionnel à la taille de l'arbre, les arbres bicolores restent efficaces, contrairement aux arbres binaires de recherche ordinaires.

Pour comprendre comment ces contraintes garantissent la propriété ci-dessus, il suffit de s'apercevoir qu'aucun chemin ne peut avoir deux nœuds rouges consécutifs à cause de la propriété 3. Le plus petit chemin théorique de la racine à une feuille ne contient alors que des nœuds noirs tandis que le plus grand alterne entre les nœuds rouges et noirs. Et comme d'après la propriété 4, chacun de ces chemins contient le même nombre de nœuds noirs, le plus grand chemin ne peut être deux fois plus grand que le plus petit.

La propriété 2 n'est pas nécessaire. Les seuls cas où la racine pourrait devenir rouge étant les deux cas où sa couleur n'a pas d'importance : Soit la racine est le seul nœud, soit elle possède deux fils noirs. Cette propriété est ajoutée uniquement pour visualiser plus rapidement l'isomorphisme avec les arbres 2-3-4 : Chaque nœud noir et ses éventuels fils rouges représentent un nœud d'arbre 2-3-4.


Version 1.1 74

Chapitre V : Communication

inter-processus


Version 1.1 75

Les communications inter processus (Inter-Process Communication ou IPC) regroupent un ensemble de mécanismes permettant à des processus concurrents (ou distants) de communiquer. Ces mécanismes peuvent être classés en trois catégories :

Les outils permettant aux processus de s'échanger des données ;

Les outils permettant de synchroniser les processus, notamment pour gérer le principe de section critique8 ;

Les outils offrant directement les caractéristiques des deux

premiers (ie : permettant d'échanger des données et de synchroniser des processus).

8 En programmation concurrente, une section critique est une portion de code dans laquelle il

doit être garanti qu'il n'y aura jamais plus d'un thread simultanément. Il est nécessaire

d'utiliser des sections critiques lorsqu'il y a accès à des ressources partagées par plusieurs

thread.

Une section critique peut être protégée par un mutex, un sémaphore ou d'autres primitives de

programmation concurrente.

Puisqu'à un moment donné, jamais plus d'un thread peut être actif dans une section critique,

le thread la détenant doit la libérer le plus vite possible pour éviter qu'elle ne devienne un

goulot d'étranglement. Libérer la section critique permet d'améliorer les performances en

permettant aux threads en attente d'y accéder.


Version 1.1 76

V.1. Échange de données

Les fichiers peuvent être utilisés pour échanger des informations entre deux, ou plusieurs processus. Dans ce cas, les processus voulant envoyer des informations écrivent dans un (ou plusieurs) fichier(s) à une certaine position ; les processus souhaitant recevoir ces informations se positionnent aux « bons » emplacement dans un fichier et les lisent. Ce type d'échange est possible entre des processus concurrents, en utilisant le système de fichiers local, ou

distants en utilisant un système de fichiers distribué tel que NFS9.

La mémoire (principale) d'un système peut aussi être utilisée pour des échanges de données. Suivant le type de processus, les outils utilisés ne sont pas les mêmes.

Dans le cas des processus « classiques », l'espace mémoire du processus n'est pas partagé. On utilise alors des mécanismes de mémoire partagée, comme les segments de mémoire partagée pour Unix.

Dans le cas des processus légers l'espace mémoire est partagé, la mémoire peut donc être utilisée directement.

Dans les deux cas, les échanges sont réalisés en plaçant les données dans des variables partagées par les processus.

Quelle que soit la méthode utilisée pour partager les données, ce type de communication pose le problème des sections critiques : le moment où les processus accèdent aux données partagées. En effet si deux processus accèdent « en même temps » à une ressource, il peut se produire différents cas :

9 Network File System (ou NFS, système de fichiers en réseau) est un protocole développé par

Sun Microsystems qui permet à un ordinateur d'accéder à des fichiers via un réseau. Il fait

partie de la couche application du modèle OSI.

Ce système de fichiers en réseau permet de partager des données principalement entre

systèmes UNIX. Des versions existent pour Macintosh ou Microsoft Windows.

NFS est compatible avec IPv6 sur la plupart des systèmes.


Version 1.1 77

Les données ne sont plus cohérentes

Un ou plusieurs des processus concernés "plantent"

Un (ou plusieurs) processus est (sont) bloqué(s) : il doit attendre que la ressource soit libérée

En utilisant des fichiers, on a généralement le deuxième ou le troisième cas. Si on le prévoit, le programme peut attendre (10 millisecondes, 1 seconde etc.) et reprendre plus tard l'accès aux données. Cela dit, cette solution n'est pas toujours possible en réseau, car les fichiers ne sont pas toujours libérés correctement

(par le programme, par le système d'exploitation etc.)

En utilisant la mémoire, on a plutôt le premier cas si on ne gère rien de particulier. Cela dit, on peut prévoir des synchronisations par lectures/écritures exclusives et mettre simplement le programme en attente en cas de conflit. Dans tous les cas, le partage de données en mémoire n'est possible que sur un seul et même ordinateur.


Version 1.1 78

V.2. Synchronisation

Les mécanismes de synchronisation sont utilisés pour résoudre les problèmes de sections critiques et plus généralement pour bloquer et débloquer des processus suivant certaines conditions.

Les verrous permettent de bloquer tout ou une partie d'un fichier. Ces blocages peuvent être réalisés soit pour les opérations de lecture, soit d'écriture, soit pour les deux.

Les sémaphores sont un mécanisme plus général, ils ne sont pas associés à un type particulier de ressource et permettent de limiter l'accès concurrent à une section critique à un certain nombre de processus. Pour ce faire les sémaphores utilisent deux fonctions : P et V, et un compteur. La fonction P décrémente le compteur, si le compteur est nul le processus est bloqué. La fonction V incrémente le compteur et débloque l'un des processus bloqué.

Les signaux sont à l'origine destinés à tuer (terminer) un processus dans certaines conditions, par exemple le signal SIGSEGV tue un processus qui effectue un accès à une zone de mémoire qu'il n'a pas allouée. Les signaux peuvent cependant être déroutés vers d'autres fonctions. Le blocage d'un processus se fait alors en demandant l'attente de l'arrivée d'un signal et le déblocage consiste à envoyer un message au processus.

Le problème des mécanismes de synchronisation est que les processus ne sont bloqués que s'ils les utilisent. De plus, leur

utilisation est difficile et entraine des problèmes d'interblocage (tous les processus sont bloqués).


Version 1.1 79

V.2.1. Les sémaphores …

Un sémaphore permet de protéger une variable (ou un type de donnée abstrait) et constitue la méthode utilisée couramment pour restreindre l'accès à des ressources partagées (par exemple un espace de stockage) dans un environnement de programmation concurrente. Le sémaphore a été inventé par Edsger Dijkstra et utilisé pour la première fois dans le système d'exploitation THE Operating system.

Les sémaphores fournissent la solution la plus courante pour le fameux problème du « dîner des philosophes », bien qu'ils ne permettent pas d'éviter tous les interblocages (ou deadlocks). Pour pouvoir exister sous forme logicielle, ils nécessitent une implémentation matérielle (au niveau du microprocesseur), permettant de tester et modifier la variable protégée au cours d'un cycle insécable. En effet, dans un contexte de multiprogrammation, on ne peut prendre le risque de voir la variable modifiée par un autre processus juste après que le processus courant vient de la

tester et avant qu'il ne la modifie.

Les trois opérations prises en charge sont Init, P et V.

P et V du néerlandais Proberen et Verhogen signifient tester et incrémenter (en français "Puis-je?" et "Vas-y!"). La valeur d'un sémaphore est le nombre d'unités de ressource (exemple : imprimantes...) libres ; s'il n'y a qu'une ressource, un sémaphore à système numérique binaire avec les valeurs 0 ou 1 est utilisé.

L'opération P est en attente jusqu'à ce qu'une ressource soit

disponible, ressource qui sera immédiatement allouée au processus courant.

V est l'opération inverse; elle rend simplement une ressource disponible à nouveau après que le processus a terminé de l'utiliser.

Init est seulement utilisé pour initialiser le sémaphore. Cette opération ne doit être utilisée qu'une seule et unique fois.


Version 1.1 80

Les opérations P et V doivent être indivisibles, ce qui signifie que les différentes opérations ne peuvent pas être exécutées plusieurs fois de manière concurrente. Un processus qui désire exécuter une opération qui est déjà en cours d'exécution par un autre processus doit attendre que le premier termine.

Dans les livres en anglais, les opérations V et P sont quelques fois appelées respectivement up et down. En conception logicielle, elles sont appelées signal et wait ou release et take. De façon informelle, un bon moyen de se rappeler laquelle fait quoi est le procédé mnémotechnique les associant à Puis-je ? et Vas-y !

Pour éviter l'attente, un sémaphore peut avoir une file de processus associée (généralement une file du type FIFO). Si un processus exécute l'opération P sur un sémaphore qui a la valeur zéro, le processus est ajouté à la file du sémaphore. Quand un autre processus incrémente le sémaphore en exécutant l'opération V, et qu'il y a des processus dans la file, l'un d'eux est retiré de la file et reprend la suite de son exécution.

Le sémaphore SEM, sa liste L et son

compteur K, SEM est accessible aux opérations :

INIT(SEM, VAL)

P(SEM)

V(SEM)

Opération Init(sem, val)

Initialisation d'un sémaphore :

function Init(semaphore sem, int val)

{

disable_interrupt;

sem.K:= val;

enable_interrupt;

}


Version 1.1 81

Opération P(sem)

function P(semaphore sem)

{

disable_interrupt;

if (sem.K == 0)

{

L.suivant = processus_courant;

processus_courant.état= bloque;

reordonnancement = vrai;

}

else

{

sem.K=sem.K-1;

}

enable_interrupt;

}

Opération V(sem)

function V(semaphore sem)

{

disable_interrupt;

sem.K=sem.K+1;

if (not L.vide)

{

processus_reveille= L.tete;

processus_reveille.state = prêt;

reordonnancement = vrai;

}

enable_interrupt;

}

L'incrémentation de la variable s ne doit pas être interrompue, et l'opération P ne doit pas être interrompue après que s soit différent de 0. Ceci peut être fait par une instruction spéciale ou en ignorant les interruptions afin d'empêcher d'autres processus de devenir actifs. Les sémaphores peuvent être utilisés pour la synchronisation des entrées/sorties.


Version 1.1 82

V.2.2. Exemple d'usage du sémaphore Sémaphores bloquants : Outre les sémaphores à compteur interne, il existe également les sémaphores bloquants. Un sémaphore bloquant est un sémaphore qui est initialisé avec la valeur 0. Ceci a pour effet de bloquer n'importe quel thread qui effectue P(S) tant qu'un autre thread n'aura pas fait un V(S). Ce type d'utilisation est très utile lorsque l'on a besoin de contrôler l'ordre d'exécution entre threads. Cette utilisation des sémaphores permet de réaliser des barrières de

synchronisation. Problème du « dîner des philosophes » : La situation est la suivante :

Cinq philosophes (initialement mais il peut y en avoir beaucoup plus) se trouvent autour d'une table ;

Chacun des philosophes a devant lui un plat de spaghetti ;

À gauche de chaque plat de spaghetti se trouve une fourchette. Un philosophe n'a que trois états possibles :

Penser pendant un temps indéterminé ; Être affamé (pendant un temps déterminé et fini sinon il y a

famine) ; Manger pendant un temps déterminé et fini.

Des contraintes extérieures s'imposent à cette situation : Quand un philosophe a faim, il va se mettre dans l'état «

affamé » et attendre que les fourchettes soient libres ; Pour manger, un philosophe a besoin de deux fourchettes :

celle qui se trouve à gauche de sa propre assiette, et celle qui se trouve à droite (c'est-à-dire les deux fourchettes qui entourent sa propre assiette) ;

Si un philosophe n'arrive pas à s'emparer d'une fourchette, il reste affamé pendant un temps déterminé, en attendant de renouveler sa tentative. Le problème consiste à trouver un ordonnancement des philosophes tel qu'ils puissent tous manger, chacun à leur tour.


Version 1.1 83

Il y a N philosophes qui passent leur temps soit à réfléchir soit à manger. Chaque philosophe possède une place attitrée autour d'une table circulaire. Dans la Figure 1, chaque place est représentée par une assiette. Il y a un grand bol de spaghetti au centre de la

table. Un philosophe doit avoir deux fourchettes pour manger du spaghetti. Cependant, on dispose seulement de N fourchettes. Il y a une fourchette entre 2 assiettes ou entre 2 philosophes. Un philosophe peut seulement prendre la fourchette située immédiatement à sa droite et celle située immédiatement à sa gauche. Tous les processus représentant les philosophes sont identiques et font la même chose. Le processus est une boucle infinie dans laquelle le philosophe est d'abord en train de penser et après un certain temps, en train de manger. Il faut faire en sorte que les processus simulent le comportement des philosophes. La Figure 1 présente le problème avec 4 philosophes. Nous considérerons seulement ce cas particulier montrant 4 philosophes et 4 fourchettes entre les philosophes. Nous pouvons constater que 2 philosophes voisins ne peuvent pas manger en même temps. Un philosophe a besoin de 2 fourchettes pour manger. Comme il y a un total de 4 fourchettes, seulement 2 philosophes peuvent manger en même temps. La Figure 1 présente une solution du problème des philosophes. On utilise un sémaphore pour représenter chacune des fourchettes. Chaque fourchette est une ressource qui peut être utilisée que par un philosophe à la fois. On initialise le sémaphore à un pour indiquer qu'un seul philosophe peut l'utiliser à la fois. Si la


Version 1.1 84

fourchette n'est pas utilisée, le wait() ne sera pas bloquant. Par contre, si la fourchette est utilisée, l'opération wait() suspendra le processus. Le processus bloqué sur le wait() sera réveillé seulement quand le philosophe qui possède la fourchette la relâche avec une opération signal() sur le sémaphore correspondant. La solution de la Figure 1 montre qu'un philosophe doit faire un wait() sur chacune des 2 fourchettes qui l'entourent avant de manger. Il peut manger seulement s'il réussit à avoir les 2 fourchettes. Quand il a fini de manger, il relâche les 2 fourchettes

avec un signal(). Cette solution simple s'assure qu'un philosophe doit avoir 2 fourchettes pour manger et respecte l'interdépendance entre les processus. Cependant, elle peut produire un interblocage des processus. Supposons que tous les philosophes ont obtenu leur fourchette de droite (premier wait() dans les processus). Alors, aucun philosophe ne peut obtenir la fourchette de gauche manquante. Les philosophes attendent mutuellement un après l'autre. Le processus A attend après B, B après C, C après D et D après A. Il y a attente circulaire. Nous avons un interblocage. La Figure 2 présente une solution sans interblocage. Elle consiste à s'assurer qu'au plus 3 philosophes utilisent des fourchettes

simultanément. On évite ainsi l'attente circulaire. Les 3 processus qui ont des fourchettes ne pourront pas former une suite circulaire de processus qui s'attendent mutuellement. Il s'agit d'un problème d'exclusion mutuelle avec la modification que 3 processus peuvent exécuter le code "mange" en même temps. On utilise un sémaphore "c" qui est initialisé à 3. Tout au plus, 3 processus pourront faire le wait() sans bloquer.


Version 1.1 85

V.3. Échange de données et synchronisation Ces outils regroupent les possibilités de l’échange d’informations et de la synchronisation, et sont plus simples d'utilisation. L'idée de ce type d'outil est de communiquer en utilisant le principe des files, les processus voulant envoyer des informations les placent dans la file ; ceux voulant les recevoir les récupèrent dans cette même file. Les opérations d'écriture et de lecture dans la file sont bloquantes et permettent donc la synchronisation.

Ce principe est utilisé par les files d'attente de message 10(message queue) sous Unix, par les sockets 11Unix ou Internet, par les tubes12, nommés ou non, et par la transmission de messages (Message Passing).

10 Les files d'attente de message fournissent des liaisons asynchrones normalisées. Elles ont

pour but que l'expéditeur et le récepteur du message ne soient pas contraints de s'attendre

l'un l'autre. Des messages placés dans la file d'attente sont stockés, jusqu'à ce que le

destinataire les recherche. L'expéditeur n'a pas à attendre que le récepteur commence à traiter

son message, il poste son information et peut passer à autre chose. 11

Une socket représente un point terminal d'un canal de communication entre deux ou

plusieurs processus — un nom peut lui être attribué.

Chaque socket possède un type et un ou plusieurs processus qui lui sont associés. Elle est

également caractérisée par le domaine de communication dans lequel elle se trouve. Ce

dernier est une abstraction qui permet de regrouper les processus ayant des propriétés

communes et communiquant par l'intermédiaire de sockets. Normalement, une socket ne peut

échanger des données qu'avec une socket se trouvant dans le même domaine de

communication. 12

Le terme tube nommé (calqué sur l'anglais named pipe) est une mise en œuvre des tubes

Unix. Comme les tubes anonymes, les tubes nommés sont des zones de données organisées

en FIFO mais contrairement à ceux-ci qui sont détruits lorsque le processus qui les a créé

disparait, les tubes nommés sont liés au système d'exploitation et ils doivent être

explicitement détruits. Ce type de mécanisme se retrouve bien sûr dans tous les systèmes

d'exploitation de type Unix mais aussi dans les systèmes d'exploitation de Microsoft cependant

leur sémantique est sensiblement différente.


Version 1.1 86

Chapitre VI : La mémoire

virtuelle


Version 1.1 87

En informatique, le mécanisme de mémoire virtuelle, ou swap, a été mis au point dans les années 1960. Il repose sur l'utilisation d'une mémoire de masse (type disque dur), dans le but, entre autres, de permettre à des programmes de pouvoir s'exécuter dans un environnement matériel possédant moins de mémoire centrale que nécessaire (ou, vu autrement, de faire tourner plus de programmes que la mémoire centrale ne

peut en contenir). La mémoire virtuelle permet :

D'augmenter le taux de multiprogrammation ; De mettre en place des mécanismes de protection de la

mémoire ; De partager la mémoire entre processus.


Version 1.1 88

VI.1. Mémoire virtuelle paginée Le principe est le suivant :

Les adresses mémoires émises par le processeur sont des adresses virtuelles, indiquant la position d'un mot dans la mémoire virtuelle.

Cette mémoire virtuelle est formée de zones de même taille, appelées pages. Une adresse virtuelle est donc un couple (numéro de page, déplacement dans la page). La taille des pages est une puissance de deux, de façon à déterminer sans calcul le

déplacement (10 bits de poids faible de l'adresse virtuelle pour des pages de 1 024 mots), et le numéro de page (les autres bits).

La mémoire vive est également composée de zones de même taille, appelées cadres (frames en anglais), dans lesquelles prennent place les pages.

Un mécanisme de traduction (translation, ou génération d'adresse) assure la conversion des adresses virtuelles en adresses physiques, en consultant une table des pages (page table en anglais) pour connaître le numéro du cadre qui contient la page recherchée. L'adresse physique obtenue est le couple (numéro de cadre, déplacement).

Il peut y avoir plus de pages que de cadres (c'est là tout l'intérêt) : les pages qui ne sont pas en mémoire sont stockées sur un autre support (disque), elles seront ramenées dans un cadre quand on en aura besoin.


Version 1.1 89

La table des pages est indexée par le numéro de page. Chaque ligne est appelée « entrée dans la table des pages » (pages table entry, abrégé PTE), et contient le numéro de cadre. La table des pages pouvant être située n'importe où en mémoire, un registre spécial (PTBR pour Page Table Base Register) conserve son adresse. En pratique, le mécanisme de traduction fait partie d'un circuit électronique appelé MMU (memory management unit) qui contient également une partie de la table des pages, stockée dans une mémoire associative formée de registres rapides. Ceci évite d'avoir

à consulter la table des pages (en mémoire) pour chaque accès mémoire. Voici un exemple réel d'une machine dont le processeur génère des adresses virtuelles sur 32 bits, pouvant ainsi accéder à 4 Gio de mémoire. La taille de la page est de 4 Kio. On en déduit que le champ déplacement occupe les 12 bits de poids faible, et le champ numéro de page les 20 bits de poids fort. On notera la présence d'un champ spécial appartenant à chaque PTE. Pour simplifier, nous avons réduit la largeur de ce champ à un bit : le bit de validité. Si celui-ci est à 0, cela signifie que le numéro de cadre est invalide. Il faut donc se doter d'une technique permettant de mettre à jour cette PTE pour la rendre valide. Trois cas peuvent se produire :

L'entrée est valide : elle se substitue au numéro de page pour former l'adresse physique.

L'entrée dans la table des pages est invalide. Dans ce cas il faut trouver un cadre libre en mémoire vive et mettre son numéro dans cette entrée de la table des pages.

L'entrée dans la table des pages est valide mais correspond à une adresse sur la mémoire de masse où se trouve le contenu du cadre. Un mécanisme devra ramener ces données pour les placer en mémoire vive.


Version 1.1 90

VI.2. Allocation à la demande

Dans les deux derniers cas, une interruption – appelée défaut de page (ou parfois faute de page, traduction de l'anglais page fault) est générée par le matériel et donne la main au système d'exploitation. Celui-ci a la charge de trouver un cadre disponible en mémoire centrale afin de l'allouer au processus responsable de ce défaut de page, et éventuellement de recharger le contenu de cette frame par le contenu sauvé sur la mémoire de masse (couramment le disque dur, sur une zone appelée zone d'échange

ou swap). Il se peut qu'il n'y ait plus aucun cadre libre en mémoire centrale : celle-ci est occupée à 100 %. Dans ce cas un algorithme de pagination a la responsabilité de choisir une page « victime ». Cette page se verra soit immédiatement réaffectée au processus demandeur, soit elle sera d'abord sauvegardée sur disque dur, et l'entrée de la table des pages qui la référence sera mise à jour. La page victime peut très bien appartenir au processus qui manque de place. Ci-dessous sont listés quelques exemples d'algorithmes. La première ligne correspond à la chaîne de références, c’est-à-dire

l'ordre dans lequel le processus va accéder aux pages. On suppose que la mémoire centrale est composée de trois frames. La frame victime apparaîtra soulignée. Les défauts de page initiaux ne sont pas comptés (ils sont en nombre identique quel que soit l'algorithme choisi). L'algorithme optimal : le nombre de défauts de page est réduit à 6. La règle de remplacement est « remplacer la frame qui ne sera pas utilisée pendant la durée la plus longue ». Malheureusement, cet algorithme nécessiterait de connaître l'avenir. Les autres

algorithmes essayeront donc d'approcher cette solution optimale.

7

0

1

2

0 3

0

4

2

3

0

3

2

1

2

0

1

7

0

1

7

7

7

2

2

2

2

2

7

0

0

0

0

4

0

0

0

1

1

3

3

3

1

1


Version 1.1 91

L'algorithme le plus souvent utilisé est appelé LRU (Least recently used, soit « la moins récemment utilisée »). Il consiste à choisir comme victime le cadre qui n'a pas été référencé depuis le plus longtemps. On peut l'implémenter soit en rajoutant des bits dans chaque entrée de la table des pages qui indiquent quand a eu lieu la dernière référence à cette entrée, soit via une structure de liste où l'on amènera en première position le cadre récemment référencé, les cadres victimes restant donc en dernières positions. Cet algorithme donne lieu à 9 remplacements :

7

0

1

2

0 3

0

4

2

3

0

3

2

1

2

0

1

7

0

1

7

7

7

2

2

4

4

4

0

1

1

1

0

0

0

0

0

0

3

3

3

0

0

1

1

3

3

2

2

2

2

2

7

Autres algorithmes : Remplacement aléatoire : où la frame victime est choisie au hasard. LFU (Least frequently used soit « la moins souvent utilisée ») : on garde un compteur qui est incrémenté à chaque fois que le cadre est référencé, et la victime sera le cadre dont le compteur est le

plus bas. Inconvénient : au démarrage du programme quelques pages peuvent être intensément utilisées, comme d’autres ne le seraient jamais par la suite. La valeur du compteur sera si élevée qu'ils ne seront remplacés que trop tardivement. Il faut aussi gérer le cas de dépassement de capacité du compteur… Il peut être relativement facile de trouver des cas pathologiques qui rendent un algorithme inutilisable. Par exemple, pour l'algorithme LRU, il s'agirait d'un programme qui utilise 5 pages dans une boucle sur une machine qui ne compte que 4 cadres'. Il va d'abord utiliser

les 4 premiers cadres séquentiellement (1, 2, 3, 4) puis un défaut de page va survenir et c'est la page 1, la plus anciennement chargée, qui sera la victime. Les pages utilisées sont maintenant (5, 2, 3, 4). Puisque le programme boucle, il a besoin de la page 1 (à la suite de la page 5). Cette fois-ci, la page victime est la page 2, remplacée par la 1 : (5, 1, 3, 4), puis (5, 1, 2, 4), (5, 1, 2, 3), etc. Un défaut de page est généré à chaque itération…


Version 1.1 92

VI.2.1. Anomalie de Belady

L'anomalie de Belady est une anomalie de comportement observée en informatique pour l'algorithme de remplacement des lignes de cache FIFO. Augmenter le nombre de voies de la mémoire cache peut accroître le taux de défauts de cache. Ce phénomène n'est pas spécifique aux mémoires caches N-associatives mais est général à toutes les applications où l'algorithme FIFO est utilisé. Par exemple, dans les mémoires cache de haut niveau (gestion de pages…), ce phénomène est également observable.

Jusqu'en 1970, il était communément admis qu'une augmentation du nombre de voies améliorait la performance de l'algorithme de remplacement Fifo. László Bélády démontra que le résultat est opposé pour certaines situations atypiques et remit ainsi en question l'efficacité de cet algorithme. De nos jours, des algorithmes pseudo-LRU ou LRU lui sont préférés. Prenons l'exemple d'une mémoire cache associative de degré 3 et d'une seconde de degré 4. Comparons leurs résultats pour la séquence : 3 2 1 0 3 2 4 3 2 1 0 4. On suppose que ces lignes sont

mappées sur le même ensemble.

Nous voyons ainsi que nous obtenons 9 défauts de cache pour 3 voies et 10 pour 4 voies. Le résultat est contraire à l'intuition

première, d'où le nom d'anomalie de Belady. Bien évidemment ce genre de situations n'est pas la plus courante et l'algorithme FIFO présente un comportement normal pour la majorité des séquences. Néanmoins, cela a entravé le développement de l'algorithme FIFO dans l'industrie et a justifié aux yeux de nombreuses personnes son remplacement par des algorithmes plus efficaces (LRU, pseudo-LRU…) mais également par une politique aléatoire…

Voies 3 2 1 0 3 2 4 3 2 1 0 4

Voie 1 3 3 3 0 0 0 4 4 4 4 4 4

Voie 2

2 2 2 3 3 3 3 3 1 1 1

Voie 3

1 1 1 2 2 2 2 2 0 0

Voies accédées 3 2 1 0 3 2 4 3 2 1 0 4

Voie 1 3 3 3 3 3 3 4 4 4 4 0 0

Voie 2

2 2 2 2 2 2 3 3 3 3 4

Voie 3

1 1 1 1 1 1 2 2 2 2

Voie 4

0 0 0 0 0 0 1 1 1

(en rouge les défauts de cache)


Version 1.1 93

Les méthodes de sélection de la page victime évoquées ci-dessus peuvent s'appliquer soit aux pages appartenant à un processus (on parle alors d'« allocation locale »), soit à toutes les pages et donc à toute la mémoire (dans ce cas la technique d'allocation est dite « globale »). Dans un système d'allocation globale, le temps d'exécution d'un processus peut grandement varier d'une instance à l'autre car le nombre de défauts de page ne dépend pas du processus lui-même. D'un autre côté, ce système permet au nombre de cadres alloués à

un processus d'évoluer. Le schéma suivant montre trois processus en cours d'exécution, par exemple un éditeur de texte nommé Ed. Les trois instances sont toutes situées aux mêmes adresses virtuelles (1, 2, 3, 4, 5). Ce programme utilise deux zones mémoire distinctes : les pages qui contiennent le code, c’est-à-dire les instructions décrivant le programme, et la zone de données, le fichier en cours d'édition. Il suffit de garder les mêmes entrées dans la table des pages pour que les trois instances se partagent la zone de code. Par contre, les entrées correspondantes aux pages de données sont, elles, distinctes.


Version 1.1 94

VI.3. Efficacité On rencontre trois problèmes majeurs : La taille de la table des pages : pour une architecture où 20 bits sont réservés pour le numéro de page, la table occupera 4 Mio de mémoire minimum (1 024 entrées de 4 Kio chacune). Ce problème est résolu par l'utilisation de plusieurs tables de pages : le champ numéro de page sera décomposé en plusieurs, chacun indiquant un déplacement dans la table de plus bas niveau13.

Le temps d'accès : la table des pages étant située en mémoire, il faudrait deux accès mémoire par demande de la part du processeur. Pour pallier ce problème les entrées les plus souvent utilisées sont conservées dans une mémoire associative (mémoire cache) appelée TLB pour Translation Lookaside Buffer. Chaque adresse virtuelle issue du processeur est cherchée dans le TLB ; s'il y a correspondance, l'entrée du TLB est utilisée, sinon une interruption est déclenchée et le TLB devra être remis à jour par l'entrée de la table des pages stockée en mémoire avant que l'instruction fautive ne soit redémarrée. Tous les microprocesseurs

actuels possèdent un TLB. Phénomène de trashing (effondrement) : plus le taux de multiprogrammation augmente, moins chaque processus se voit allouer de pages. Au bout d'un moment, le système sature car trop de défauts de page sont générés. Le phénomène de trashing apparait à chaque fois que, dans un système de stockage hiérarchique, un des niveaux se voit surchargé. C'est par exemple le cas si la mémoire cache est trop petite. À ce moment-là les allers-retours incessants de données le long de la hiérarchie vont

fortement diminuer le rendement de l'ordinateur. Il est possible de diminuer les effets de ce comportement soit en rajoutant des ressources matérielles (ajouter de la mémoire), diminuer le taux de multiprogrammation, ou modifier la priorité des processus.

13

Les VAX et les Pentiums supportent deux niveaux, le SPARC trois, les Motorola 680x0

quatre... On peut aussi segmenter la table des pages.


Version 1.1 95

VI.4. Principe de localité

Le comportement des programmes n'est pas chaotique : le programme démarre, il fait appel à des fonctions (ou parties de code) qui en appellent d'autres à leur tour, etc. Chacun de ces appels définit une région. Il est probable que le programme va passer beaucoup de temps à s'exécuter au sein de quelques régions : c'est le principe de localité. Le même principe peut être appliqué aux pages contenant des données.

Autrement dit, un programme accède fréquemment à un petit ensemble de pages, et cet ensemble de pages évolue lentement avec le temps. Si l'on est capable de conserver en mémoire ces espaces souvent accédés, on diminue les chances de voir un programme se mettre à trasher, c’est-à-dire réclamer des pages qu'on vient de lui retirer récemment. VI.4.1 Le working set : espace de travail On peut définir un paramètre, Δ, qui est le nombre de références aux pages accédées par le processus durant un certain laps de

temps. La figure ci-dessous montre la valeur de l'espace de travail à deux instants différents : Il faut choisir la valeur de Δ avec soin : trop petite elle ne couvre pas l'espace de travail nominal du processus, si elle est trop grande

elle inclut des pages inutiles. Si Δ est égal à l'infini, il couvre la totalité du programme, bien sûr. Pour un unique processus, on peut représenter graphiquement comment la mémoire lui est allouée, et visualiser les espaces de travail :


Version 1.1 96

Les « plateaux » sont des zones où il n'y a pas de défaut de page : l'espace alloué est suffisamment grand pour contenir toutes les frames dont le processus a besoin pendant un temps relativement long. Les défauts de pages ont lieu

dans la partie ascendante de la transition, tandis que de la mémoire est libérée quand la courbe retombe vers le prochain espace de travail : zone d'équilibre. C'est au système d'exploitation de mettre en œuvre les algorithmes pour que la valeur de Δ soit optimum de sorte que le taux de multiprogrammation et l'utilisation de l'unité centrale soient maximisés. En d'autres termes : éviter le trashing. Si la somme des espaces de travail de chacun des processus est supérieur au nombre de frames disponibles, il y aura forcément effondrement.


Version 1.1 97

Chapitre VII :

Système de

fichiers


Version 1.1 98

VII.1. Généralités Le volume des données traitées par les applications informatiques atteint couramment plusieurs centaines de gigaoctets et va jusqu'à plusieurs téraoctets pour certaines applications industrielles. De tels volumes de données ne peuvent pas être stockés dans la mémoire centrale. De plus, un stockage persistant à long terme, permettant de sauvegarder les données traitées ou à traiter pour une utilisation future, est également nécessaire. Le principe employé pour répondre à ce problème consiste à stocker ces données dans des

mémoires secondaires sous forme de fichiers, c'est-à-dire des suites de blocs (la plus petite unité que le périphérique de stockage est capable de gérer). Le contenu de ces blocs, simple suite de données binaires, peut être interprété selon le format de fichier comme des caractères, des nombres entiers ou flottants, des codes d'opérations machines, des adresses mémoires, etc. L’échange entre les deux types de mémoire se fait ensuite par transfert de blocs. L'objectif du système de fichiers est de permettre l'accès au contenu des fichiers stockés (l'ouverture du fichier, son enregistrement sa copie ou son déplacement dans un second

emplacement, ou sa suppression) à partir de leur chemin d'accès, formé d'un nom précédé d'une liste de répertoires imbriqués. Pour l'utilisateur, un système de fichiers est vu comme une arborescence : les fichiers sont regroupés dans des répertoires (concept utilisé par la plupart des systèmes d’exploitation). Ces répertoires contiennent soit des fichiers, soit récursivement d'autres répertoires. Il y a donc un répertoire racine et des sous-répertoires. Une telle organisation génère une hiérarchie de répertoires et de fichiers organisés en arbre.


Version 1.1 99

VII.2. Principe de stockage Différentes méthodes permettent d'associer un nom de fichier à son contenu. Dans le cas du système de fichier FAT, ancien système de fichier de MS/DOS et de Windows encore largement utilisé sur les supports amovibles comme les clés USB, chaque répertoire contient une table associant les noms de fichiers à leur taille et un index pointant vers la table d'allocation de fichiers, une zone réservée du disque indiquant pour chaque bloc de données l'index du bloc suivant du même fichier.

Dans le cas des systèmes de fichier d'Unix (ou de Linux), les fichiers et les répertoires sont identifiés par un numéro unique, le numéro d'inode. Ce numéro permet d'accéder à une structure de données (inode) regroupant toutes les informations sur un fichier à l'exception du nom, notamment la protection d'accès en lecture, en écriture ou des listes de dates, ainsi que le moyen d'en retrouver le contenu. Le nom est stocké dans le répertoire associé à un numéro d'inode. Cette organisation présente l'avantage qu'un fichier unique sur disque peut être connu du système sous plusieurs noms. L'organisation du système de fichier NTFS est encore plus complexe, fonctionnant un peu à la façon d'une base de données.

Le nom d'un fichier est une chaîne de caractères, parfois de taille limitée, et dans laquelle certains caractères ayant un sens pour le système d'exploitation peuvent être interdits. C'est le cas par exemple pour les caractères « : », « / » ou « \ » sous Windows. Les systèmes de fichier Unix sont généralement neutres pour le jeu de caractère utilisé (considéré au niveau bas comme une simple suite d'octets). NTFS utilise le jeu de caractères UTF-16 pour les noms de fichiers. Sous Windows, le nom d'un fichier possède en général un suffixe

(extension) séparé par un point qui est fonction du contenu du fichier : .txt pour du texte par exemple. De cette extension va dépendre le choix des applications prenant en charge ce fichier. Toutefois, sous Linux/Unix, l'extension fait simplement partie du nom de fichier, son format est détecté par le type MIME inscrit de façon transparente dans l'en-tête des fichiers.


Version 1.1 100

Sous Linux/Unix, chaque fichier est décrit par des métadonnées (conservées dans l'inode), alors que le contenu du fichier est écrit dans un ou plusieurs blocs du support de stockage, selon la taille du fichier. Les métadonnées les plus courantes sous UNIX sont :

Droits d'accès en lecture, écriture et exécution selon l'utilisateur, le groupe, ou les autres ;

Dates de dernier accès, de modification des métadonnées (inode), de modification des données (block)1 ;

Propriétaire et groupe propriétaire du fichier ;

Taille du fichier ; Nombre d'autres inodes (liens) pointant vers le fichier ; Nombre de blocs utilisés par le fichier2 ; Type de fichier : fichier simple, lien symbolique, répertoire,

périphérique, etc. Sur la plupart des systèmes Unix, la commande stat permet d'afficher l'intégralité du contenu de l'inode.


Version 1.1 101

VII.3. Fonctions remplies par le SGF Le système de gestion des fichiers assure plusieurs fonctions : Manipulation des fichiers : des opérations sont définies pour permettre la manipulation des fichiers par les programmes d’application, à savoir : créer/détruire des fichiers, insérer, supprimer et modifier un article dans un fichier. Allocation de la place sur mémoires secondaires : les fichiers

étant de taille différente et cette taille pouvant être dynamique, le SGF alloue à chaque fichier un nombre variable de granules de mémoire secondaire de taille fixe (blocs). Localisation des fichiers : il est nécessaire de pouvoir identifier et retrouver les données ; pour cela, chaque fichier possède un ensemble d’informations descriptives (nom, adresse…) regroupées dans un inode. Sécurité et contrôle des fichiers : le SGF permet le partage des fichiers par différents programmes d’applications tout en assurant

la sécurité et la confidentialité des données. En effet, un nom et une clé de protection sont associés à chaque fichier afin de le protéger contre tout accès non autorisé ou mal intentionné lors du partage des fichiers. Le SGF se doit aussi de garantir la conservation des fichiers en cas de panne du matériel ou du logiciel. L'organisation physique sous-jacente du médium utilisé (blocs, linéaire) et les mécanismes d'entrée/sortie de bas-niveau sont masqués. L'utilisateur peut donc organiser ses données

permanentes en les distribuant dans différents fichiers. Le contenu des fichiers est déterminé par leur format, qui dépend de l'application utilisée.


Version 1.1 102

En plus de cette organisation abstraite, les systèmes de fichiers peuvent inclure la compression ou le chiffrement automatique des données, une gestion plus ou moins fine des droits d'accès aux fichiers, et une journalisation des écritures (pour la robustesse, en cas de défaillance du système). De plus, certains systèmes de fichiers peuvent s'étendre sur un réseau entier, comme par exemple NFS. Certains de ces systèmes de fichiers en réseau peuvent être distribués ou répartis, comme par exemple PVFS2.


Version 1.1 103

VII.4. Systèmes de fichiers et systèmes

d'exploitation associés ou compatibles Le choix du système de gestion des fichiers se fait principalement en fonction du système d’exploitation. Généralement, les systèmes d’exploitation les plus récents supportent un grand nombre de systèmes de fichiers. MS-DOS (et compatibles) et les premières versions de Windows 95 utilisaient les systèmes de fichiers FAT16 et FAT12 (pour les supports de moins de 16 Mio). À partir de Windows 95 OSR2, le choix entre les systèmes de fichiers a commencé à s'élargir. FAT16 et FAT32 pouvaient tous les deux être utilisés, et à partir d'une certaine taille de partition, le choix du système FAT32 était alors plus judicieux. Sous les premières versions de Windows NT (NT3.x et NT4), il y a le choix entre le système FAT16 et NTFS. Ce système d'exploitation ne supporte pas le FAT32. Généralement, le système NTFS est conseillé, car il procure une sécurité plus grande ainsi que des performances accrues par rapport au FAT. Contrairement aux

précédentes versions de Windows NT, Windows NT5 (Windows 2000) accepte des partitions de type FAT16, FAT32 et NTFS. Ainsi, le système de fichiers le plus récent (NTFS 5) est conseillé puisqu’il offre de plus nombreuses fonctionnalités que les systèmes FAT. Le SP1 de Vista propose de formater en exFAT qui est une grosse évolution de la FAT, proposant une meilleure fiabilité, une « vraie » gestion des noms longs, et l'ACL. Windows CE 6 (le futur Windows Mobile 7) gère aussi ce nouveau FS. Le but de Microsoft est de remplacer la FAT, principalement utilisée sur les supports amovibles comme les cartes mémoires. Le monde des Unix (Unix, Linux, BSD, MacOS X) supporte un très

grand nombre de systèmes de fichiers. Cela est dû au fait que malgré leur nombre, les systèmes supportés suivent généralement des standards et notamment POSIX.


Version 1.1 104

VII.5. Exemples Non journalisés

ext et ext2 : Extented FS version 2 (Linux, BSD, Windows via un pilote tiers)

exFAT : Extended File Allocation Table (nouveau système de fichiers proposé par Microsoft pour remplacer la FAT sur les supports amovibles)

FAT : File Allocation Table (DOS/Windows, Linux, BSD, OS/2, M

ac OS X). Se décompose en plusieurs catégories : FAT12 ; FAT16 ; FAT32 ; VFAT ; FATX : système de fichiers pour Xbox. FFS : Fast File System (BSD, Linux expérimental) HFS : Hierarchical File System (Mac OS, Mac OS X, Linux) HPFS : High Performance FileSystem (OS/2, Linux) minix fs (minix, Linux) S5 (UNIX System V, Linux)

Unix File System : (BSD, Linux en lecture seule) Journalisés

BeFS (BeOS, Haiku, Linux en lecture seule et expérimental) ext3 : Extented FS version 3 - notamment pour l'ajout de la

journalisation (Linux, BSD) ext4 : Extented FS version 4 - notamment pour une capacité

de 1 exa-octet et les Extents (Linux >=2.6.28) HFS+ (Mac OS X, Linux)

JFS (AIX, OS/2, Linux) JFS2 AIX5 LFS : (Linux) NSS : Novell Storage Services (Netware et Suse Linux) NTFS : New Technology FileSystem (Windows

NT/2000/XP/Vista/7, Linux (écriture disponible grâce au pilote NTFS-3G), Mac OS X (écriture disponible grâce au pilote NTFS-3G))


Version 1.1 105

ReiserFS (Linux, BSD en lecture seule) Reiser4 (Linux expérimental) Spufs : Synergistic processing unit filesystem UFS+ : Unix FS + journal (BSD, Linux en lecture seule) XFS (Irix, Linux, BSD en lecture seule)

à Snapshot Les systèmes de fichiers à snapshot, ou, en français, instantanés, offrent la possibilité d'enregistrer l'état du système de fichiers à un

instant donné.

Btrfs : ButterFS (Linux) ZFS : Zettabyte FS (Solaris10, OpenSolaris, FreeBSD 7, Mac OS X en lecture seule, Linux via FUSE) HAMMER : (DragonFly BSD datant de 2008)

Réseau (NFS : network file system en anglais)

AFS Andrew File System : (Aix, Linux) CodaFS (Linux) NFS (tous les UNIX, Linux, Mac OS X, IRIX) (Windows pour la

4) NCP NetWare Core Protocol (Novell NetWare, Linux en client

seul) SSHFS (Linux via FUSE) SMB ou Server Message Block (Windows) (Linux, BSD et Mac

OS X via Samba) CIFS (Évolution de SMB, supporté par Samba ainsi que par

Windows 2000 et XP) Tahoe3 (libre, distribué, chiffré et avec tolérance aux pannes,

tous les UNIX, Linux, Mac OS X, Windows)


Version 1.1 106

Chapitre VIII :

Réseau

informatique


Version 1.1 107

VIII.1. Généralités Partant du principe que ce cours sera largement abordé en deuxième année dans le cours de M. Bawin, nous nous en tiendrons aux concepts de base. Un réseau informatique est un ensemble d'équipements reliés entre eux pour échanger des informations. Par analogie avec un filet (un réseau est un « petit rets », c'est-à-dire un petit filet), on appelle nœud (node) l'extrémité d'une connexion, qui peut être une

intersection de plusieurs connexions (un ordinateur, un routeur, un concentrateur, un commutateur). Indépendamment de la technologie sous-jacente, on porte généralement une vue matricielle sur ce qu'est un réseau. De façon horizontale, un réseau est une strate de trois couches : les infrastructures, les fonctions de contrôle et de commande, les services rendus à l'utilisateur. De façon verticale, on utilise souvent un découpage géographique : réseau local, réseau d'accès et réseau d'interconnexion. Les réseaux informatiques filaires locaux existent depuis le milieu

des années 1970 lorsque les universités américaines commencèrent à avoir besoin d'interconnexion rapide entre les ordinateurs présents sur un même site. Les réseaux informatiques filaires étendus sont devenus nécessaires et populaires depuis les années 1970 lorsque les fabricants de matériel informatique IBM et Digital equipment créèrent les architectures SNA et DECnet, ceci en conjonction avec la digitalisation du réseau de téléphone d'AT&T qui permit la mise en place de Connexions dédiées à moyen débits entre sites distants (en oppositions aux connexions bas-débits par modem).


Version 1.1 108

VIII.1.1. Infrastructures Les infrastructures ou supports peuvent être sur des câbles dans lesquels circulent des signaux électriques, l'atmosphère (ou le vide spatial) où circulent des ondes radio, ou des fibres optiques qui propagent des ondes lumineuses. Elles permettent de relier « physiquement » des équipements assurant l'interconnexion des moyens physiques qui sont définis par des protocoles. Les équipements d'un réseau sont connectés directement ou non entre eux, conformément à quelques organisations types connues sous le

nom de topologie de réseau. Les principaux types de réseaux filaires pour les réseaux informatiques d'entreprises ou de particuliers utilisent les protocoles suivant qui proviennent du standard Ethernet : 10BASE5 : câble coaxial épais bande de base (obsolète) ; 10BASE2 : câble coaxial fin bande de base (obsolète) ; 10BASE-T : paires torsadées (10 Mb/s) ; 100BASE-T : paires torsadées (100 Mb/s) les plus généralisées aujourd'hui en réseau local (LAN) ; 1000BASE-T : paires torsadées (1 Gb/s), présent dans les nouveaux ordinateurs. 10GBASE-T : paires torsadées (10 Gb/s). Plusieurs normes définissent les modalités de fonctionnement des réseaux hertziens, comme par exemple la norme Wi-Fi (IEEE 802.11). Les courants porteurs en ligne (CPL) permettent quant à eux de transporter des flux d'information sur un réseau électrique local.


Version 1.1 109

VIII.2. Protocoles et services Les protocoles de communication définissent de façon formelle et interopérable la manière dont les informations sont échangées entre les équipements du réseau. Des logiciels dédiés à la gestion de ces protocoles sont installés sur les équipements d'interconnexion que sont par exemple les commutateurs réseau, les routeurs, les commutateurs téléphoniques, les antennes GSM, etc. Les fonctions de contrôle ainsi mises en place permettent une communication entre les équipements connectés. Le protocole

probablement le plus répandu est IP qui permet l'acheminement des paquets jusqu'à sa destination. Deux protocoles de niveau supérieur UDP et TCP permettent le transport de données. La première permet l'envoi de données d'une manière non fiable (aucune garantie de la réception du paquet par le destinataire). L'autre permet au contraire une transmission fiable des données (garantie de la réception du paquet par le destinataire par accusés de réception). Les services réseau se basent sur les protocoles pour fournir, par exemple : Des transferts de textes (SMS...) ou de données (Internet...) ; Des communications vocales (téléphone...) ; VoIP ou des diffusions

d'images (télé...). TNT hd principalement.


Version 1.1 110

VIII.3. Le modèle OSI

Le modèle OSI (de l'anglais Open Systems Interconnection, « Interconnexion de systèmes ouverts ») d'interconnexion en réseau des systèmes ouverts est un modèle de communications entre ordinateurs proposé par l'ISO (International Organization for Standardization). Il décrit les fonctionnalités nécessaires à la communication et l'organisation de ces fonctions. VIII.3.1. Aperçu

La norme complète, de référence ISO 7498 est globalement intitulée « Modèle basique de référence pour l'interconnexion des systèmes ouverts (OSI) » et est composée de 4 parties :

Le modèle de base Architecture de sécurité Dénomination et adressage Cadre général de gestion

La version de cet article ainsi que les articles consacrés à chacune des couches du modèle se concentrent sur la partie 1, révision de 1994.

Le texte de la norme proprement dite est très abstrait car il se veut applicable à de nombreux types de réseaux. Pour la rendre plus compréhensible, en plus de présenter la norme, cet article fait des liens avec les réalisations concrètes telles qu'on les trouve dans un ordinateur, c’est-à-dire des piles protocolaires concrètes (un « système réel » au sens de la section 4). De plus, la norme n'indique pas de mécanismes propres à assurer les fonctions définies alors que cet article le fait. Les exemples de services et surtout de protocoles sont pris dans le monde IP (probablement le plus connu mais aussi le plus éloigné de l'esprit de la norme), le monde RNIS

(y compris la seconde génération, plus connue sous le nom ATM) et parfois le monde OSI (qui ne fait pas que des modèles). Les combinaisons offertes par le modèle sont beaucoup plus nombreuses que celles réalisées dans des piles de protocole existantes, on ne peut donc pas donner d'exemple réel pour toutes les fonctions.


Version 1.1 111

VIII.3.2. Présentation de la norme L'objectif de cette norme est de spécifier un cadre général pour la création de normes ultérieures cohérentes. Le modèle lui-même ne définit pas de service particulier et encore moins de protocole. Concepts et terminologie : services, protocoles et interfaces Le modèle est essentiellement une architecture en couches définies et délimitées avec les notions de service, de protocole et

d'interface. Un service est une description abstraite de fonctionnalités à l'aide de primitives (commandes ou événements) telles que demande de connexion ou réception de données. Un protocole est un ensemble de messages et de règles d'échanges réalisant un service. Une interface (« point d'accès au service » dans la norme) est le moyen concret d'utiliser le service. Dans un programme, c'est typiquement un ensemble de fonctions de bibliothèque ou d'appels systèmes. Dans une réalisation matérielle, c'est par exemple un jeu de registres à l'entrée d'un circuit. Les détails d'un service varient bien sûr d'une architecture de réseau à l'autre. La classification la plus grossière se fait selon que le service fonctionne en mode connecté ou non. Malgré cette variabilité, les fonctions communes ont des noms conventionnellement constants. Ces noms ne proviennent toutefois pas directement de ISO 7498-1. connection.request est une demande de connexion sortante, i.e. à l'initiative d'une entité locale. connection.indication correspond à l'événement « Une demande de connexion entrante a été reçue. » connection.response est l'indication d'acceptation ou de rejet de la connexion connection.confirmation correspond à l'événement « La réponse du demandé a été reçue. » C'est un acquittement. data.request, data.indication et data.confirm sont le pendant pour les données.


Version 1.1 112

Les données fournies à une primitive de service sont appelées (N)-SDU (« Service Data Unit ») où N est l'indication de la couche, son numéro dans la norme, parfois une lettre tirée du nom de la couche. Les messages d'un protocole sont appelés PDU (« Protocol Data Unit »). VIII.3.3. Architecture en couches

Modèle OSI

Type de Donnée Couche Fonction

Couches

Hôte

Donnée

7. Application Point d'accès aux services réseaux

6. Présentation Gère l'encryptage et le décryptage des données, convertit les données

machine en données exploitable par n'importe quelle autre machine

5. Session Communication Interhost, gère les sessions entre les différentes

applications

Segments 4. Transport Connexions bout à bout, connectabilité et contrôle de flux

Couches

Matérielles

Paquet/Datagramme 3. Réseau Détermine le parcours des données et l'adressage logique

Trame 2. Liaison Adressage physique

Bit 1. Physique Transmission des signaux sous forme binaire

Le modèle comporte 7 couches succinctement présentées ci-dessus de bas en haut et détaillées dans leur articles respectifs. Ces couches sont parfois réparties en 2 groupes. Les 4 couches inférieures sont plutôt orientées communication et

sont souvent fournies par un système d'exploitation. Les 3 couches supérieures sont plutôt orientées application et plutôt réalisées par des bibliothèques ou un programme spécifique. Dans le monde IP, ces 3 couches sont rarement distinguées. Dans ce cas, toutes les fonctions de ces couches sont considérées comme partie intégrante du protocole applicatif.

http://fr.wikipedia.org/wiki/Contr%C3%B4le_de_flux


Version 1.1 113

Par ailleurs, les couches basses sont normalement transparentes pour les données à transporter, alors que les couches supérieures ne le sont pas nécessairement, notamment au niveau présentation. Dans une telle architecture, une « entité » de niveau (N+1) envoie des données avec la primitive « data.request » de l'entité de niveau (N) en lui fournissant comme données un (N+1)-PDU qui sera à son tour encapsulé dans un (N)-PDU. Côté récepteur, chaque entité analyse l'enveloppe protocole correspondant à sa couche et transmet les données à la couche supérieure sous la forme d'une primitive « data.indication ».

Certaines fonctions comme la détection des erreurs de transmission, leur correction et le contrôle de flux peuvent être présentes dans plusieurs couches. Ces fonctions sont décrites globalement plus loin. La caractérisation donnée ici est tirée du chapitre 7 de ISO 7498-1. La description originelle donne en plus pour chaque couche les fonctions de manipulation de commandes ou de données significatives parmi celles décrites plus bas. La couche « physique » est chargée de la transmission effective des signaux entre les interlocuteurs. Son service est limité à l'émission et la réception d'un bit ou d'un train de bit continu (notamment pour les supports synchrones). La couche « liaison de données » gère les communications entre 2 machines adjacentes, directement reliées entre elles par un support physique. La couche « réseau » gère les communications de proche en proche, généralement entre machines : routage et adressage des paquets (cf. note ci-dessous). La couche « transport » gère les communications de bout en bout entre processus (programmes en cours d'exécution). La couche « session » gère la synchronisation des échanges et les « transactions », permet l'ouverture et la fermeture de session. La couche « présentation » est chargée du codage des données applicatives, précisément de la conversion entre données manipulées au niveau applicatif et chaînes d'octets effectivement transmises.


Version 1.1 114

La couche « application » est le point d'accès aux services réseaux, elle n'a pas de service propre spécifique et entrant dans la portée de la norme. VIII.3.4. Le modèle TCP/IP Le modèle TCP/IP (appelé aussi modèle Internet), qui date de 1976, a été stabilisé bien avant la publication du modèle OSI en 1984. Il présente aussi une approche modulaire (utilisation de couches) mais en contient uniquement quatre :

Couche Physique Couche Réseau Couche Transport Couche Services

Aujourd'hui, c'est le modèle TCP/IP, plus souple, qui l'emporte sur le marché. Le modèle OSI, plus rigoureux, est principalement utilisé pour certaines applications critiques, ou pour ses fonctionnalités permettant de garantir une qualité de service.


Version 1.1 115

VIII.4. Suite des protocoles Internet

La suite TCP/IP est l'ensemble des protocoles utilisés pour le transfert des données sur Internet. Elle est souvent appelée TCP/IP, d'après le nom de deux de ses protocoles : TCP (Transmission Control Protocol) et IP (Internet Protocol), qui ont été les premiers à être définis. Le document de référence est RFC 1122. Le modèle OSI, qui décompose les différents protocoles d'une pile en sept couches, peut être utilisé pour décrire la suite de protocoles Internet, bien que les couches du modèle OSI ne correspondent pas toujours avec les habitudes d'Internet (Internet étant basé sur TCP/IP qui ne comporte que quatre couches). Dans une pile de protocoles, chaque couche résout un certain nombre de problèmes relatifs à la transmission de données, et fournit des services bien définis aux couches supérieures. Les couches hautes sont plus proches de l'utilisateur et gèrent des données plus abstraites, en utilisant les services des couches

basses qui mettent en forme ces données afin qu'elles puissent être émises sur un médium physique. Le modèle Internet a été créé afin de répondre à un problème pratique, alors que le modèle OSI correspond à une approche plus théorique, et a été développé plus tôt dans l'histoire des réseaux. Le modèle OSI est donc plus facile à comprendre, mais le modèle TCP/IP est le plus utilisé en pratique. Il est préférable d'avoir une connaissance du modèle OSI avant d'aborder TCP/IP, car les mêmes principes s'appliquent, mais sont plus simples à comprendre avec le modèle OSI.


Version 1.1 116

VIII.4.1. Couches dans la pile TCP/IP Comme les suites de protocoles TCP/IP et OSI ne correspondent pas exactement, toute définition des couches de la pile TCP/IP peut être sujette à discussion... En outre, le modèle OSI n'offre pas une richesse suffisante au niveau des couches basses pour représenter la réalité ; il est nécessaire d'ajouter une couche supplémentaire d'interconnexion de réseaux (Internetworking) entre les couches Transport et Réseau. Les protocoles spécifiques à un type de réseau particulier,

mais qui fonctionnent au-dessus de la couche de liaison de données, devraient appartenir à la couche réseau. ARP, et STP (qui fournit des chemins redondants dans un réseau tout en évitant les boucles) sont des exemples de tels protocoles. Toutefois, ce sont des protocoles locaux, qui opèrent au-dessous de la fonction d'interconnexion de réseaux ; placer ces deux groupes de protocoles (sans parler de ceux qui fonctionnent au-dessus du protocole d'interconnexion de réseaux, comme ICMP) dans la même couche peut prêter à confusion. Le schéma qui suit essaie de montrer où se situent divers protocoles de la pile TCP/IP dans le modèle OSI de l'ISO :

7 Application ex. HTTP, HTTPS, SMTP, SNMP, FTP, Telnet, NFS

6 Présentation ex. XDR, ASN.1, SMB, AFP

5 Session ex. ISO 8327 / CCITT X.225, RPC, Netbios, ASP

4 Transport ex. TCP, UDP, RTP, SCTP, SPX, ATP

3 Réseau ex. IP (IPv4 ou IPv6), ICMP, IGMP, X.25, CLNP, ARP, OSPF, RIP, IPX, DDP

2 Liaison ex. Ethernet, Token Ring, PPP, HDLC, Frame relay, RNIS (ISDN), ATM, Wi-

Fi, Bluetooth, ZigBee, irDA (Infrared Data Association)

1 Physique

ex. techniques de codage du signal (électronique, radio, laser, …) pour la

transmission des informations sur les réseaux physiques (réseaux filaires,

optiques, radioélectriques …)

http://fr.wikipedia.org/wiki/Hypertext_Transfer_Protocol

http://fr.wikipedia.org/wiki/HTTPS#HTTPS

http://fr.wikipedia.org/wiki/Simple_Mail_Transfer_Protocol

http://fr.wikipedia.org/wiki/Simple_Network_Management_Protocol

http://fr.wikipedia.org/wiki/File_Transfer_Protocol

http://fr.wikipedia.org/wiki/Telnet

http://fr.wikipedia.org/wiki/Network_File_System

http://fr.wikipedia.org/wiki/Repr%C3%A9sentation_externe_des_donn%C3%A9es

http://fr.wikipedia.org/wiki/ASN.1

http://fr.wikipedia.org/wiki/Server_message_block

http://fr.wikipedia.org/wiki/AppleTalk_Filing_Protocol

http://fr.wikipedia.org/wiki/Remote_procedure_call

http://fr.wikipedia.org/wiki/Netbios

http://fr.wikipedia.org/w/index.php?title=AppleTalk_Session_Protocol&action=edit&redlink=1

http://fr.wikipedia.org/wiki/Transmission_Control_Protocol

http://fr.wikipedia.org/wiki/User_datagram_protocol

http://fr.wikipedia.org/wiki/Real-time_transport_protocol

http://fr.wikipedia.org/wiki/Stream_Control_Transmission_Protocol

http://fr.wikipedia.org/wiki/Sequenced_packet_exchange

http://fr.wikipedia.org/wiki/AppleTalk_Transport_Protocol

http://fr.wikipedia.org/wiki/Internet_Protocol

http://fr.wikipedia.org/wiki/IPv4

http://fr.wikipedia.org/wiki/IPv6

http://fr.wikipedia.org/wiki/Internet_control_message_protocol

http://fr.wikipedia.org/wiki/Internet_Group_Management_Protocol

http://fr.wikipedia.org/wiki/X.25

http://fr.wikipedia.org/wiki/Connectionless_Network_Protocol

http://fr.wikipedia.org/wiki/Address_resolution_protocol

http://fr.wikipedia.org/wiki/Open_shortest_path_first

http://fr.wikipedia.org/wiki/Routing_information_protocol

http://fr.wikipedia.org/wiki/Internetwork_packet_exchange

http://fr.wikipedia.org/wiki/DDP

http://fr.wikipedia.org/wiki/Ethernet

http://fr.wikipedia.org/wiki/Token_Ring

http://fr.wikipedia.org/wiki/Point-to-Point_Protocol

http://fr.wikipedia.org/wiki/High_Level_Data_Link_Control

http://fr.wikipedia.org/wiki/Relais_de_trames

http://fr.wikipedia.org/wiki/R%C3%A9seau_num%C3%A9rique_%C3%A0_int%C3%A9gration_de_services

http://fr.wikipedia.org/wiki/Asynchronous_Transfer_Mode

http://fr.wikipedia.org/wiki/Wi-Fi

http://fr.wikipedia.org/wiki/Wi-Fi

http://fr.wikipedia.org/wiki/Bluetooth

http://fr.wikipedia.org/wiki/ZigBee

http://fr.wikipedia.org/wiki/IrDA

http://fr.wikipedia.org/wiki/Infrared_Data_Association

http://fr.wikipedia.org/wiki/%C3%89lectronique

http://fr.wikipedia.org/wiki/Radio%C3%A9lectricit%C3%A9

http://fr.wikipedia.org/wiki/Laser


Version 1.1 117

Habituellement, les trois couches supérieures du modèle OSI (Application, Présentation et Session) sont considérées comme une seule couche Application dans TCP/IP. Comme TCP/IP n'a pas de couche session unifiée sur laquelle les couches plus élevées peuvent s'appuyer, ces fonctions sont généralement remplies par chaque application (ou ignorées). Une version simplifiée de la pile selon le modèle TCP/IP est présentée ci-après :

5

Application

« couche

7 »

ex. HTTP, FTP, DNS

(les protocoles de routage comme RIP, qui fonctionnent au-dessus d'UDP,

peuvent aussi être considérés comme faisant partie de la couche application)

4 Transport

ex. TCP, UDP, RTP, SCTP

(les protocoles de routage comme OSPF, qui fonctionnent au-dessus d'IP,

peuvent aussi être considérés comme faisant partie de la couche transport)

3 Réseau

Pour TCP/IP il s'agit de IP,

(les protocoles requis comme ICMP et IGMP fonctionnent au-dessus d'IP,

mais peuvent quand même être considérés comme faisant partie de la

couche réseau ; ARP ne fonctionne pas au-dessus d'IP),

2 Liaison ex. Ethernet, Token Ring, etc.

1 Physique

ex. la boucle locale (transmission par modulation sur lignes analogiques :

lignes téléphoniques RTC, numériques,ADSL …), les grandes artères de

communication (transmission par multiplexage, commutation, …), les réseaux

de radiocommunication (radio, téléphonie sans fil, satellite, …)

Une autre approche du modèle TCP/IP consiste à mettre en avant un modèle en 2 couches. En effet, IP fait abstraction du réseau physique. Et ce n'est pas une couche application qui s'appuie sur une couche transport (représentée par TCP ou UDP) mais des applications. On aurait donc :

Applications

2 TRANSPORT

1 IP (Internet)

Physique

http://fr.wikipedia.org/wiki/Hypertext_Transfer_Protocol

http://fr.wikipedia.org/wiki/File_transfer_protocol

http://fr.wikipedia.org/wiki/Domain_Name_System

http://fr.wikipedia.org/wiki/Routing_information_protocol

http://fr.wikipedia.org/wiki/Transmission_Control_Protocol

http://fr.wikipedia.org/wiki/User_datagram_protocol

http://fr.wikipedia.org/wiki/Real-time_transport_protocol

http://fr.wikipedia.org/wiki/Stream_Control_Transmission_Protocol

http://fr.wikipedia.org/wiki/Open_shortest_path_first

http://fr.wikipedia.org/wiki/Internet_Protocol

http://fr.wikipedia.org/wiki/Internet_control_message_protocol

http://fr.wikipedia.org/wiki/Internet_group_management_protocol

http://fr.wikipedia.org/wiki/Address_resolution_protocol

http://fr.wikipedia.org/wiki/Ethernet

http://fr.wikipedia.org/wiki/Token_Ring

http://fr.wikipedia.org/wiki/R%C3%A9seau_t%C3%A9l%C3%A9phonique_commut%C3%A9

http://fr.wikipedia.org/wiki/Asymmetric_Digital_Subscriber_Line


Version 1.1 118

Cette représentation est plus fidèle aux concepts d'IP. Rappelons que ce « modèle » est antérieur au modèle OSI et tenter de les faire correspondre peut induire en erreur. En effet, TCP introduit une notion de session, or TCP est au niveau TRANSPORT sur un modèle calqué sur l'OSI. Cette antériorité au modèle OSI explique aussi certaines incohérences comme l'implémentation d'un protocole de routage au-dessus d'UDP (RIP est implémenté sur UDP, alors qu'OSPF, arrivé après le modèle OSI et cette volonté de vouloir découper les thématiques par couches, s'appuie directement

sur IP). DHCP est également implémenté sur UDP, niveau « applications » alors que c'est le rôle de la couche réseau de fournir une configuration de niveau 3. Couche physique La couche physique décrit les caractéristiques physiques de la communication, comme les conventions à propos de la nature du média utilisé pour les communications (les câbles, les liens par fibre optique ou par radio), et tous les détails associés comme les connecteurs, les types de codage ou de modulation, le niveau des signaux, les longueurs d'ondes, la synchronisation et les distances maximales. Couche de liaison de données La couche de liaison de données spécifie comment les paquets sont transportés sur la couche physique, et en particulier le tramage (i.e. les séquences de bits particulières qui marquent le début et la fin des paquets). Les en-têtes des trames Ethernet, par exemple, contiennent des champs qui indiquent à quelle(s) machine(s) du réseau un paquet est destiné. Exemples de protocoles de la couche de liaison de données : Ethernet, Wireless Ethernet, SLIP, Token Ring et ATM. PPP est un peu plus complexe, car il a été initialement spécifié pour fonctionner au-dessus d'un autre protocole de liaison de données Cette couche est parfois subdivisée en LLC et MAC.


Version 1.1 119

Couche réseau Dans sa définition d'origine, la couche de réseau résout le problème de l'acheminement de paquets à travers un seul réseau. Exemples de protocoles de ce type : X.25, et le Initial Connection Protocol d'ARPANET. Lorsque deux terminaux communiquent entre eux via ce protocole, aucun chemin pour le transfert des données n'est établi à l'avance : il est dit que le protocole est « non orienté connexion ». Par opposition, pour un système comme le réseau téléphonique

commuté, le chemin par lequel va passer la voix (ou les données) est établi au commencement de la connexion : le protocole est « orienté connexion ». Avec l'avènement de la notion d'interconnexion de réseaux, des fonctions additionnelles ont été ajoutées à cette couche, et plus spécialement l'acheminement de données depuis un réseau source vers un réseau destinataire. Ceci implique généralement le routage des paquets à travers un réseau de réseaux, connu sous le nom d'Internet. Dans la suite de protocoles Internet, IP assure l'acheminement des paquets depuis une source vers une destination, et supporte aussi d'autres protocoles, comme ICMP (utilisé pour transférer des messages de diagnostic liés aux transmissions IP) et IGMP (utilisé pour gérer les données multicast). ICMP et IGMP sont situés au-dessus d'IP, mais assurent des fonctions de la couche réseau, ce qui illustre l'incompatibilité entre les modèles Internet et OSI. La couche réseau IP peut transférer des données pour de nombreux protocoles de plus haut niveau. Ces protocoles sont identifiés par un numéro de protocole IP (IP Protocol Number) unique. ICMP et IGMP sont respectivement les protocoles 1 et 2. Couche transport Les protocoles de la couche de transport peuvent résoudre des problèmes comme la fiabilité des échanges (« est-ce que les données sont arrivées à destination ? ») et assurer que les données arrivent dans l'ordre correct. Dans la suite de protocoles TCP/IP, les protocoles de transport déterminent aussi à quelle application chaque paquet de données doit être délivré.


Version 1.1 120

Les protocoles de routage dynamique qui se situent réellement dans cette couche de la pile TCP/IP (puisqu'ils fonctionnent au-dessus d'IP) sont généralement considérés comme faisant partie de la couche réseau. Exemple : OSPF (protocole IP numéro 89). TCP (protocole IP numéro 6) est un protocole de transport « fiable », orienté connexion, qui fournit un flux d'octets fiable assurant l'arrivée des données sans altérations et dans l'ordre, avec retransmission en cas de perte, et élimination des données dupliquées. Il gère aussi les données « urgentes » qui doivent être traitées dans le désordre (même si techniquement, elles ne sont

pas émises hors bande). TCP essaie de délivrer toutes les données correctement et en séquence - c'est son but et son principal avantage sur UDP, même si ça peut être un désavantage pour des applications de transfert ou de routage de flux en temps-réel, avec des taux de perte élevées au niveau de la couche réseau. UDP (protocole IP numéro 17) est un protocole simple, sans connexion, « non fiable » - ce qui ne signifie pas qu'il est particulièrement peu fiable, mais qu'il ne vérifie pas que les paquets soient arrivés à destination, et ne garantit pas leur arrivée dans l'ordre. Si une application a besoin de ces garanties, elle doit les assurer elle-même, ou bien utiliser TCP. UDP est généralement utilisé par des applications de diffusion multimédia (audio et vidéo, etc.) pour lesquelles le temps requis par TCP pour gérer les retransmissions et l'ordonnancement des paquets n'est pas disponible, ou pour des applications basées sur des mécanismes simples de question/réponse comme les requêtes DNS, pour lesquelles le surcoût lié à l'établissement d'une connexion fiable serait disproportionné par rapport au besoin. Aussi bien TCP qu'UDP sont utilisés par de nombreuses applications. Les applications situées à une quelconque adresse réseau se distinguent par leur numéro de port TCP ou UDP. Par convention, des ports bien connus sont associés avec certaines applications spécifiques. RTP (Real Time Protocol) est un protocole fonctionnant avec UDP ou TCP, spécialisé dans le transport de données possédant des contraintes temps réel. Typiquement, il sert à transporter des vidéos pour que l'on puisse synchroniser la lecture des images et du son directement, sans les stocker préalablement. SCTP (Stream Control Transmission Protocol) a été défini en 2000


Version 1.1 121

dans la RFC 4960, et un texte d'introduction existe dans la RFC 3286. Il fournit des services similaires à TCP, assurant la fiabilité, la remise en ordre des séquences, et le contrôle de congestion. Alors que TCP est byte-oriented (orienté octets), SCTP gère des « frames » (courtes séquences). Une avancée majeure de SCTP est la possibilité de communications multi-cibles, où une des extrémités (ou les) de la connexion est constituée de plusieurs adresses IP. Couche application

C'est dans la couche application que se situent la plupart des programmes réseau. Ces programmes et les protocoles qu'ils utilisent incluent HTTP (World Wide Web), FTP (transfert de fichiers), SMTP (messagerie), SSH (connexion à distance sécurisée), DNS (recherche de correspondance entre noms et adresses IP) et beaucoup d'autres. Les applications fonctionnent généralement au-dessus de TCP ou d'UDP, et sont souvent associées à un port bien connu. Exemples : HTTP port TCP 80 ; SSH port TCP 22 ; DNS port UDP 53 (TCP 53 pour les transferts de zones et les requêtes supérieures à 512 octets) ; RIP port UDP 520 ; FTP port TCP 21 ; Ces ports ont été assignés par l'Internet Assigned Numbers Authority (IANA). Sous UNIX, on trouve un fichier texte servant à faire les correspondances port↔protocole : /etc/services. Sous Windows, il se situe dans %SystemRoot%\System32\drivers\etc. Il se nomme services, on peut le lire avec le Bloc-notes.

Auth, BOOTP, BOOTPS, DHCP, Echo, Finger, FTP, Gopher, HTTPS, IRC, IMAP, IMAPS, Kerberos, QOTD, Netbios, NNTP, NFS, POP, POPS, RTSP, NTP, SFTP, SMTP, SNMP, SSH, Telnet, TFTP, WAIS, Webster, Whois, XDMCP.

Table des Matières - Notes de coursnotesdecours.drivehq.com/courspdf/Cours...

Documents

Transcript of Table des Matières - Notes de coursnotesdecours.drivehq.com/courspdf/Cours...