Vous êtes sur la page 1sur 154

LES SYSTMES INFORMATIQUES

Vision cohrente et utilisation

Christian CARREZ
Professeur des Universits au CNAM

Avant-propos

Ce polycopi de cours est une mise jour du livre que j'ai publi en 1990, et qui maintenant n'est plus disponible. C'est le support de cours pour la partie systmes informatiques de la valeur d'architecture des machines et des systmes informatiques du cycle A informatique du CNAM. Pour raliser des programmes, il est vident qu'il faut matriser les concepts de base de la programmation. Mais ce n'est pas suffisant. En particulier, il faut aussi comprendre l'ensemble des mcanismes et outils ncessaires leur mise en uvre en machine. C'est le but recherch par ce cours. En ce sens, il s'adresse en priorit ceux qui seront des informaticiens professionnels. Cependant, comme on ne peut faire de bonne programmation sans cette comprhension, il permettra toute personne ayant abord la programmation de parfaire ses connaissances dans les concepts de base de l'informatique. Nous allons tout d'abord prsenter, dans ce polycopi, les principaux outils qui sont utiles la construction des programmes eux-mmes. Nous verrons ensuite les relations entre les programmes et les objets externes, c'est--dire essentiellement les fichiers. Enfin, nous aborderons quelques unes des fonctionnalits des systmes d'exploitation qui permettent d'adapter la machine aux vritables besoins des utilisateurs. Notre but essentiel est de faire comprendre l'importance des mcanismes mis en jeu, et leurs consquences sur l'excution des applications, quels que soient les langages utiliss pour les crire. Nous prendrons le point de vue d'utilisateur d'un systme d'exploitation et non celui du concepteur. Nous n'hsiterons pas cependant, donner par endroit une description interne des mcanismes, l o il nous semble que cette description permet de mieux les comprendre. Ce polycopi est construit sur quatre parties d'importances ingales: introduction, chane de production de programmes, environnement externe, et environnement physique. Il est complt par un deuxime polycopi qui contient un ensemble de problmes et solutions. Dans la premire partie, nous commenons par rappeler rapidement l'volution historique de l'utilisation des ordinateurs, ce qui permet de mettre en avant les diffrents concepts ou mcanismes, au fur et mesure de leur apparition. Nous dcrivons ensuite brivement l'architecture du matriel, pour montrer les difficults de l'utilisation du matriel nu, et justifier ainsi le rle du systme d'exploitation. Nous prsentons alors les diffrents types de systmes d'exploitation, leurs modes d'utilisation, les critres de choix, et ce qui caractrise un systme gnral ou spcialis. Cette introduction permet de prsenter les services offerts par le systme, et se termine par la description de l'architecture d'un systme informatique. La deuxime partie prsente la chane de production des programmes, qui peut apparatre au programmeur sous forme d'une bote outils, ou sous la forme d'un systme intgr. Dans tous les cas, elle comporte trois aspects: la traduction, l'dition de liens et des outils complmentaires. Nous prsentons brivement les constituants essentiels de la traduction: l'analyse lexicale, l'analyse syntaxique, l'analyse smantique, la gnration et l'optimisation de code et terminons par la description de la traduction croise. L'dition de liens est dcrite plus en dtail, en introduisant d'abord la notion de module translatable et la notion de lien, en montrant l'expression de la nature du lien dans le module source ainsi que la reprsentation des liens dans le module objet. L'tude du fonctionnement de l'diteur de liens montre ensuite comment se passe l'dition simple d'une liste de module, la construction de la table des liens et l'utilisation de la notion de bibliothque pour ajouter des modules de bibliothques la liste. Nous montrons alors que la liaison avec le systme doit tre trait diffremment, par des instructions spciales. Cet aspect se termine avec la notion de recouvrement, les rfrences croises et le chargement.
-I-

Avant-propos La prsentation des autres outils de la chane de production permet d'voquer les outils d'aide la mise au point, avec, en particulier, la notion de trace, de point d'arrt, de reprise et de pas pas, conduisant aux metteurs au point symboliques multi-fentres. Elle se poursuit avec les prprocesseurs et les macrognrateurs. Elle se termine avec le make, outil de dfinition et d'exploitation du graphe de dpendance entre des fichiers. L'ide est de montrer qu'il vaut mieux faire un outil pour raliser une activit automatisable plutt que de la faire la main. La troisime partie aborde la description des objets externes vus de l'utilisateur. Nous introduisons tout d'abord la notion de fichier logique comme notion abstraite qui permet la manipulation des objets externes par le programme (les fichiers physiques). Suivant le cas, les objets externes ont pour but d'changer des informations, ou de les mmoriser long terme. Ceci peut conduire diffrentes formes de fichiers. Concrtement, l'implantation des objets externes sur disque peut se prsenter soit sous forme d'une suite squentielle de blocs avec ventuellement des extensions, soit sous forme d'un ensemble de blocs de taille fixe. La reprsentation de l'espace libre conduit la notion de quantum, et peut utiliser une table de bits ou une liste des zones libres. l'excution, il faut relier le fichier logique un objet externe, et pour cela il faut disposer d'un mcanisme de dsignation. Ceci conduit introduire la notion de volume, en tant que dsignation du support, et la notion de rpertoire, pour dsigner l'objet sur le support. L'intrt de l'uniformisation de la dsignation par une arborescence unique est mise en vidence, ainsi que l'utilisation de l'environnement pour abrger cette dsignation. La description des objets externes ne serait pas complte sans une introduction de la protection et de la scurit. La protection, qui a pour but de dfinir des rgles d'utilisation des oprations sur les objets, est obtenue soit par des droits d'accs soit par des mots de passe. La scurit, qui a pour but de garantir que les oprations s'excutent conformment leurs spcifications mme en cas de dfaillances, est obtenue par redondance interne ou externe. Enfin, nous terminons cette partie par une prsentation rapide de quelques systmes de gestion de fichiers courants. Dans la quatrime partie, nous abordons l'interface du programme avec le systme d'exploitation. La notion de processus est dcrite, ainsi que la hirarchie de processus. Cette notion est indissociable de la notion de ressources, et permet d'introduire les diffrents tats d'un processus. Nous abordons ensuite les mcanismes habituels de synchronisation des processus que sont les verrous et les smaphores, et montrons que le contrle du respect d'une rgle du jeu conduit souvent proposer aux programmeurs d'application des mcanismes particuliers plus labors. Nous montrons alors les consquences du blocage des processus en attente de ressources sur les temps de rponse, et introduisons la notion d'interblocage et le problme de la famine. Nous prsentons ensuite le partage de la mmoire centrale, en introduisant la notion de multiprogrammation. Nous montrons les limites du partitionnement de la mmoire. La notion de segmentation fournit au programmeur un espace mmoire deux dimensions lui facilitant la gestion de son propre espace, lorsque cette segmentation est prise en compte par le matriel. La notion de pagination est complmentaire de la notion de segmentation, et permet l'implantation de la notion de mmoire virtuelle. Les principaux algorithmes de pagination la demande sont alors prsents. Le rle du langage de commandes est dcrit en conclusion: quelles sont les fonctionnalits et comment s'excute une commande permettent d'assimiler l'interprteur de commande un programme comme un autre. C'est en fait un des constituants de la chane de production de programmes, mais qui permet entr'autre la manipulation des objets externes et des processus, ce qui justifie de ne l'aborder qu' la fin. Les chapitres des quatre premires parties comportent presque tous un paragraphe conclusion qui tente de rsumer ce qui nous parat essentiel dans ce chapitre. Christian Carrez

- II -

Table des matires

Premire Partie: Introduction........................................................................................ 1 1 volution historique de l'utilisation des ordinateurs.................................................. 3


1.1. Les systmes purement squentiels (1950-1960)..................................................................... 3 1.1.1. Les programmes autonomes (1950) .................................................................................. 3 1.1.2. Le moniteur d'enchanement des travaux (1955) .............................................................. 4 1.1.3. L'ordinateur spcialis d'entres-sorties (1960) ................................................................ 5 1.2. L'introduction du paralllisme (1960-1965)............................................................................. 6 1.2.1. Les entres-sorties tamponnes (1960) ............................................................................. 6 1.2.2. La multiprogrammation (1965) ......................................................................................... 7 1.2.3. Le contrle de procds (1965) ......................................................................................... 8 1.3. L'amlioration de l'interface homme-machine (1965-1980) .................................................... 9 1.3.1. Le temps partag (1965).................................................................................................... 9 1.3.2. Le transactionnel (1970).................................................................................................. 10 1.3.3. Les stations de travail (1980) .......................................................................................... 10 1.4. Conclusion.............................................................................................................................. 11

2 Rappels d'architecture matrielle............................................................................ 13


2.1. Architecture gnrale ............................................................................................................. 13 2.2. Architecture du processeur..................................................................................................... 14 2.3. Les entres-sorties .................................................................................................................. 15 2.3.1. Les entres-sorties programmes .................................................................................... 15 2.3.2. Les entres-sorties par accs direct la mmoire ........................................................... 16 2.3.3. Les entres-sorties par processeur spcialis .................................................................. 17 2.4. Les interruptions..................................................................................................................... 17 2.5. Notion dappel systme .......................................................................................................... 19 2.5.1. Mode matre-esclave ....................................................................................................... 19 2.5.2. Droutement .................................................................................................................... 19 2.6. Les caractristiques des principaux priphriques ................................................................. 19 2.6.1. Les priphriques de dialogue homme-machine ............................................................. 20
2.6.1.1. Les crans claviers distants .................................................................................................................... 20 2.6.1.2. Les crans graphiques ............................................................................................................................ 20 2.6.1.3. Les imprimantes..................................................................................................................................... 20

2.6.2. Les priphriques de stockage squentiel ....................................................................... 21 2.6.3. Les priphriques de stockage alatoire.......................................................................... 22 2.6.4. Les priphriques de communications entre machines ................................................... 22 2.6.5. Les priphriques et le systme....................................................................................... 23 2.7. Conclusion.............................................................................................................................. 23

3 Gnralits sur les systmes d'exploitation.............................................................. 25


3.1. Les diffrents types de systmes d'exploitation ..................................................................... 25
- III -

Table des matires 3.1.1. Les modes d'utilisation .................................................................................................... 25 3.1.2. Les critres de choix........................................................................................................ 26 3.1.3. Systme gnral ou spcialis ......................................................................................... 27 3.2. Les services offerts par le systme ......................................................................................... 28 3.2.1. La chane de production de programmes ........................................................................ 28 3.2.2. Le programme et les objets externes ............................................................................... 29 3.2.3. Le programme et son environnement physique .............................................................. 29 3.3. Architecture d'un systme ...................................................................................................... 29 3.4. Conclusion.............................................................................................................................. 30

Deuxime Partie: Chane de production de programmes ........................................... 31 4 La traduction des langages de programmation ........................................................ 33
4.1. L'analyse lexicale ................................................................................................................... 34 4.2. L'analyse syntaxique .............................................................................................................. 35 4.3. L'analyse smantique.............................................................................................................. 36 4.4. La gnration et l'optimisation de code.................................................................................. 37 4.5. La traduction croise .............................................................................................................. 38 4.6 Conclusion............................................................................................................................... 39

5 L'dition de liens et le chargement .......................................................................... 41


5.1. La notion de module translatable ........................................................................................... 41 5.2. La notion de lien..................................................................................................................... 42 5.2.1. Expression de la nature du lien dans le module source................................................... 43 5.2.2. Reprsentation des liens dans le module objet................................................................ 44 5.3. Fonctionnement de l'diteur de liens...................................................................................... 45 5.3.1. dition simple de la liste L .............................................................................................. 45 5.3.2. Construction de la table des liens .................................................................................... 46 5.3.3. Notion de bibliothque .................................................................................................... 47 5.3.4. Adjonction de modules de bibliothques ........................................................................ 48 5.3.5. Edition de liens dynamique ............................................................................................. 50 5.4. Notion de recouvrement ......................................................................................................... 50 5.5. Les rfrences croises........................................................................................................... 51 5.6. Le chargement ........................................................................................................................ 52 5.7. Conclusion.............................................................................................................................. 52

6 Autres outils de la chane de production.................................................................. 55


6.1. Les outils d'aide la mise au point......................................................................................... 55 6.1.1. La notion de trace ............................................................................................................ 55 6.1.2. La notion de point d'arrt, de reprise et de pas pas....................................................... 56 6.1.3. Les metteurs au point symboliques ................................................................................. 56 6.1.4. Les metteurs au point symboliques multi-fentres.......................................................... 57 6.1.5. Les mesures de comportement dynamique ..................................................................... 58 6.2. Les prprocesseurs et les macrognrateurs........................................................................... 58 6.3. Le make .................................................................................................................................. 59 6.3.1. Graphe de dpendance..................................................................................................... 60 6.3.2. Exploitation du graphe de dpendance............................................................................ 60
- IV -

Table des matires 6.3.3. Macro substitution........................................................................................................... 61 6.4. Les outils complmentaires .................................................................................................... 62 6.5. Conclusion.............................................................................................................................. 62

Troisime Partie: Environnement externe .................................................................. 61 7 La notion de fichier.................................................................................................. 67


7.1. Le but des objets externes ...................................................................................................... 67 7.1.1. Les objets externes comme outils d'change d'informations........................................... 67 7.1.2. Les objets externes comme outils de mmorisation long terme................................... 68 7.2. La manipulation des objets externes par le programme ......................................................... 69 7.2.1. La notion de fichier ......................................................................................................... 69 7.2.2. Le fichier squentiel ........................................................................................................ 69 7.2.3. Le fichier squentiel de texte........................................................................................... 70 7.2.4. Le fichier accs alatoire .............................................................................................. 70 7.3. La liaison entre le fichier et l'objet externe ............................................................................ 71 7.3.1. L'tablissement de la liaison............................................................................................ 71 7.3.2. Reprsentation interne d'un fichier.................................................................................. 71 7.4. Conclusion.............................................................................................................................. 72

8 Implantation des objets externes sur disque ............................................................ 73


8.1. La linarisation de l'espace disque ......................................................................................... 73 8.2. Allocation par zone ................................................................................................................ 74 8.2.1. Implantation squentielle simple..................................................................................... 74 8.2.2. Implantation squentielle avec extensions fixes ............................................................. 75 8.2.3. Implantation squentielle avec extensions quelconque................................................... 76 8.3. Allocation par blocs de taille fixe........................................................................................... 77 8.3.1. Implantation par blocs chans ........................................................................................ 77 8.3.2. Implantation par blocs plusieurs niveaux ..................................................................... 78 8.4. Reprsentation de l'espace libre ............................................................................................. 79 8.4.1. Notion de quantum .......................................................................................................... 79 8.4.2. Reprsentation par table de bits....................................................................................... 80 8.4.3. Reprsentation par liste des zones libres......................................................................... 81 8.5. Conclusion.............................................................................................................................. 81

9 La dsignation des objets externes .......................................................................... 83


9.1. La dfinition d'une liaison ...................................................................................................... 83 9.2. La notion de volume............................................................................................................... 84 9.2.1. La structuration d'un volume........................................................................................... 84 9.2.2. Le montage de volume .................................................................................................... 85 9.2.3. La relation entre volume et support................................................................................. 86 9.3. La notion de rpertoire ........................................................................................................... 86 9.3.1. Le rpertoire sur bande magntique ................................................................................ 86 9.3.2. Rpertoire simple sur disque ........................................................................................... 87 9.3.3. Arborescence de rpertoires ............................................................................................ 87 9.4. Construction d'une arborescence unique la Unix ................................................................ 88 9.4.1. Les fichiers spciaux comme priphriques.................................................................... 89 9.4.2. Le montage de volume dans Unix................................................................................... 89 9.4.3. Les fichiers multi-rpertoires .......................................................................................... 90 9.4.4. La dsignation par rapport l'environnement ................................................................. 91
-V-

Table des matires 9.5. Conclusion.............................................................................................................................. 92

10 La scurit et la protection des objets externes ..................................................... 93


10.1. Les mcanismes de protection.............................................................................................. 93 10.1.1. La protection par droits d'accs..................................................................................... 93 10.1.2. La protection par mot de passe...................................................................................... 94 10.2. Les mcanismes de scurit ................................................................................................. 95 10.2.1. La scurit par redondance interne................................................................................ 95 10.2.2. La scurit par sauvegarde priodique .......................................................................... 95 10.2.3. Les disques tolrance de panne .................................................................................. 97 10.3. Conclusion............................................................................................................................ 98

11 Quelques exemples de SGF ................................................................................... 99


11.1. Les systmes FAT et VFAT................................................................................................. 99 11.1.1. Reprsentation de l'espace............................................................................................. 99 11.1.2. Les rpertoires ............................................................................................................... 99 11.2. Les systmes HFS et HFS Plus de MacOS ........................................................................ 100 11.2.1. La reprsentation de l'espace....................................................................................... 100 11.2.2. Les rpertoires ............................................................................................................. 101 11.2.3. Cohrence du SGF....................................................................................................... 102 11.2.4. Le systme HFS Plus................................................................................................... 102 11.3. Le systme NTFS ............................................................................................................... 103 11.3.1. Les descripteurs de fichiers ......................................................................................... 103 11.3.2. Les Rpertoires............................................................................................................ 104 11.3.3. Compression de donnes ............................................................................................. 104 11.3.4. Scurit par fichier journal .......................................................................................... 105 11.4. Le systme ext2fs de Linux................................................................................................ 105 11.4.1. La reprsentation de l'espace....................................................................................... 106 11.4.2. Les rpertoires ............................................................................................................. 106 11.4.3. Scurit........................................................................................................................ 107 11.5. Structuration en couche du systme ................................................................................... 107

Quatrime Partie: Environnement physique............................................................. 105 12 La gestion des processus...................................................................................... 111


12.1. La notion de processus ....................................................................................................... 111 12.2. La hirarchie de processus ................................................................................................. 112 12.2.1. Un nombre fixe de processus banaliss....................................................................... 113 12.2.2. La cration dynamique de processus........................................................................... 113 12.2.3. L'exemple de Unix ...................................................................................................... 113 12.3. La notion de ressources ...................................................................................................... 114 12.4. Les tats d'un processus...................................................................................................... 115 12.5. Conclusion.......................................................................................................................... 116

13 Synchronisation et communication entre processus ............................................ 119


13.1. Les mcanismes de synchronisation................................................................................... 119 13.1.1. Les verrous .................................................................................................................. 120 13.1.2. Les smaphores ........................................................................................................... 120 13.1.3. Les mcanismes plus labors..................................................................................... 121 13.2. La communication entre processus .................................................................................... 122
- VI -

Table des matires 13.2.1. Le schma producteur-consommateur......................................................................... 122 13.2.2. Les tubes Unix............................................................................................................. 123 13.2.3. La communication par bote aux lettres ...................................................................... 124 13.3. Les consquences sur les temps de rponse ....................................................................... 124 13.4. La notion d'interblocage ..................................................................................................... 125 13.5. La notion de famine............................................................................................................ 127 13.6. Conclusion.......................................................................................................................... 128

14 La gestion de la mmoire centrale ....................................................................... 129


14.1. La notion de multiprogrammation...................................................................................... 129 14.1.1. L'intrt de la multiprogrammation............................................................................. 129 14.1.2. Les consquences de la multiprogrammation ............................................................. 130 14.1.3. Les difficults du partitionnement............................................................................... 131 14.2. La notion de mmoire segmente....................................................................................... 132 14.3. Le mcanisme de pagination .............................................................................................. 133 14.3.1. La pagination un niveau ........................................................................................... 133 14.3.2. La pagination deux niveaux...................................................................................... 135 14.3.3. La segmentation vis vis de la pagination.................................................................. 136 14.3.4. Le principe de la pagination la demande .................................................................. 136 14.4. La notion d'espace de travail .............................................................................................. 138 14.5. Conclusion.......................................................................................................................... 138

15 Le langage de commandes................................................................................... 141


15.1. Le langage issu du traitement par lot.................................................................................. 141 15.2. Le langage interactif........................................................................................................... 142 15.2.1. Le message d'invite ..................................................................................................... 142 15.2.2. Un langage orient verbe............................................................................................. 142 15.2.3. La gestion de l'environnement..................................................................................... 142 15.2.4. Le traitement prliminaire de la commande................................................................ 143 15.2.5. L'excution de la commande ....................................................................................... 144 15.3. Les structures de contrle du langage de commandes ....................................................... 144 15.4. Le langage base de menus ou d'icnes ............................................................................ 145 15.5. Conclusion.......................................................................................................................... 145

Bibliographie ............................................................................................................ 147 Index ......................................................................................................................... 149

- VII -

PREMIERE PARTIE

INTRODUCTION

-1-

volution historique de l'utilisation des ordinateurs

A l'origine, les ordinateurs taient utiliss pour des besoins spcifiques, par une population rduite de personnes qui connaissaient tous les aspects de leur exploitation. Des raisons conomiques, d'adquation aux besoins, d'amlioration de performances, etc..., ont entran une volution de cette exploitation. Cette volution a conduit l'introduction de plusieurs concepts successifs. Un rappel historique permet la prsentation de ces concepts et leur justification.

1.1. Les systmes purement squentiels (1950-1960)


1.1.1. Les programmes autonomes (1950)
Initialement, les priphriques des ordinateurs se rsumaient en un lecteur de cartes, un perforateur de cartes, et une imprimante. Le mode de fonctionnement tait assez simple, vu de l'utilisateur, puisque l'excution d'un programme consistait mettre dans le lecteur de cartes un paquet contenant la forme binaire du programme suivie des donnes. Aprs lecture du programme, l'ordinateur en lanait l'excution, les rsultats tant obtenus sous forme d'un paquet de cartes perfores, ou de lignes imprimes (figure 1.1).
perforateur de cartes ordinateur imprimante

lecteur de cartes

Fig. 1.1. Fonctionnement en programmes autonomes. La constitution de la forme binaire tait peut-tre un peu complique. Il est en effet apparu trs vite que l'criture de programmes devait tre aide de faon viter la conception directe en forme binaire. Les langages d'assemblage ou de haut niveau, FORTRAN par exemple, sont apparus trs tt. Le programmeur constituait une suite de cartes contenant le texte source de son programme, dont il obtenait une traduction sous forme binaire au moyen de l'excution successive de divers programmes standards (les passes du compilateur). Ainsi l'excution d'un programme FORTRAN, perfor sur un paquet de cartes ps, pouvait, par exemple, demander les tapes suivantes:
-3-

Introduction excution de la passe 1 du compilateur avec comme donnes ps, et fournissant un paquet de cartes pi, forme intermdiaire pour le compilateur, excution de la passe 2 du compilateur avec comme donnes pi, et fournissant un paquet de cartes pb, forme binaire du programme, excution de pb sur ses donnes. A la fin de l'excution de la passe 2, pi peut tre jet, car il ne sert plus rien. Le concept de base de ce mode de fonctionnement tait la notion d'amorage. La mise en route (ou la rinitialisation) de l'ordinateur lance l'excution d'un programme cabl de quelques instructions (l'amorce cable), qui met le matriel en position de lecture d'une carte, dont le contenu sera mmoris dans un emplacement fixe de la mmoire. Ds que cette carte est lue, le matriel excute l'instruction qui se trouve cet emplacement fixe. Le contenu de cette premire carte doit donc tre un court programme qui assure le chargement en mmoire des cartes qui suivent, et le lancement du programme correspondant. D'o le terme d'amorce logicielle ( bootstrap en anglais). Notons que ce concept est toujours utilis sur les ordinateurs d'aujourd'hui, lors de leur mise en route ou de leur rinitialisation; le seul changement intervenu est de pouvoir amorcer la machine depuis n'importe quel priphrique, et non plus partir de cartes perfores. Ce mode de fonctionnement correspondait assez bien la structure purement squentielle de l'ordinateur. Le matriel tait conu pour excuter les instructions du programme sans intervention extrieure possible, en dehors de la rinitialisation. Ainsi la lecture d'une carte commenait lorsque le programme faisait appel l'instruction correspondante, cette instruction se terminant lorsque la carte avait t lue sans erreur en mmoire. Ce mode de fonctionnement attire les remarques suivantes: Seul l'enchanement des instructions d'un programme est automatique. Le matriel est en gnral sous employ, du fait des manipulations humaines entre deux activits. L'utilisation sous forme de vacations (rservation pendant une certaine dure par un utilisateur unique), accentue le sous-emploi, et entrane la manipulation de paquets de cartes importants (les passes d'un compilateur) par de nombreuses personnes. Les programmes sont crits pour fonctionner sur une machine nue, puisque la totalit du logiciel est charg par l'amorce. On dit aussi que l'on a un fonctionnement en autonome ( stand alone en anglais). Notons que le mode d'utilisation des micro-ordinateurs individuels s'apparentent celui-ci, avec remplacement des cartes par les disquettes. La fonctionnalit a nanmoins t amliore, et les programmes ne fonctionnent plus tout fait sur une machine nue.

1.1.2. Le moniteur d'enchanement des travaux (1955)


L'mergence des supports magntiques (bandes initialement) a tout d'abord permis la conservation des programmes binaires importants sur ce support. Il a fallu alors dfinir des outils spcifiques de gestion de ces priphriques, pour permettre aux utilisateurs de retrouver facilement ces programmes. Simultanment, pour amliorer la rentabilit des machines, on a imagin l'introduction du moniteur d'enchanement des travaux, qui est un programme particulier activ automatiquement la fin de l'excution de chaque programme utilisateur, et dont le but est d'assurer alors la lecture en mmoire et le lancement du programme utilisateur suivant (figure 1.2).
traducteurs fichiers

lecteur de cartes

moniteur imprimante travaux -4-

Evolution historique Fig. 1.2. Moniteur d'enchanement des travaux. Dans ce contexte, l'utilisateur prpare un paquet de cartes reprsentant son travail ( job en anglais), et qui est constitu d'une ou plusieurs tapes (steps). Chaque tape correspond un programme dont l'excution est demande par l'utilisateur sur un jeu de donnes particulier. Ce programme peut tre un des utilitaires conservs sur bande, tel qu'un compilateur, ou le rsultat d'une tape prcdente mmoris temporairement sur bande. Le moniteur d'enchanement joue le rle du programme de l'amorce logicielle vu en 1.1.1, et assure le chargement et l'excution successifs de chacun des programmes dfinis par les tapes des travaux des diffrents utilisateurs. Pour cela trois concepts ont t introduits: Le langage de commande est interprt par le moniteur, et permet l'utilisateur de prciser en quoi consiste le travail. C'est donc le moyen de communication entre l'utilisateur et le moniteur d'enchanement des travaux. La protection des donnes et des instructions du moniteur est ncessaire pour viter qu'un programme utilisateur ne vienne les dtruire. Le superviseur d'entres-sorties est un ensemble de sous-programmes rsidents en machine, qui assurent le contrle des oprations d'entres-sorties des programmes des utilisateurs. Ce contrle est ncessaire pour garantir que chaque travail d'un utilisateur ne sera pas perturb par les actions intempestives des autres. Ce mode de fonctionnement attire les remarques suivantes: L'utilisateur n'a plus accs directement la machine, mais utilise les services d'un oprateur. Il y a enchanement automatique des programmes. Le dbit des travaux (throughput en anglais), c'est--dire le nombre de travaux par unit de temps, est amlior. Le temps de rponse, c'est--dire le dlai qui spare le moment o l'utilisateur donne son programme et celui o il obtient le rsultat, est augment. L'utilisateur ne peut plus agir sur son programme durant l'excution.

1.1.3. L'ordinateur spcialis d'entres-sorties (1960)


Les oprations d'entres-sorties relatives aux cartes et aux imprimantes sont, en gnral, longues par rapport aux performances des machines. Comme le moniteur d'enchanement impose que ces oprations soient excutes par le superviseur d'entres-sorties, au lieu de l'tre directement par le programme, celui-ci peut raliser diffremment ces oprations, pourvu que le rsultat soit le mme pour l'utilisateur. Aussi, pour amliorer la rentabilit de l'ordinateur de traitement, on a imagin de transfrer les cartes sur une bande, en utilisant un ordinateur spcifique et bon march, et de faire lire cette bande, la place des cartes, par le moniteur d'enchanement des travaux. De mme, les rsultats d'impression sont transfrs sur bande dans l'ordinateur principal, et la bande est ensuite lue par l'ordinateur spcifique pour tre imprime (figure 1.3).

-5-

Introduction

traducteurs fichiers lot de programmes moniteur ordinateur principal (travaux) lot de rsultats

opration manuelle bande magntique lecteur de cartes

opration manuelle bande magntique imprimante

ordinateur auxiliaire conversion de support

Fig. 1.3. Traitement par lot avec ordinateur spcialis d'entres-sorties. Ce mode de fonctionnement attire les remarques suivantes: Le dbit des travaux est amlior. Le temps de rponse est augment, car le transport des bandes n'est effectu que lorsqu'un nombre important de travaux y est mmoris. On parle de train de travaux.

1.2. L'introduction du paralllisme (1960-1965)


1.2.1. Les entres-sorties tamponnes (1960)
Il est apparu trs vite que la ralisation matrielle d'une opration d'entres-sorties par le processeur de calcul conduisait une mauvaise rentabilit de la machine. Les concepteurs du matriel ont donc introduit des processeurs spcialiss qui prenaient en charge ces oprations de faon autonome (voir le chapitre suivant). Il tait ainsi possible de poursuivre les traitements pendant l'excution de l'opration. Ceci a permis de connecter de nouveau les priphriques de type lecteur de cartes ou imprimante sur l'ordinateur principal, et de supprimer l'ordinateur secondaire. Le superviseur d'entres-sorties assure la lecture des cartes dans une zone ddie de mmoire centrale, avant que le programme n'en ait effectivement besoin, permettant ainsi de satisfaire immdiatement sa demande ultrieure. De mme, lorsque le programme demande une impression, celle-ci est remplace par une recopie dans une zone ddie de mmoire centrale, le superviseur assurant l'impression du contenu de cette zone ultrieurement. Ce mode de fonctionnement n'a t rendu possible que par l'introduction du mcanisme d'interruption, permettant un dispositif extrieur d'arrter momentanment le droulement normal d'un programme pour excuter un traitement spcifique. Nous reviendrons plus en dtail sur ce mcanisme dans le chapitre suivant. Par exemple, lorsque le lecteur de cartes a fini le transfert du contenu de la carte dans la mmoire centrale, il le signale au superviseur par le biais d'une interruption. Celui-ci peut alors commander la lecture de la carte suivante dans un autre emplacement mmoire. De mme, l'imprimante signale au superviseur, par une interruption, la fin de l'impression d'une ligne. Celui-ci peut alors commander l'impression de la ligne suivante si elle est disponible. Ce mode de fonctionnement attire les remarques suivantes: Le temps de rponse est amlior, puisqu'il n'est plus ncessaire de remplir une bande pour pouvoir la transfrer depuis (ou vers) l'ordinateur secondaire d'entres-sorties. La rentabilit du systme est amliore par la rcupration au niveau processeur de traitement des temps des oprations d'entres-sorties devenues autonomes.
-6-

Evolution historique La rservation de tampons d'entres-sorties en mmoire centrale est une solution coteuse (surtout l'poque o les tailles de mmoire centrale taient faibles par rapport celles que l'on trouve aujourd'hui!). L'volution naturelle est d'tendre ces zones sur disque (figure 1.4).

lecteur de cartes imprimante

moniteur d'enchanement conversion de support avant plan traitement par lot arrire plan travaux rsultats files d'attente

Fig. 1.4. Entres-sorties tamponnes.

1.2.2. La multiprogrammation (1965)


Les mthodes vues jusqu'alors, si elles amliorent la rentabilit des machines, atteignent cependant leurs limites. En effet, lorsqu'un programme s'excute, il n'est pas possible de supprimer compltement les temps des oprations d'entres-sorties. Le tamponnement, ainsi qu'il a t introduit ci-dessus, n'apporte qu'une solution partielle, du fait de la taille limite du tampon. Par ailleurs, il n'est gure envisageable pour les priphriques accs alatoire tels que les disques. Les temps d'unit centrale laisss disponibles par un programme pendant ses entres-sorties, peuvent tre rcuprs par d'autres programmes indpendants s'ils sont galement prsents en mmoire centrale ce moment. C'est ce que l'on appelle la multiprogrammation (figure 1.5).
avant plan lecteur de cartes imprimante conversion de support tltraitement moniteur de multiprogrammation T1 T2 T3 T4 travaux rsultats files d'attente

travaux en arrire plan

soumission distance

Fig. 1.5. Moniteur de multiprogrammation. Constatons tout d'abord que, pour mettre plusieurs programmes simultanment en mmoire, il faut avoir de la place. La multiprogrammation a pu tre dveloppe grce l'augmentation de la taille des mmoires centrales conjointement une diminution considrable de leur cot. La mise en uvre de la multiprogrammation ncessite le renforcement de certains mcanismes qui ont dj t prsents: La protection des donnes et des instructions du moniteur doit maintenant tre tendue aux donnes et instructions d'un programme par rapport aux autres, de faon permettre l'isolation de chacun des utilisateurs dans un univers partag. Le superviseur d'entres-sorties doit contrler l'accs aux ressources de la machine, et assurer la gestion de ces ressources (allocation, contrle, restitution).

-7-

Introduction Le mcanisme d'interruption est au centre de l'allocation du processeur. Signalant la fin d'une opration d'entres-sorties, l'interruption a en gnral pour effet de permettre au programme demandeur de poursuivre son excution (figure 1.6). La notion de systme d'exploitation apparat avec la ncessit de grer l'ensemble du matriel et du logiciel mis la disposition d'utilisateurs simultans.
systme d'exploitation demande E/S travail n 1 travail n 2 travail n 3 entre-sortie n 1 entre-sortie n 2 a demande E/S b c

interruption fin E/S

En a, le systme d'exploitation prend le contrle pour lancer l'entre-sortie demande par le travail n 1, et donner l'unit centrale au travail n 2. Il en va de mme en b pour l'entre-sortie demande par le travail n 2. Lors de la fin de l'entre-sortie n 1, une interruption donne le contrle au systme d'exploitation qui peut en consquence relancer le travail n 1 qui tait en attente.

Fig. 1.6. Fonctionnement simplifi de la multiprogrammation. Ce mode de fonctionnement attire les remarques suivantes: L'amlioration de la rentabilit de la machine est obtenue en la partageant entre plusieurs programmes simultans, conduisant une meilleure utilisation de l'ensemble des ressources. Il est possible de s'abstraire de la squentialit originelle des travaux. Le systme assure le transfert sur disque des programmes ds qu'ils sont disponibles. Lorsqu'il y a de la place libre en mmoire, il choisit l'un des travaux sur disque en fonction de paramtres varis, et non plus dans l'ordre d'arrive. Il est ainsi possible de diminuer le temps de rponse pour les travaux courts. Il est possible de dporter les organes d'entres-sorties du type cartes et imprimantes, en les reliant l'ordinateur central par des lignes tlphoniques spcialises. Les travaux qui sont entrs par ce moyen sont traits de la mme faon que les autres, les rsultats tant dlivrs par le systme sur l'imprimante dporte.

1.2.3. Le contrle de procds (1965)


Les ordinateurs peuvent aussi tre spcialiss pour le contrle de procds. Par analogie avec ce qui prcde, les interruptions vont permettre de dclencher des programmes spcifiques de lecture d'informations sur des capteurs, de mmorisation de ces valeurs, ou d'envoi de commandes l'extrieur. Lorsque aucune activit de ce type (travaux en avant plan ou foreground en anglais) n'est excuter, l'ordinateur peut tre utilis pour des travaux en arrire plan (background en anglais). Les travaux en avant plan correspondent aux activits du superviseur vues au paragraphe prcdent, alors que les travaux en arrire plan correspondent aux travaux des utilisateurs (figure 1.7).
procds industriels

donnes / commandes avant plan contrle temps rel

interruptions prioritaires

arrire plan temps diffr

Fig. 1.7. Contrle de procds industriels.

-8-

Evolution historique

1.3. L'amlioration de l'interface homme-machine (1965-1980)


1.3.1. Le temps partag (1965)
L'volution qui ressort des tapes ci-dessus conduit un loignement entre l'utilisateur et la machine. Il tait naturel que l'on cherche retrouver certaines fonctionnalits intressantes de l'utilisation en portes ouvertes, sans en avoir les inconvnients. Constatant qu'un utilisateur est satisfait s'il passe beaucoup plus de temps rflchir au travail qu'il va demander qu' attendre le rsultat de ce travail, ce temps de rflexion peut tre mis profit par l'ordinateur pour rpondre aux besoins des autres utilisateurs. L'ensemble des ressources de la machine est partag entre un ensemble d'utilisateurs, chacun d'eux ayant l'impression qu'il a la machine pour lui tout seul (figure 1.8). La conception d'un systme en temps partag a ncessit l'introduction de l'horloge temps rel, en plus des mcanismes dj vus.
moniteur temps partag allocation de ressources programmes utilisateurs gestion des terminaux sauvegarde temporaire

Fig. 1.8. Systme en temps partag. L'horloge temps rel est un dispositif matriel externe qui provoque des interruptions des instants rguliers. Ces interruptions sont au centre de l'allocation du processeur, et permettent de rpartir quitablement le temps du processeur entre les diffrents programmes utilisateurs. Le mcanisme des interruptions et la notion de superviseur permet la gestion d'un ensemble de terminaux. La multiprogrammation permet d'optimiser l'utilisation de l'unit centrale pendant les oprations d'entres-sorties des programmes des utilisateurs. En ralit, c'est un peu plus complexe, dans la mesure o il n'est pas raisonnable de laisser un programme d'un utilisateur en mmoire pendant que cet utilisateur rflchit, car ce temps de rflexion est souvent de l'ordre de 30 secondes. En gnral il est prfrable de mmoriser ce programme sur disque pendant ce temps, et de le rappeler en mmoire lorsque ncessaire. Ceci a t rendu possible par des techniques de va-et-vient (swapping en anglais) ou de mmoire virtuelle. Par ailleurs le grand nombre d'utilisateurs ayant des activits voisines implique qu'un mme programme peut tre en cours d'excution pour plusieurs utilisateurs la fois (un compilateur par exemple). Ceci a conduit la conception de programmes rentrants: un seul exemplaire du programme capable de traiter en mme temps plusieurs jeux de donnes.

1.3.2. Le transactionnel (1970)


Le temps partag s'adresse plutt l'utilisateur qui dsire concevoir, mettre au point et utiliser des programmes. Le dveloppement des terminaux a conduit s'intresser aux utilisateurs qui dsirent exploiter des applications spcifiques orientes vers la saisie et la consultation d'informations conserves dans des fichiers. Il ne s'agit plus alors de mettre leur disposition une machine, mais de leur permettre d'effectuer sur des donnes, qu'ils ont mises en commun, des oprations
-9-

Introduction prprogrammes qui demandent un temps d'unit centrale assez bref. Ceci conduit grer l'ordinateur et les terminaux de faon spcifique pour amliorer les temps de rponses vus de l'utilisateur. Par rapport aux concepts voqus jusqu'alors, le partage d'informations est ici fondamental, alors qu'il tait secondaire dans les modes prcdents. Ce partage peut couvrir les donnes proprement dites, mais aussi les instructions qui dcrivent les oprations. Pour grer ce partage et garder la cohrence de ces donnes partages, on introduit la notion de transaction. De plus la conservation des donnes, quoi qu'il arrive, est aussi exige par les utilisateurs. Il faut donc mettre en uvre des mcanismes de sauvegarde appropris.

1.3.3. Les stations de travail (1980)


L'abaissement des cots des matriels a permis la conception d'ordinateurs individuels dont les performances avoisinnent celles des ordinateurs de moyenne puissance des annes 1970-1980. Ceci n'a pas eu pour consquence la remise en cause des concepts de base des systmes d'exploitation. L'utilisateur, habitu une fonctionnalit fournie sur les gros systmes, dsire retrouver cette fonctionnalit agrmente d'une meilleure convivialit sur sa machine personnelle. D'un point de vue gnral, le poste de travail a d'abord t conu de faon autonome, utilis par une seule personne. En ce sens, le systme lui-mme avait des fonctionnalits simplifies proches de celles des premiers systmes. L'exemple type est MSDOS. Les performances de mmoires centrales ont ensuite permis de dfinir directement par logiciel et point par point, le contenu de l'image qui est affiche l'cran 25 fois par secondes. Les fonctionnalits du systme se sont alors naturellement tendues vers les aspects graphiques et l'interactivit au moyen de la souris, avec l'apparition des premiers MacIntosh au dbut des annes 1980. Ceux-ci taient dj organiss en un petit rseau local permettant le partage de fichiers et d'imprimantes entre les utilisateurs. Par la suite, les recherches poursuivies au MIT ont conduit la sortie d'un produit X-Window, la fin des annes 1980, qui permettait la sparation entre le programme de gestion de l'cran graphique situ sur une machine et celui de l'application elle-mme de l'utilisateur situ sur une autre machine, la coopration entre les deux programmes passant par le rseau, selon un mode client-serveur. On appelle ainsi le mode de fonctionnement o lun des programmes, appel client, ici lapplication, demande un traitement spcifique (service) lautre, appel le serveur, ici la gestion de lcran. La gnralisation des postes de travail en rseau et linterconnexion des rseaux ont conduit au world wide web ou toile mondiale, o un programme, appel navigateur, install sur le poste de travail de lutilisateur, permet celui-ci dobtenir, depuis des serveurs situs nimporte o, des informations qui sont mises en page par le navigateur. Deux aspects importants dcoulent de ces utilisations: L'interface homme-machine doit permettre une grande facilit d'utilisation par un nonspcialiste. La puissance de calcul locale permet de satisfaire les besoins d'affichage. La communication entre ordinateurs distants est une ncessit, pour assurer le partage d'un ensemble de ressources matrielles et logicielles entre les diffrentes stations de travail. Elle conduit la conception de systmes rpartis, construits autour de rseaux locaux.

1.4. Conclusion
L'amorce (bootstrap) est un petit programme qui est charg en mmoire en une seule opration d'entre lors de la mise en route de l'ordinateur, et dont l'excution permet le chargement et le lancement d'un programme plus important. Un programme autonome (stand alone) est un programme capable de s'excuter sur une machine nue. Un moniteur d'enchanement des travaux est un programme spcifique qui assure, la fin d'excution d'un programme utilisateur, le chargement et l'excution du suivant de faon automatique.

- 10 -

Evolution historique Le langage de commande permet l'utilisateur de dfinir la suite des programmes dont il veut voir l'excution. Le superviseur d'entres-sorties est un ensemble de sous-programmes qui assure le contrle et la bonne excution des entres-sorties pour le compte des programmes des utilisateurs. Le mcanisme d'interruption est le mcanisme qui permet un organe matriel externe d'interrompre le droulement normal du processeur pour lui demander d'excuter un travail spcifique et bref. La multiprogrammation consiste mettre plusieurs programmes en mmoire centrale au mme moment de faon pouvoir excuter l'un d'entre eux pendant que les autres sont en attente de la fin d'une entre-sortie. La protection mmoire est un dispositif matriel qui permet d'empcher un programme d'accder en mmoire des donnes qui ne lui appartiennent pas. Le temps partag consiste partager dans le temps les ressources de la machine entre les utilisateurs, de telle sorte que chacun d'eux ait l'impression d'avoir la machine pour lui seul. Le systme d'exploitation est le logiciel charg de grer l'ensemble du matriel et du logiciel la disposition des utilisateurs et qu'ils se partagent. Le dbit des travaux est le nombre moyen de travaux excuts par la machine en un temps donn. Le temps de rponse est le dlai qui spare le moment o l'utilisateur soumet sa commande et le moment o il obtient le rsultat.

- 11 -

Rappels d'architecture matrielle

Pour comprendre le rle et les fonctionnalits des systmes d'exploitation, il est ncessaire d'apprhender ce qu'est une machine nue, c'est--dire quels sont les constituants matriels d'un ordinateur, et quels en sont les principes de fonctionnement.

2.1. Architecture gnrale


En premire approche, un ordinateur est constitu d'un processeur qui effectue les traitements, d'une mmoire centrale o ce processeur range les donnes et les rsultats de ces traitements et de priphriques permettant l'change d'informations avec l'extrieur. Tous ces constituants sont relis entre eux par l'intermdiaire d'un bus, qui est l'artre centrale et leur permet de s'changer des donnes (figure 2.1.). Pratiquement tous les ordinateurs actuels ont cette architecture, que ce soient les micro-ordinateurs personnels ou les gros ordinateurs des entreprises. Les diffrences rsident essentiellement dans les performances des constituants.
processeur contrle donnes adresses BUS mmoire

contrleur bus

interface

accs direct mmoire

processeur entres sorties

contrleur priphrique priphrique priphrique priphrique priphrique priphriqu e

Fig. 2.1. Architecture gnrale d'un ordinateur. La mmoire est un organe passif, qui rpond des ordres indiqus par les fils de contrle du bus. En rponse un ordre d'criture, elle range la valeur reprsente par les fils de donnes du bus dans un emplacement dfini par les fils d'adresse du bus. En rponse un ordre de lecture, elle fournit sur
- 13 -

Introduction les fils de donnes du bus la valeur mmorise l'emplacement dfini par les fils d'adresses. Le nombre de fils de donnes du bus dfinit le nombre de bits des emplacements mmoire. C'est une caractristique importante pour les performances de l'ordinateur, puisqu'il dtermine le nombre de bits pouvant tre lus ou crits en mmoire par une seule opration. Le nombre de fils d'adresse du bus dfinit la taille maximale de la mmoire centrale. Le bus est gr par un contrleur, parfois intgr au processeur, qui empche son utilisation simultane par plusieurs organes.

2.2. Architecture du processeur


Le processeur est l'organe qui effectue les traitements suivant un algorithme dfini par le programmeur. Il est constitu essentiellement de trois parties (figure 2.2): L'unit arithmtique et logique (U. A. L.) est capable d'effectuer les oprations lmentaires habituelles sur des valeurs binaires, telles que l'addition, la soustraction, le ou logique, les dcalages, etc... Les registres permettent de mmoriser des rsultats intermdiaires ou des tats particuliers du processeur. Ils sont en gnral en petit nombre, mais d'accs trs rapide. Certains ont un rle particulier, comme l'accumulateur, le compteur ordinal ou le registre instruction. Le dcodeur-squenceur contrle l'excution des diffrentes phases des instructions. Le principe de fonctionnement est assez simple. Le dcodeur-squenceur rpte indfiniment la squence d'oprations suivante: lecture mmoire l'adresse indique par le compteur ordinal, et rangement du rsultat dans le registre instruction, dcodage de cette instruction pour en excuter les diffrentes phases.

donnes

instruction

accumulateur registres

dcodeur contrle squenceur

Unit arithmtique et logique

..

..

adresses

Fig. 2.2. Architecture gnrale d'un processeur. Les instructions sont en gnral assez rudimentaires. Ce sont essentiellement des oprations de transfert de donnes entre les registres et l'extrieur du processeur (mmoire ou priphrique), ou des oprations arithmtiques ou logiques avec un ou deux oprandes. Pour ces dernires oprations, un registre particulier, l'accumulateur, est souvent utilis implicitement comme l'un des oprandes et comme rsultat. En gnral le droulement de l'instruction entrane l'incrmentation du compteur ordinal, et donc l'excution de l'instruction qui suit. Notons que le transfert d'une valeur dans le compteur ordinal entrane un branchement l'adresse correspondant cette valeur. La tendance naturelle a t de construire des processeurs avec un jeu d'instructions de plus en plus large; on pensait alors que le programmeur utiliserait les instructions ainsi disponibles pour amliorer l'efficacit de ses programmes. Ceci a conduit ce que l'on a appel l'architecture CISC ( Complex Instruction Set Computer). Cependant on a constat que les programmes contenaient toujours les
- 14 -

Architecture matrielle mmes instructions, une partie importante du jeu d'instructions n'tant utilise que trs rarement. Une nouvelle famille de processeurs a alors t construite, l'architecture RISC ( Reduced Instruction Set Computer), qui offre un jeu rduit d'instructions simples mais trs rapides. La figure 2.3 donne un exemple de la reprsentation binaire d'une instruction en machine (cas 68000). Cette forme n'est pas trs agrable pour l'homme, mais c'est le vritable langage de la machine. La forme mnmonique qui l'accompagne est dj plus lisible, mais ncessite un programme (l'assembleur) pour pouvoir tre interprte par la machine.
0 0 1 1 0 0 1 0 0 0 0 1 0 0 1 0 MOVE.W D1,(A2) transfert dans le registre D1 de la valeur situe en mmoire, et dont l'adresse est dans le registre A2.

Fig. 2.3. Exemple d'instruction binaire et mnmonique.

2.3. Les entres-sorties


Le principe lmentaire mis en uvre pour l'change de donnes entre deux constituants physiques est reprsent en figure 2.4. En dehors des donnes proprement dites, deux liaisons supplmentaires sont ncessaires, pour permettre d'une part l'metteur de la donne de signaler la prsence effective de cette donne sur les fils correspondants, et d'autre part au rcepteur de signaler qu'il a lu la donne. On peut comparer ceci au ping-pong: celui qui a la balle a le droit d'accder aux fils de valeur pour lire ou crire la donne. Suivant la capacit de traitement que l'on place entre le processeur et le priphrique, c'est--dire suivant la complexit du dispositif qui va prendre en compte cet change lmentaire et le transformer en des changes sur le bus, on trouvera les dispositions voques dans la figure 2.1.
valeur donne lmentaire indicateur de donne prte indicateur de donne reue

Fig. 2.4. Protocole lmentaire d'entres-sorties.

2.3.1. Les entres-sorties programmes


La faon la plus simple d'assurer la liaison entre le bus et un priphrique, est de faire une simple adaptation des signaux voqus ci-dessus. On parle alors d'une interface. Le processeur adresse directement le priphrique soit par les instructions habituelles d'accs la mmoire centrale, l'interface jouant alors le rle d'un (ou de plusieurs) emplacement de mmoire, soit par des instructions spcialises qui assurent le transfert d'une donne lmentaire avec un registre ou un emplacement mmoire. Dans tous les cas, le programmeur doit assurer le protocole lmentaire d'changes voqu plus haut; c'est pourquoi on parle d'entres-sorties programmes.
tantque il_y_a_des_donnes__lire faire tantque donne_suivante_non_prte faire fait; { attente de la donne} lire_la_donne; traitement_de_la_donne; fait

Fig. 2.5. Exemple d'entre-sortie programme. La figure 2.5 donne le schma d'un tel programme de lecture. Noter la boucle d'attente de la donne qui teste l'indicateur de donne prte. Nous supposons ici que la lecture de la donne entrane le positionnement par l'interface de l'indicateur de donne lue et sa remise zro par le positionnement de l'indicateur de donne prte. Il est facile de constater qu'un tel change a une vitesse (on dit encore un dbit) limit par le nombre d'instructions machine qui constituent le corps de la boucle externe. Ce dbit est souvent limit en consquence 50 Ko/s (Kilo-octets par seconde). Par ailleurs si le priphrique est lent, le processeur est monopolis pendant toute la dure de l'change. Dans ce cas, on ne lit que quelques octets la fois pour viter cette monopolisation. Comme il a t mentionn dans le prcdent chapitre, cette forme d'change tait la seule possible dans les premires gnrations de machines.
- 15 -

Introduction

2.3.2. Les entres-sorties par accs direct la mmoire


Pour accrotre le dbit potentiel des entres-sorties, et diminuer la monopolisation du processeur dont nous avons parl ci-dessus, la premire solution a t de dporter un peu de fonctionnalit dans le dispositif qui relie le priphrique au bus, de faon lui permettre de ranger directement les donnes provenant du priphrique en mmoire dans le cas d'une lecture, ou d'extraire directement ces donnes de la mmoire dans le cas d'une criture. C'est ce que l'on appelle l'accs direct la mmoire, ou encore le vol de cycle. La figure 2.6 schmatise le mcanisme d'accs direct la mmoire. L'excution d'un transfert se droule de la faon suivante: Le processeur informe le dispositif d'accs direct la mmoire de l'adresse en mmoire o commence le tampon qui recevra les donnes s'il s'agit d'une lecture, ou qui contient les donnes s'il s'agit d'une criture. Il informe galement le dispositif du nombre d'octets transfrer. Le processeur informe le contrleur des paramtres de l'opration proprement dite. Pour chaque donne lmentaire change avec le contrleur, le dispositif demande au processeur le contrle du bus, effectue la lecture ou l'criture mmoire l'adresse contenue dans son registre et libre le bus. Il incrmente ensuite cette adresse et dcrmente le compteur. Lorsque le compteur atteint zro, le dispositif informe le processeur de la fin du transfert par une ligne d'interruption (voir plus loin).
mmoire centrale

demande processeur acquitement interruption demande adresse compteur donnes dispositif d'accs direct mmoire acquitement contrleur

Fig. 2.6. Mcanisme d'accs direct la mmoire. Pendant toute la dure du transfert, le processeur est libre d'effectuer un traitement quelconque. La seule contrainte est une limitation de ses propres accs mmoire pendant toute la dure de l'opration, puisqu'il doit parfois retarder certains de ses accs pour permettre au dispositif d'accs direct la mmoire d'effectuer les siens (d'o le terme de vol de cycle voqu plus haut). La limitation du dbit inhrent au mcanisme est en gnral li au dbit potentiel de la mmoire elle-mme, c'est--dire la dure d'un cycle de lecture ou d'criture en mmoire. Si cette dure est de 500 ns., on peut thoriquement atteindre 2 Mo/s. Si la mmoire est organise en mots de 4 octets, il est possible de lire ou d'crire 4 octets en un seul cycle, et de porter ainsi le dbit 8 Mo/s. Dans ce cas le dispositif d'accs direct la mmoire assure le regroupement ou l'clatement des donnes changes avec le priphrique de faon minimiser les accs mmoire.

2.3.3. Les entres-sorties par processeur spcialis


La troisime faon de relier un priphrique avec la mmoire est d'utiliser un processeur spcialis d'entres-sorties, c'est--dire de dlguer plus d'automatisme ce niveau. Dans le schma prcdent, le processeur principal avait en charge la prparation de tous les dispositifs, accs direct la mmoire, contrleur, priphrique, etc..., pour la ralisation de l'opration. L'utilisation d'un processeur spcialis a pour but de reporter dans ce processeur la prise en charge de cette
- 16 -

Architecture matrielle prparation, mais aussi des oprations plus complexes, telles que par exemple le contrle et la reprise d'erreurs. L'intrt est de faire excuter des tches de bas niveau par un processeur moins performant, et donc moins coteux raliser, tout en rservant le processeur principal des tches plus nobles.

2.4. Les interruptions


Nous avons dj introduit ce mcanisme dans le chapitre prcdent ainsi que dans le paragraphe cidessus. Ce mcanisme a t imagin pour permettre un dispositif extrieur d'interrompre le droulement normal du processeur pour lui faire excuter un traitement spcifique. Un programme en arrire plan peut ainsi tre interrompu pour permettre d'activer un travail en avant plan; il sera ensuite poursuivi la fin de ce dernier. Un priphrique peut signaler la fin de l'opration d'entressorties demande prcdemment, permettant ainsi au systme de temps partag de reprendre l'excution du programme qui avait demand cette opration. Le mcanisme est obtenu en modifiant lgrement le fonctionnement du dcodeur-squenceur du processeur, par introduction d'une troisime phase, et qui devient le suivant: lecture mmoire l'adresse indique par le compteur ordinal, et rangement du rsultat dans le registre instruction, dcodage de cette instruction pour en excuter les diffrentes phases, s'il y a une demande d'interruption, alors la prendre en compte. La prise en compte de l'interruption peut se faire de diffrentes faons. Puisqu'il s'agit d'interrompre le droulement normal des instructions, il suffit de modifier le compteur ordinal. Cependant comme on dsire reprendre ultrieurement le programme interrompu, il faut aussi sauvegarder la valeur de ce compteur. Dans la plupart des processeurs, ce n'est pas jug tout fait suffisant. En gnral, le constructeur dfinit un PSW (Program Status Word), ou mot d'tat du programme, contenant en particulier le compteur ordinal ainsi que certains indicateurs sur l'tat courant du processeur. La prise en compte d'une interruption par le processeur consiste alors ranger en mmoire ce PSW dans un emplacement dtermin ou repr par un registre particulier utilis comme un pointeur de pile1, et charger un nouveau PSW soit fixe, soit obtenu depuis la mmoire. Pour viter de ranger inutilement en mmoire des registres, ce qui serait coteux en temps, le processeur ne range que le minimum lors de la prise en compte de l'interruption. Si on dsire pouvoir reprendre ultrieurement le programme interrompu, les instructions qui constituent le traitement de l'interruption que nous appellerons sous-programme d'interruption, doit ranger en mmoire le contenu de l'ensemble des registres du processeur qui ne l'ont pas t par la prise en compte de l'interruption, pour permettre cette reprise ultrieure. C'est ce que l'on appelle la sauvegarde du contexte. Dans certains cas, on pourra ne faire qu'une sauvegarde partielle des seuls registres modifis par le sous-programme d'interruption. Lorsque le contexte est sauvegard, le sous-programme analyse la cause de l'interruption, et effectue le traitement appropri. Il peut ensuite restituer le contexte du programme interrompu (ou celui d'un autre programme lorsque l'interruption correspond la fin d'une opration d'entres-sorties pour celui-ci). Il se termine par une instruction spciale qui demande au processeur de restituer le PSW du programme interrompu, entranant sa reprise effective (figure 2.7).

Une pile est une structure de donnes permettant la conservation d'informations, de telle sorte que les informations sont enleves de la structure dans l'ordre inverse o elles y ont t mises. - 17 -

Introduction
droulement d'un programme sous programme d'interruptio n sauvegarde du contexte interruption externe recherche cause traitement de l'interruption prise en compte interruption restauration du contexte acquitement d'interruption restitution du PSW

Fig. 2.7. Droulement d'un sous-programme d'interruption. Le schma de fonctionnement du mcanisme d'interruption ainsi dcrit met en avant une difficult si une nouvelle interruption survient alors que le traitement de la prcdente n'est pas termine. Si on ne prend pas de prcaution, le sous-programme d'interruption est de nouveau appell avant sa fin, entranant la sauvegarde du contexte du sous-programme d'interruption et la perte du contexte du programme initialement interrompu2. Ce problme est rsolu par le biais du masquage des interruptions, qui interdit au processeur la prise en compte d'une interruption si elle est masque. Cela n'annulle pas la demande d'interruption proprement dite, qui n'est pas considre par le processeur. Lorsque, ultrieurement, une instruction sera excute par le processeur pour dmasquer cette interruption, celui-ci pourra alors la prendre en compte. Cela permet ainsi au logiciel (en gnral le systme d'exploitation) de contrler les moments o une telle prise en compte pourrait perturber son bon fonctionnement. En particulier, le masquage automatique des interruptions par le processeur lors de la prise en compte d'une interruption vite de le rexcuter une nouvelle fois avant qu'il ne soit termin, moins que le programmeur n'ait lui-mme demand le dmasquage des interruptions dans le sous-programme aprs avoir pris les prcautions ncessaires cette nouvelle interruption (sous-programme rentrant). Certains processeurs ont plusieurs fils d'interruption qui sont masquables individuellement. Ils correspondent alors des interruptions hirarchises, c'est--dire qu' chaque fil est attribu un numro appell niveau de priorit d'interruption, permettant au processeur de savoir laquelle il y a lieu de prendre en compte si plusieurs sont prsentes au mme moment. Ce dispositif est complt par un registre spcialis du processeur (qui fait partie du PSW) qui contient le niveau de priorit de l'interruption en cours de traitement. Le processeur ne prend en compte une interruption que si elle est non masque, et de priorit suprieure au niveau de priorit courant. Cela permet de satisfaire les demandes plus urgentes que celle que l'on est en train de traiter tout en vitant les problmes de rentrance voqus plus haut.

2.5. Notion dappel systme


2.5.1. Mode matre-esclave
Le chapitre prcdent a introduit la ncessit de contrler les actions dun programme vis vis de son environnement direct. En gnral, il est ncessaire dempcher le programme dun utilisateur de perturber le fonctionnement global du systme ou les programmes des autres utilisateurs. Cela implique quil nait pas accs lensemble des ressources de la machine, mais seulement celles qui lui ont t alloues en propre. La solution la plus couramment adopte est de distinguer deux modes de fonctionnement du processeur, le mode matre et le mode esclave. Dans le mode matre, le processeur a accs toutes les ressources de la machine. Dans le mode esclave, certaines instructions lui sont interdites. Pour cela, le fonctionnement du dcodeur-squenceur du processeur est lgrement modifi, par introduction d'une phase de contrle intermdiaire:

moins d'utiliser pour la sauvegarde des contextes successifs, mais se pose alors le problme de la taille de cette pile. - 18 -

Architecture matrielle lecture mmoire l'adresse indique par le compteur ordinal, et rangement du rsultat dans le registre instruction, si le processeur est en mode esclave, vrification que linstruction est autorise, dcodage de cette instruction pour en excuter les diffrentes phases, s'il y a une demande d'interruption, alors la prendre en compte. Lindicateur du mode de fonctionnement matre/esclave fait partie du mot dtat programme. De cette faon, ce mode est li au programme en cours dexcution. En particulier, la prise en compte dune interruption chargeant un mot dtat programme spcifique linterruption, le sous programme correspondant sexcutera dans le mode dfini par ce mot dtat et non par celui du programme interrompu. La reprise de ce dernier restaurera le mode qui lui est attach.

2.5.2. Droutement
Si le programme dun utilisateur fonctionne en mode esclave, sous un jeu dinstructions rduit, nanmoins, certaines actions ncessaires son bon fonctionnement ncessitent de disposer du jeu complet, et doivent donc tre excutes en mode matre. videmment le changement de mode doit tre contrl. En gnral, ceci se fait au moyen dune instruction spciale, qui va changer le mot dtat programme du processeur, selon un principe voisin de la prise en compte des interruptions, cest--dire, rangement du mot dtat courant et chargement du mot dtat li la fonction demande et restauration du mot dtat initial la fin de la fonction. Cest pourquoi, ce mcanisme prend parfois la dnomination dinterruption programme. On dit encore droutement ou appel superviseur. Un droutement est aussi trs voisin dun appel de sous programme : sauvegarde du compteur ordinal, dont la valeur est remplace par ladresse du sous programme, et restauration de la valeur sauvegarde la fin du sous programme. Il y a, cependant, deux diffrences essentielles : Le droutement modifiant le mot dtat programme permet un changement de mode, un masquage des interruptions, ou un changement du niveau de priorit courant du processeur. Ladresse du sous programme excut nest pas contenue dans linstruction de droutement ellemme, mais dans le mot dtat programme charg. Ceci oblige le passage par des points de contrles qui vrifieront les valeurs des paramtres de la fonction avant de lexcuter. De plus, le programme na pas connatre les adresses qui sont lintrieur du systme et aux quelles il na pas accs.

2.6. Les caractristiques des principaux priphriques


Les exemples suivants montrent la grande diversit des priphriques habituels.

2.6.1. Les priphriques de dialogue homme-machine


Trois types de priphriques principaux sont concerns par le dialogue entre lhomme et la machine.

2.6.1.1. Les crans claviers distants


Il s'agit de terminaux relativement simples, qui ont vocations tre installs loin de lordianteur. La liaison doit donc tre faible cot, et on utilise 2 ou 4 fils, sur lesquels les bits sont srialiss, c'est--dire que les 8 bits d'un octet sont transmis les uns aprs les autres, vitesse constante, suivant un protocole standard international (RS232) ils sont prcds par un bit de dpart (start), et suivis d'un ou deux bits de fin (stop). C'est ce que l'on appelle la ligne srie asynchrone. Elle est asynchrone, car chaque octet est transmis individuellement, le bit start permettant la synchronisation automatique du rcepteur sur l'metteur, pour la dure du transfert de l'octet correspondant. Vu de l'ordinateur, un cran-clavier est donc en fait une ligne srie. Les octets sont en gnral transmis un par un par des entres-sorties programmes. Le dbit en sortie est au plus de 1000 octets par seconde. Il ne sert rien d'aller plus vite, puisque l'homme ne peut dj plus lire le contenu de l'cran cette vitesse. Le dbit en entre est en gnral beaucoup plus lent puisqu'il est
- 19 -

Introduction limit par la frappe manuelle sur le clavier, et donc quelques octets par seconde. Pour viter que le processeur ne perde trop de temps lors de ces entres-sorties programmes, on utilise le mcanisme d'interruption pour chaque caractre transmis. Si l'ordinateur doit comporter beaucoup de lignes, il peut s'en suivre une charge de traitement importante due la prise en compte de ces interruptions. Dans ce cas, les constructeurs proposent souvent des processeurs d'entres-sorties spcialiss dans ce travail; on les appelle alors des frontaux.

2.6.1.2. Les crans graphiques


Les crans graphiques sont maintenant le mode daffichage habituel des postes de travail individuels, quil sagisse de poste bureautique ou de stations de travail haut de gamme. Une zone de mmoire ddie contient limage en point point devant tre affiche. Un processeur graphique spcialis parcours cette mmoire et interprte la suite des emplacements comme dcrivant les points successifs ou pixels de limage, et les transforme en signal vido pour laffichage. Ce balayage est effectu 25 fois par secondes. De plus, cette zone est galement accessible par le processeur central qui peut donc dfinir le contenu de chaque pixel de lcran. Comme un cran peut comporter jusqu 1300 lignes de 1600 points chacune, limage peut donc tre constitue denviron 2 millions de pixels, chaque pixel tant dfini gnralement par trois couleurs (rouge, vert et bleu), le niveau de chacune delles tant dfini par 8 bits. Une telle mmoire peut donc atteindre 6 Mo. Le processeur central na pas redfinir tout ou partie du contenu de ces 6 Mo, 25 fois par secondes, mais chaque fois quun changement intervient dans limage afficher lutilisateur. Dans le cas de la ncessit danimation complexe, il peut tre fait appel un processeur spcialis pour faire varier le contenu de cette mmoire. Les crans graphiques sont en gnral coupls ce que lon appelle une souris. Il sagit en fait dun dispositif trs simple qui transmet les mouvements subis dans deux directions, ainsi que lappui sur 1 3 boutons. Ces informations de mouvements peuvent tre analyss par un logiciel spcialis, qui en retour affiche une marque une position de lcran, permettant lutilisateur de voir leffet de ses mouvements sur la souris. Ce logiciel doit tre assez rapide pour que tout mouvement de lutilisateur ait un effet visuel immdiat. Les programmes dapplications reoivent en gnral les coordonnes de la position de la marque sur lcran au moment de lappui sur lun des boutons.

2.6.1.3. Les imprimantes


L'imprimante est un autre type de priphrique de dialogue homme-machine trs courant. On peut distinguer les imprimantes caractres et les imprimantes graphiques. Nous mettons dans la catgorie des imprimantes caractres celles qui on envoie les caractres imprimer et qui ont peu de fonctionnalits de mise en page. Une telle imprimante peut tre connecte sur une ligne srie comme les terminaux cran-clavier, et a alors les mmes caractristiques vues du processeur. L'intrt est d'une part la standardisation vue de l'ordinateur qui ne fait pas de distinction entre ces imprimantes et les terminaux, et d'autre part la possibilit de les loigner de l'ordinateur pour les rapprocher de l'utilisateur. Elle peut galement tre relie par une interface directe en mode caractre, c'est--dire en utilisant les entres-sorties programmes vues plus haut, la boucle assurant le transfert d'une ligne. Elle peut enfin tre relie sur un dispositif d'accs direct la mmoire. Dans ces deux derniers cas, le dbit instantan peut tre important, car l'imprimante dispose en gnral d'un tampon correspondant une ligne, ce qui justifie ces deux modes de liaison. Il faut noter cependant que l'impression proprement dite ralentit le dbit moyen, qui varie entre 100 octets par seconde et 5000 octets par seconde (2400 lignes/minute). Les imprimantes graphiques, par exemple les imprimantes laser, offrent des fonctionnalits complexes de dessin de caractres ou de figures comme de mise en page. Les plus simples doivent recevoir le contenu de la page imprimer sous la forme dune suite de bits dcrivant les points (noir ou blanc) des lignes successives. Cependant, avec une finesse de 300 points par pouce, une page contient environ 8 millions de points, dcrits par 1 Mo, qui doivent tre transmis pendant le dfilement de la feuille de papier devant le faisceau laser. Aussi cette mthode a tendance tre abandonne au profit dune mthode plus labore, dans la quelle le contenu de la page est dcrit dans un langage standardis, comme postscript. Limprimante dispose dun processeur rapide qui interprte cette description et la traduit en points sur le papier. Ce processeur peut tre dot de plus ou moins de mmoire pour stocker les descriptions de page imprimer et les dessins correspondants
- 20 -

Architecture matrielle plusieurs fontes (une fonte est un assortiment de caractres). Par ailleurs, la disponibilit dun processeur permet de connecter limprimante directement au rseau. Notons que pour les crans claviers et les imprimantes classiques, le dbit en sortie n'est pas crucial en ce sens que si le dbit est ralenti du fait du processeur, il n'y aura pas perturbation du fonctionnement, mais simplement perte de performance. Le dbit en entre des claviers doit tre respect sous peine de perte d'informations, mais ce dbit est assez faible pour ne pas tre trop contraignant, sauf, comme nous l'avons dit, dans le cas d'un nombre important de terminaux. Nous verrons que ces contraintes sont beaucoup plus fortes pour les autres types de priphriques.

2.6.2. Les priphriques de stockage squentiel


Nous nous intressons ici aux bandes magntiques de 1/2 pouce3 de large, soit 1.27 cm., et d'environ 2400 pieds de long, soit 730 mtres. L'enregistrement et la lecture sont obtenus par 9 ttes permettant de mettre transversalement un octet avec un bit de parit. Le transfert entre l'ordinateur et la bande ne peut s'effectuer que lorsqu'elle dfile vitesse constante, en gnral 75 ips (inches par seconde), soit 190.5 cm/s, mais peut atteindre 200 ips, soit 5 m/s. La densit, exprime en nombre d'octets par pouce (bpi pour byte per inch), dterminera d'une part la capacit totale de la bande, d'autre part le dbit du transfert. Les densits les plus courantes actuellement sont, d'une part 1600 bpi, donnant une capacit totale de 44 Mo, et un dbit de 120 Ko/s, d'autre part 6250 bpi, donnant une capacit totale de 172 Mo, et un dbit de 500 Ko/s, mais pouvant atteindre 1.25 Mo/s. La vitesse de dfilement devant tre constante pendant le transfert, il faut mmoriser les informations par bloc de taille variable, les blocs successifs tant spars par un espace inutilisable (gap) rserv au freinage et l'acclration. Cet espace est en moyenne de 3/4 de pouce, soit 1.905 cm. Constatons que les dbits interdisent les entres-sorties programmes. Par ailleurs le dbit doit imprativement tre respect sous peine d'critures d'informations errones si l'ordinateur ne fournit pas un octet temps en criture, ou de perte d'informations si l'ordinateur ne mmorise pas un octet temps en lecture. C'est pourquoi on utilise les entres-sorties par accs direct la mmoire ou par processeur spcialis. Ce dernier offre l'avantage de permettre d'assurer toutes les reprises d'erreurs qui pourraient se produire, en recommenant ventuellement plusieurs fois l'opration.

2.6.3. Les priphriques de stockage alatoire


secteur tte

6 7 8 9

1 0 15

10

11

12

13

14

bras

piste

cylindre

Fig. 2.8. Disque magntique. Il s'agit essentiellement des disquettes, ou disques magntiques. Bien des caractristiques s'appliquent galement aux disques optiques, mais nous n'en parlerons pas. Un disque est constitu d'un ou plusieurs plateaux tournant vitesse constante autour de leur axe (on parle parfois d'une pile
3

Rappelons que le pouce (Inch) est une mesure de longueur anglaise, qui vaut 2.54 centimtres, tout comme le pied, qui vaut 12 pouces, soit 30.48 centimtres. - 21 -

Introduction de disque ). Chaque plateau est recouvert sur ses deux faces d'une couche magntique. Des ttes de lecture/criture sont fixes, raison de une par face, sur un bras qui peut se dplacer perpendiculairement l'axe. Pour une position du bras donne, chaque tte peut lire ou crire sur une circonfrence du plateau qui la concerne, dlimitant ainsi ce que l'on appelle une piste. L'ensemble des pistes vues par chaque tte, pour une position de bras donne, s'appelle un cylindre. Enfin chaque piste est dcoupe en secteurs, qui contiennent chacun le mme nombre d'octets (figure 2.8). La structure mme du disque impose que les oprations se fassent par secteurs complets. Par ailleurs, le dbit est constant pour un disque donn, et est actuellement compris entre 250 Ko/s et 5 Mo/s. Comme il doit imprativement tre respect, il est ncessaire d'utiliser les entres-sorties par accs direct la mmoire ou par processeur spcialis. Contrairement aux bandes magntiques, ce dernier n'est pas essentiel pour la rcupration d'erreurs qui sont peu frquentes (et en gnral plus irrmdiables) sur les disques, mais peut prendre en charge une partie de la gestion du disque luimme et des accs. Les disquettes ont la mme structure que les disques durs, mais le dbit est beaucoup plus faible, puisqu'il est de l'ordre de 30 Ko/s. Ce dbit est donc parfois compatible avec le mode d'change programm. Il faut noter cependant que lors de la lecture ou de l'criture d'un secteur, le dlai qui spare le lancement de l'opration du transfert du premier octet, est alatoire, et compris entre 0 et 300 ms, temps pendant lequel le transfert programm impose au processeur de rester en boucle d'attente.

2.6.4. Les priphriques de communications entre machines


Lorsqu'on veut faire communiquer entre elles plusieurs machines, diffrentes solutions sont possibles. Nous nous intressons ici aux communications entre machines htrognes et distance moyenne ou longue. En effet un constructeur peut construire des dispositifs particuliers, entre deux accs directs la mmoire, ou mme partager la mmoire entre les machines, pour changer des informations entre des machines de sa fabrication qui seraient situes dans la mme pice. La communication entre machines sur des distances dpassant par exemple 100 mtres, pose d'abord le problme du cot du cable. Comme dans le cas des liaisons avec les crans-claviers, la connexion est effectue en utilisant des cables 2 ou 4 fils. Cette communication pose ensuite le problme du langage utilis, et que l'on appelle le protocole de communication. Initialement, chaque constructeur avait son propre protocole, ne permettant que la communication entre ses machines. Sous la pression des utilisateurs, et de divers organismes, des protocoles varis ont t normaliss par des instances internationales. Nous ne tentons ici que de donner quelques caractristiques importantes de ces communications. La notion de protocole consiste encadrer l'information transmettre, c'est--dire le contenu, par des informations qui construisent le protocole, et servent vhiculer le contenu. Dans la description de la ligne srie asynchrone, nous avons vu un exemple de protocole simple o l'octet tait encadr par un bit start et des bits stops. Dans la communication entre machines les protocoles sont plus complexes, de faon permettre des changes complexes d'informations. La premire caractristique est la transmission par paquet. L'ensemble des octets reprsentant l'information transmettre est tout d'abord dcoup en morceau, par exemple 250 octets. Chaque morceau est encadr par les informations du protocole permettant de le vhiculer, constituant un paquet. Les diffrents paquets sont transmis individuellement. A la rception des paquets, le rcepteur en extrait le contenu, et utilise les informations du protocole pour reconstruire l'information. Intuitivement, le protocole doit permettre d'identifier l'metteur, le rcepteur, et un numro d'ordre du paquet. La deuxime caractristique est la transmission du paquet vitesse constante. On dit que la transmission est synchrone, car d'une part les horloges de l'metteur et du rcepteur sont synchronises entre elles, d'autre part l'metteur commence par transmettre en dbut de paquet une information permettant au rcepteur de reconnatre le premier bit rel du paquet, et de faire le regroupement des bits des octets 8 par 8. La troisime caractristique est la complexification de l'ensemble de la transmission entre deux machines qui rsulte de l'abandon des liaisons point point par des lignes spcialises au profit de
- 22 -

Architecture matrielle l'interconnexion globale de l'ensemble des machines de la plante. Ceci a conduit la dfinition du modle OSI (Open Systems Interconnexion) qui dcoupe la communication en 7 couches, chacune d'elle tant charge d'une tche spcifique, comme par exemple, la couche rseau charge du routage des paquets ou la couche transport charge de segmenter les messages en paquet lors de l'mission et de recomposer les messages partir des paquets lors de la rception. Les dbits actuels sont importants, puisqu'ils sont couramment de 200 Ko/s, mais ils peuvent atteindre plusieurs dizaines de Mo/s, sur des rseaux locaux comme sur des rseaux longue distance. Il est vident que de tels dbits ncessitent d'utiliser soit l'accs direct la mmoire, soit le processeur spcialis d'entres-sorties, la complexit des protocoles et leur normalisation lui faisant souvent prfrer ce dernier.

2.6.5. Les priphriques et le systme


Il ressort de l'tude des caractristiques des diffrents priphriques une trs grande diversit de fonctionnement, de mode de liaison, de vitesse de transfert. Programmer sur une machine nue implique la connaissance de cette diversit, et la spcialisation du programme une configuration particulire. L'un des rles essentiels du systme d'exploitation, et de son constituant particulier le superviseur d'entres-sorties, est de prendre en compte cette diversit pour en dcharger le programmeur. Le systme fournira au programmeur un nombre limit d'interfaces standards et uniformes.

2.7. Conclusion
Un ordinateur est constitu d'un bus qui relie les divers organes, d'un processeur, d'une mmoire centrale et de priphriques. Un processeur est constitu d'une unit arithmtique et logique, de registres et d'un dcodeursquenceur qui le contrle. Il lit en mmoire l'intruction situe l'adresse dfinie par le compteur ordinal, l'excute, puis recommence. Son langage est binaire. Les entres-sorties programmes sont obtenues par un programme qui effectue le transfert des informations entre la mmoire et un priphrique, une par une. L'accs direct la mmoire est un dispositif qui assure le transfert des informations entre la mmoire et un priphrique par vol de cycle. La prise en compte d'une interruption par le processeur consiste ranger en mmoire le mot d'tat programme et le remplacer par un nouveau. Le compteur ordinal fait partie de ce mot d'tat programme. Le reste du contexte doit tre sauvegard par le sous-programme d'interruption, pour permettre sa restitution en fin d'excution de ce sous-programme. Le masquage des interruptions est le mcanisme qui permet au logiciel de contrler la prise en compte des interruptions par le processeur. Le processeur peut travailler selon le mode matre ou le mode esclave dans lequel certaines instructions sont interdites. Des instructions spciales d'appel superviseur permettent de changer de mode de faon contrle. Les priphriques de dialogue homme-machine, lorsqu'ils sont simples, peuvent tre grs par des transferts programms, ventuellement rgis par interruption. Cependant lorsque leur nombre augmente sur une mme machine, la charge de traitement peut ncessiter l'utilisation de processeurs spcialiss appels frontaux. Par ailleurs, dans les stations de travail, l'affichage est le rsultat de modifications du contenu de la mmoire partage par le dispositif de balayage vido. Les priphriques magntiques, bandes ou disques, ncessitent l'utilisation soit de l'accs direct la mmoire, soit d'un processeur spcialis d'entres-sorties. Ce dernier a l'avantage de permettre de dcharger le processeur principal d'une partie de la gestion du priphrique. La communication entre machines utilise des protocoles normaliss, qui permettent de s'affranchir des contraintes matrielles et prendre en compte la complexit du rseau
- 23 -

Introduction d'interconnexion. L'information est dcoupe par l'metteur en paquets indpendants, et reconstruite par le rcepteur l'aide du protocole. L'une des fonctions du systme est de dcharger le programmeur du souci de la diversit des priphriques, par la fourniture d'un nombre limit d'interfaces standards et uniformes.

- 24 -

Gnralits sur les systmes d'exploitation

Le premier chapitre a montr l'volution qui s'est produite sur l'utilisation de l'ordinateur, et l'introduction progressive de programmes gnraux permettant de contrler son utilisation. Cette volution a t parfois mal ressentie par les utilisateurs qui voyaient souvent les contraintes et non les avantages. Ceux-ci ont espr de l'abaissement des cots du matriel la suppression du systme d'exploitation. Le deuxime chapitre a mis en vidence la complexit du matriel, ainsi que sa diversit. Il ne viendrait l'esprit de personne, actuellement, de demander la suppression du systme d'exploitation. Il s'agit de le rendre apte rpondre aux vritables besoins des utilisateurs et de privilgier les services dont ces derniers ont besoin.

3.1. Les diffrents types de systmes d'exploitation


Lors de la phase de conception d'un systme d'exploitation, il est ncessaire de faire de nombreux choix, choix d'algorithmes, choix de politique de gestion, choix de paramtres, etc... Ces choix sont guids par la nature de l'utilisation du systme, et conduisent des solutions de compromis.

3.1.1. Les modes d'utilisation


Le premier chapitre a montr plusieurs modes d'utilisation de l'ordinateur. Le mode interactif correspond au cas o l'utilisateur dialogue avec l'ordinateur: il lance des commandes dont la dure d'excution est brve, et dont il dsire une rponse en quelques secondes, pour pouvoir dcider de la suivante, aprs un temps de rflexion plus ou moins long. Ce mode se subdivise en plusieurs sous modes suivant les applications: Le mode temps partag: l'utilisateur doit pouvoir utiliser toutes les fonctionnalits de l'ordinateur, comme s'il l'avait pour lui tout seul. Il s'agit surtout de lui permettre de crer, tester, modifier, et excuter des programmes quelconques. Le mode transactionnel: l'utilisateur excute des programmes prdfinis, pour consulter ou mettre jour des donnes partages entre de nombreux utilisateurs. Le mode conception assiste: l'utilisateur se sert de toute la puissance de l'ordinateur pour l'aider dans un travail complexe de conception. L'aspect graphique est souvent ici une caractristique essentielle, et est une des raisons du besoin de puissance de calcul, le rsultat d'une commande tant une modification d'un dessin sur l'cran. Le mode diffr correspond au traitement par lot. Dans ce mode, l'utilisateur fournit un travail dont il viendra chercher le rsultat quelques heures aprs. Le travail peut tre consquent, et ncessiter de disposer de plusieurs ressources pendant un temps important, comme par exemple, du temps de processeur central, de l'espace mmoire ou des bandes magntiques.

- 25 -

Introduction Le mode temps rel correspond au contrle de procds industriels. L'ordinateur a en charge de prendre des mesures au moyen de capteurs externes, pour surveiller un procd, et lui envoyer en retour des commandes pour en assurer la bonne marche. Ces commandes doivent tre envoyes dans des intervalles de temps qui sont imposs par le procd lui-mme, pour garantir son bon fonctionnement.

3.1.2. Les critres de choix


Les critres qui permettent de caractriser l'adquation du systme au mode de fonctionnement dsir, et donc d'induire les choix lors de la conception du systme peuvent s'noncer de la faon suivante: Le temps de traitement d'une commande pourrait se dfinir comme le temps que mettrait l'ordinateur pour excuter la commande s'il ne faisait que cela. En gnral, ce temps est dcompos en un temps de processeur et un temps d'entres-sorties. Il est normalement assez bref dans le mode interactif (infrieur la seconde, par exemple); il est souvent connu dans le sous mode transactionnel, mais il est a priori imprvisible dans les sous modes temps partag et conception assiste. Dans le mode diffr, ce temps peut tre beaucoup plus important, de l'ordre de plusieurs dizaines de minutes, mais sa valeur maximale est souvent dfinie par le demandeur. Enfin, dans le mode temps rel, il est en gnral trs bref, quelques dizaines de millisecondes, et connu, de faon assez prcise. Le temps de rponse est le dlai qui spare l'envoi de la commande par le demandeur, de la fin d'excution de la commande. Ce temps ne peut, videmment, tre infrieur au temps de traitement. Ce n'est pas une consquence de la demande seule, mais le rsultat du comportement du systme. C'est l'un des critres de jugement de l'utilisateur, et donc une contrainte que doit respecter le systme pour satisfaire ce dernier. Si, par nature, un temps de rponse de plusieurs heures est acceptable pour le mode diffr, par contre l'utilisateur, en mode interactif, attend normalement des temps de rponse de l'ordre de la seconde. Le sous-mode conception assiste peut parfois impliquer des temps de rponse beaucoup plus bref (suivi de souris par exemple). Le mode temps rel impose des contraintes souvent strictes sur le temps de rponse qui peut tre aussi bien de quelques millisecondes, que de quelques minutes. Le dbit (en Anglais throughput) est le nombre de commandes qui sont excutes par unit de temps. C'est une mesure de l'efficacit de l'ensemble du systme, matriel et logiciel, qui est surtout intressant pour le responsable du service informatique, car il permet de calculer indirectement la rentabilit du systme, tous utilisateurs confondus. Il dpend videmment de la nature des commandes demandes par les utilisateurs. Dans le mode transactionnel, le dbit est dfini par le nombre de transactions par seconde ou Tps. Dans le mode diffr, le dbit est dfini par le nombre de travaux l'heure. Les moments d'arrive des commandes dterminent la faon dont les commandes sont demandes au systme. C'est une caractristique de l'utilisateur. On a constat, par exemple, qu'en mode temps partag un utilisateur rflchissait environ 30 secondes entre la rponse une commande et l'envoi de la commande suivante. Cette dure peut tre plus courte en mode transactionnel, lorsqu'il s'agit par exemple de la saisie d'un ensemble d'oprations comptables. A l'oppos, le mode diffr signifie que chaque travail consiste lui-mme en l'enchanement d'une suite de commandes prdfinies, permettant une planification des travaux. Le mode de communication entre le demandeur et l'ordinateur impose des contraintes supplmentaires sur le systme, ds que l'on dsire introduire une distance entre les deux. Nous avons vu dans le chapitre prcdent que la communication entre machines faisait intervenir un protocole normalis plus ou moins complexe. La nature du partage des ressources entre les demandeurs doit tre clairement apprhnde, car elle a une influence directe sur le comportement du systme. Par exemple, le processeur est une ressource effectivement partage entre les utilisateurs. Le systme doit permettre une utilisation simultane ( l'chelle de temps humaine) de cette ressource. Par contre une imprimante, ou un drouleur de bandes magntiques ne peuvent tre attribus qu' un seul utilisateur la fois, pendant des priodes de temps assez longues. Le partage des ressources logicielles laisse souvent plus de libert de choix suivant le mode d'utilisation. Notons tout d'abord que toute donne peut tre consulte par un nombre quelconque d'utilisateurs sans difficult. Les problmes surgissent avec les modifications d'une mme donne par plusieurs. En mode diffr,
- 26 -

Gnralits sur les systmes le partage de donnes est obtenu simplement en attribuant exclusivement au travail l'ensemble des donnes dont il a besoin. Il en va souvent de mme en mode temps partag ou en mode conception assiste. En mode transactionnel, il est par contre impratif de permettre de nombreux utilisateurs de pouvoir consulter ou modifier une mme donne, qui doit alors apparatre comme utilise simultanment par tous ces utilisateurs. Par ailleurs, dans ce mode, il y a souvent beaucoup d'utilisateurs excutant le mme programme, justifiant le partage de la mmoire centrale entre les utilisateurs.

3.1.3. Systme gnral ou spcialis


Certains systmes ont t conus pour satisfaire le plus grand nombre de besoins, tout en privilgiant lgrement l'un des modes. Par exemple, Multics (Bull) ou VMS (Dec) privilgient le mode temps partag, tout en tant acceptable pour le transactionnel ou le diffr; Multics ne tournant que sur grosse machine (DPS-8 spcial) est mal adapt aux modes conception assiste ou temps rel, alors que VMS peut tre configur sur des machines de taille moyenne pour rpondre peu prs aux besoins de la conception assiste ou du temps rel. De mme UNIX privilgie sutout le temps partag; sa taille (initialement petite!) et sa disponibilit sur de nombreux matriels permettent de l'adapter aux besoins de la conception assiste. On ne peut le considrer comme adapt au temps rel, mme s'il est plus facile que dans bien d'autres systmes, d'y incorporer des pilotes de priphriques, c'est-dire des sous-programmes de gestion de priphriques. A l'oppos, GCOS3 (Bull) ou MVS (IBM) sont des systmes orients d'abord vers le mode diffr. Sur MVS, les autres modes sont obtenus par le biais de sous systmes spcialiss, tels que TSO pour le temps partag, CICS ou IMS pour le mode transactionnel. Le systme VM (IBM) se place de faon diffrente. Il s'agit en fait d'un noyau de systme qui mule un ensemble de machines sur lesquelles on peut faire excuter des systmes particuliers. Par exemple, CMS est un systme tournant sous VM, qui privilgie le mode temps partag; il est d'ailleurs plus apprci que TSO sous VMS. Pour certaines applications, cette universalit du systme d'exploitation n'est pas adapte, ce qui conduit alors concevoir un systme spcialis pour l'un des modes d'utilisation. Ceci est particulirement vrai pour le temps rel ou le contrle de procds, pour lequel il existe beaucoup de systmes ddis: iRMX86 de Intel, SPART sur SPS-7 de Bull, RT-11 de Dec, etc... Il en est ainsi galement pour certaines applications transactionnelles o le nombre de terminaux est particulirement important, comme, par exemple, pour les systmes de rservation de places pour les transports ariens ou terrestres. Enfin, la conception assiste demande souvent une puissance de calcul importante, et conduit un poste de travail qui est dj un ordinateur dot d'un systme d'exploitation; il s'agit souvent d'un Unix configur spcialement pour ces besoins. Sur les ordinateurs personnels, par dfinition, il n'y a qu'un utilisateur la fois. Il est donc naturel que leur systme mette l'accent sur le mode interactif. MS-DOS, Windows 95/98 ou MacOS en sont de bons exemples. Cependant, si l'origine, la faible puissance de ces ordinateurs justifiait la simplicit du systme, ce n'est plus le cas aujourd'hui, et ces systmes se sont complexifis dans les aspects interfaces. Cependant, les limites de ces systmes, qui ne grent pas le partage du processeur entre plusieurs activits, sont mises en vidence par la concurrence des stations de travail, de prix trs abordable, dotes souvent d'un systme de type UNIX, LINUX ou Windows NT.

3.2. Les services offerts par le systme


Nous nous intressons ici au point de vue de l'utilisateur dans son travail de conception et de ralisation d'une application particulire.

3.2.1. La chane de production de programmes


Nous avons vu dans le chapitre prcdent que le langage de l'ordinateur tait binaire et rudimentaire. Il faut donc tout d'abord lui fournir un ensemble d'outils qui lui permette de construire cette application dans un langage plus agrable pour lui; ce sont les divers constituants de la chane
- 27 -

Introduction de production de programmes. Certains d'entre eux seront tudis plus en dtail dans les chapitres suivants. L'interprteur de commande est le premier outil fondamental. C'est lui qui va permettre l'utilisateur de se faire connatre de l'ordinateur (login), et de lui demander l'excution des programmes prenregistrs, au fur et mesure de ses besoins. Certains systmes offrent plusieurs interprteurs permettant de satisfaire des utilisateurs aux besoins diffrents. Les diteurs de texte permettent la cration et la modification du texte des programmes. Les premiers dcoupaient le texte en lignes, et permettaient les modifications des textes comme on le faisait avec des cartes perfores, en utilisant des terminaux de possibilits rduites. La deuxime gnration dcoupe le texte en pages, affiche une page sur l'cran dont est dot le terminal et permet de se dplacer dans le texte la position voulue pour faire les corrections visibles immdiatement sur l'cran. Dans chacun des cas, le texte manipul est une suite de caractres quelconques, l'diteur permettant parfois la manipulation par caractre, par mot, par ligne ou par paragraphe. La dernire gnration tente de faciliter le travail du programmeur en tenant compte du langage utilis: l'diteur permet alors la manipulation d'entits structurelles du langage, telles que les instructions, les blocs, les sous-programmes, les dclarations, etc... On les appelle diteurs syntaxiques , car les manipulations autorises sont guides par la syntaxe du langage de programmation de l'utilisateur. Les compilateurs, interprteurs ou assembleurs sont des programmes particuliers, fournis en gnral par le constructeur de la machine, qui permettent la traduction d'un programme crit dans un langage donn, plus adapt l'homme, dans le langage de la machine. L'diteur de liens et le chargeur sont galement des programmes fournis par le constructeur. Les logiciels professionnels sont souvent de bonne taille, et ne peuvent tre manipuls comme un tout. Il est ncessaire de les dcomposer en modules qui sont des morceaux de programmes qui peuvent tre compils sparment les uns des autres. L'diteur de liens permet de rassembler de tels modules dj compils et d'en faire un programme excutable. Le chargeur est le programme qui assure la mise en mmoire centrale d'un programme excutable, et d'en lancer l'excution (figure 3.1).
module source module source module source compilateur module objet module objet module objet chargeur diteur de liens programme excutable

compilateur

assembleur

diteur

bibliothcaire

metteur au point

mmoire

Fig 3.1. La chane de production de programmes. Des outils complmentaires sont souvent galement fournis pour faciliter le travail du programmeur, tels que un metteur au point qui facilite le test des programmes, paragrapheur qui met en forme les textes sources de programmes, outil de rfrences croises qui permet de connatre les liens entre les modules, bibliothcaire qui gre les modules dj compils, etc...

3.2.2. Le programme et les objets externes


Nous avons vu galement que les connexions avec les priphriques taient complexes et varies. Bien des applications n'ont pas pour but d'accder ces priphriques en tant que tel, mais pour pouvoir mmoriser des informations dont la dure de vie excde la dure d'excution du programme, ou pour pouvoir communiquer avec l'extrieur de la machine. Il faut donc lui fournir des moyens de simplifier les accs ces priphriques, en lui proposant des mcanismes uniformes d'accs des objets externes aux programmes.
- 28 -

Gnralits sur les systmes Les chapitres 7 11 montreront quels sont les problmes, et comment ils sont rsolus habituellement. Il s'agit de fournir l'utilisateur, d'une part, des outils de gestion de ces objets externes sous forme de programmes spcifiques, mais aussi, d'autre part, des sous-programmes d'accs au contenu de ces objets l'intrieur de ses propres programmes.

3.2.3. Le programme et son environnement physique


Le matriel dont on dispose est fig et a certaines caractristiques plus ou moins faciles utiliser. Le programmeur a, par ailleurs, des besoins inhrents l'application qu'il doit raliser, et ne peut configurer strictement le matriel ses besoins, car ceux-ci varient d'une application l'autre. Le problme est alors de fournir l'utilisateur une machine virtuelle adapte ses besoins. Le terme virtuel doit ici tre compris essentiellement par opposition rel, c'est--dire que notre machine virtuelle est obtenue par substitution totale ou partielle de composants matriels par des composants logiciels. L'un des premiers aspects est en particulier d'assurer l'indpendance des usagers de la machine relle, en grant implicitement les ressources communes (processeur, mmoire, etc...). Il est possible galement de simuler des ressources qui n'existent pas ou qui sont insuffisantes, de faon adapter la configuration de la machine virtuelle aux besoins. Ceci sera dvelopp dans les chapitres 12 14.

3.3. Architecture d'un systme


La figure 3.2 montre l'architecture habituelle d'un systme informatique. Dans le premier niveau, on trouve la machine nue, c'est--dire les composants matriels. Le deuxime niveau assure les fonctions premires de gestion des ressources physiques, et sert d'interface entre le logiciel et le matriel. Le troisime niveau dfinit les fonctionnalits du systme lui-mme. Les niveaux suprieurs ne sont plus partie intgrante du systme proprement dit. Ce sont donc des programmes plus ou moins fortement lis au systme. En particulier le quatrime niveau rassemble l'ensemble des outils qui contribuent la chane de production de programmes. Le cinquime niveau regroupe l'ensemble des programmes d'application, ainsi que des utilitaires courants qui sont en fait des programmes d'application suffisamment gnraux pour ne pas tre ddis une application donne, comme par exemple les utilitaires de tri-fusion ou de copie de fichiers. Les utilisateurs se trouvent au niveau suprieur (6).
6 5 4 3 2 1 gestion processeur gestion mmoire programmes d'application diteur de texte assembleur utilisateurs programmes utilitaires compilateur diteur de liens ateliers de programmation chargeur metteur au point

systme d'exploitatio n gestion donnes gestion priphriques gestion communications

machine nue

Fig. 3.2. Architecture gnrale d'un systme informatique.

3.4. Conclusion
Il y a plusieurs modes diffrents d'utilisation de l'ordinateur: le mode interactif, le mode diffr, ou le mode temps rel. Le mode interactif peut lui-mme se dcomposer en mode temps partag, mode transactionnel et mode conception assiste. Chacun des modes a ses propres caractristiques, qui se distinguent par le temps de traitement, le temps de rponse, les moments d'arrive, le mode de communication et la nature du partage des ressources.
- 29 -

Introduction Les systmes d'exploitation peuvent tre conus pour satisfaire le plus grand nombre de besoins, tout en privilgiant l'un des modes, ou tre ddis un besoin spcifique, lorsque les contraintes sont trop fortes. La chane de production de programmes est l'ensemble des outils qui concourrent la ralisation des programmes. Elle comprend principalement l'interprteur de commandes, les diteurs de texte, les traducteurs, l'diteur de liens, le chargeur, etc... Les objets externes sont des objets manipuls par les programmes, mais dont la dure de vie s'tend au-del de la dure d'excution d'un programme unique. L'environnement physique des programmes doit tre adapt par le systme pour fournir l'utilisateur une machine virtuelle dont la configuration correspond ses besoins.

- 30 -

DEUXIME PARTIE

CHAINE DE PRODUCTION DE PROGRAMMES

La traduction des langages de programmation

Le langage de la machine est en fait constitu de bits, ce qui le rend impraticable par l'homme. La premire tape a t de concevoir des langages simples, assez proches du langage de la machine pour pouvoir tre traduits facilement. Il s'agissait alors de remplacer les codes binaires des oprations de base par des codes mnmoniques plus faciles se rappeler, la traduction consistant retrouver les codes binaires correspondants. Ceci a conduit aux langages d'assemblage qui se sont perfectionns, tout en restant proches de la machine, dont le programmeur devait avoir une connaissance approfondie. La difficult de mise en uvre de ce type de langage, et leur forte dpendance avec la machine a ncessit la conception de langages volus, plus adapts l'homme, et aux applications qu'il cherchait dvelopper. Faisant abstraction de toute architecture de machine, ces langages permettent l'expression d'algorithmes sous une forme plus facile apprendre, et dominer. On s'intresse alors aux vrais besoins d'expression du programmeur plutt qu'aux mcanismes fournis par la machine. Il s'ensuit une spcialisation du langage suivant la nature des problmes rsoudre et non suivant la machine qui sera utilise pour les rsoudre. Ainsi, FORTRAN est un langage destin aux applications scientifiques, alors que COBOL est destin aux applications de gestion. Pour l'ordinateur, un programme crit dans un langage qui n'est pas le sien est en fait une simple suite de caractres plus ou moins longue. Si le langage est un langage d'assemblage, un programme spcialis, l'assembleur, parcourt cette suite de caractres pour reconnatre les diffrents mnmoniques, et les remplacer par leur quivalent binaire dans le langage de la machine (c'est une approche trs sommaire!). Si le langage est un langage volu, le programme spcialis, charg de la traduction, peut se prsenter sous l'une des deux formes suivantes: L'interprteur parcourt en permanence la suite de caractres, analyse les actions dfinies par le programme, exprimes dans le langage volu, et excute immdiatement la squence d'action de la machine qui produit les mmes effets. Le compilateur parcourt la suite de caractres, analyse les actions du programme et la traduit en une suite d'instructions dans le langage de la machine. Il s'ensuit videmment que l'analyse des actions est une phase plus complexe et plus difficile que pour l'assembleur. Notons que l'interprteur simule une machine qui comprend le langage volu, alors que le compilateur fait une traduction dans le langage de la machine, et c'est cette traduction qui est excute. Il s'ensuit qu'un interprteur est plus facile utiliser pour le programmeur, mais le rsultat est moins efficace que l'excution du programme compil, car les actions du programme sont analyses chaque fois qu'elles doivent tre excutes. Par exemple, une action situe l'intrieur d'une boucle excute 10000 fois, sera analyse 10000 fois.

- 33 -

Chane de production de programmes Notons qu'il est possible de combiner les deux. Plusieurs environnements de programmation ont t ainsi construits autour du Pascal vers 1971, de Caml vers 1988 et de Java en 1998, chacun d'eux ayant un fonctionnement analogue. Nous dcrivons celui de Java qui est le plus rcent. On dfinit d'abord une machine virtuelle universelle, ayant son propre langage, appel bytecode. En gnral ces machines n'existent pas physiquement, bien qu'il y ait eu des tentatives dans ce sens. On compense cette absence en la simulant par logiciel, c'est--dire en crant un interprteur de bytecode. La compilation consiste alors traduire un programme Java en bytecode qui peut donc tre excut l'aide de cet interprteur. Nous reviendrons sur ce principe la fin du chapitre. Quels que soient le langage et la mthode de traduction utiliss, le programme est toujours une suite de caractres. C'est ce que nous appellerons un programme source. Le traducteur doit analyser cette suite de caractres pour retrouver les constituants essentiels, vrifier la conformit avec la dfinition du langage, et en dduire la smantique. Un interprteur doit ensuite excuter les actions correspondant cette smantique, alors qu'un assembleur ou un compilateur doit traduire cette smantique dans un autre langage. On appelle programme objet , le rsultat de cette traduction. Par ailleurs, nous avons vu qu'il pouvait tre intressant de dcouper un programme en morceaux, traduits sparment, et rassembls ultrieurement par l'diteur de liens (videmment, ceci n'est pas possible avec un interprteur). On parle alors respectivement de module source et de module objet . Le langage utilis doit permettre la prise en compte de ce dcoupage en module.

4.1. L'analyse lexicale


La suite de caractres reprsentant le module est la forme concrte de communication entre le programmeur et le traducteur. Mais chaque caractre pris individuellement n'a pas, en gnral, de signification dans le langage lui-mme. Par exemple, dans un langage tel que Pascal, chaque caractre de la suite begin n'a pas de signification, alors que la suite elle-mme est un symbole du langage. Il apparat alors ncessaire de dcouper le module source, en tant que chane de caractres, en une suite de symboles du langage, chaque symbole tant reprsent par une suite de caractres. Considrons, par exemple, le petit bout de programme source suivant:
begin x := 23; end

Cette suite de caractres doit tre dcoupe de la faon suivante:


Begin x := 23 ; end

mettant en avant les six symboles dont est constitu le programme. Pour des raisons de commodit de traitement videntes, on donne chacun des symboles, une forme de reprsentation interne la machine. Cette opration de transformation du module source en une reprsentation interne code s'appelle l'analyse lexicale. Cette opration n'est videmment possible que si la structure lexicale du langage est correctement dfinie4. Ceci implique quelques contraintes habituelles sur la dfinition des langages: Un identificateur commence par une lettre, et ne peut comporter que des lettres, des chiffres, ou ventuellement des caractres spciaux qui ne sont pas utiliss ailleurs ("_" ou "$", par exemple). On peut dcrire cela sous la forme suivante:
identificateur ::= lettre { lettre | chiffre | "_" }

Une constante numrique commence par un chiffre, mme si elle est dans une base suprieure 10. On peut dcrire cela sous la forme suivante:
constante ::= chiffre { chiffre | lettre }

Les mots cls ont souvent la forme lexicale des identificateurs, et ne sont pas alors utilisables en tant qu'identificateur. C'est ce que l'on appelle encore les mots rservs. Les oprateurs peuvent tre reprsents soit par l'un des caractres spciaux habituels, tels que par exemple "+", "-", "=", etc..., mais aussi par une combinaison de ces caractres spciaux, comme par exemple ":=", pourvu que cette combinaison ne soit pas ambigu.
4

Notons que c'est l'absence d'une telle dfinition correcte pour le langage FORTRAN qui a t la cause de l'une des erreurs de programmation les plus coteuses pour la NASA. Un point ayant t tap la place de la virgule, le compilateur a traduit l'instruction de boucle "DO 50 I = 1 . 5" par une simple affectation de la valeur 1.5 la variable "DO50I". La sonde de Venus est passe 500 000 km de sa cible. - 34 -

Traduction des langages Les espaces, tabulations, fins de lignes sont sans signification, c'est--dire qu'ils sont ignors au cours de l'analyse, si ce n'est qu'ils ne peuvent se trouver l'intrieur de la reprsentation d'un symbole. En d'autres termes, ces caractres servent essentiellement la prsentation externe, mais sont aussi des sparateurs entre deux symboles. Ainsi dans le petit programme ci-dessus, l'espace permet l'analyseur lexicale de sparer le symbole begin de l'identificateur x, et est donc ncessaire cet endroit, alors que les autres espaces sont inutiles. L'ide gnrale de l'analyseur lexical est, sachant o commence un symbole dans la chane de caractres du module source, de rechercher o il se termine, en suivant les rgles de dfinitions lexicales du langage, puis de trouver o commence le symbole suivant, etc... Ces techniques sont suffisamment gnrales et bien matrises pour permettre de construire des programmes capables de produire automatiquement des analyseurs lexicaux partir de la dfinition lexicale d'un langage (par exemple, l'utilitaire lex disponible sur Multics ou sur Unix).

4.2. L'analyse syntaxique


Le rsultat obtenu aprs analyse lexicale est une suite de symboles. Mais, toute suite de symboles ne constitue pas un programme. Il faut donc vrifier la concordance de la suite avec la structure du langage, sans se proccuper, pour le moment, de la smantique du programme. C'est ce que l'on appelle l'analyse syntaxique. La plupart des langages de programmation modernes dfinissent une syntaxe du langage, indpendante du contexte, par des rgles de production, qui dcrivent la faon dont on peut construire une suite de symboles pour qu'elle constitue un programme. Le programmeur construit alors son programme en appliquant ces rgles de faon rptitive. L'analyse syntaxique consiste retrouver, partir du programme source, ou en fait partir de la suite de symboles, quelles sont les rgles que le programmeur a appliques. On utilise une syntaxe indpendante du contexte, pour permettre cette reconstruction. Une rgle de production est, en gnral, donne sous une forme standard, dite forme normale de Backus-Naur. Cette forme a l'avantage d'tre simple et facile assimiler. Par exemple, la syntaxe d'une expression pourrait tre donne par l'ensemble des rgles suivantes:
<expression> ::= <facteur> | <facteur> <oprateur additif> <expression> <facteur> ::= <terme> | <terme> <oprateur multiplicatif> <facteur> <terme> ::= <identificateur> | <nombre> | ( <expression> ) <oprateur additif> ::= + | <oprateur multiplicatif> ::= * | /

La premire prcise qu'une expression est, soit un facteur, soit un facteur suivi d'un oprateur additif suivi d'une autre expression. De mme la dernire indique qu'un oprateur multiplicatif est soit le symbole *, soit le symbole /. Plus gnralement, l'interprtation est la suivante: Les structures syntaxiques s'crivent sous la forme de mots encadrs par les signes < et >. Les symboles s'crivent sous leur forme lexicale. Une rgle de production comporte une structure syntaxique unique gauche du signe ::= et une ou plusieurs suites de symboles et de structures syntaxiques, les suites tant spares par le signe | indiquant un choix parmi les suites. Dans le contexte des rgles ci-dessus, la suite de symboles "23 * 2 + 5" est une expression constitue du facteur "23 * 2", suivi de l'oprateur additif "+" et de l'expression "5", qui est aussi un facteur, puis un terme et enfin un nombre. Le facteur " 23 * 2 " est lui-mme constitu du terme "23" qui est un nombre, suivi de l' oprateur multiplicatif "*" et du facteur "2", qui est un terme, et un nombre. Cet exemple montre que, non seulement, l'analyse syntaxique permet de contrler que le programme est correctement crit, mais aussi, qu'elle permet de trouver la structure syntaxique de ce programme (figure 4.1). En particulier, si 2 + 5 est bien une sous-suite de la suite donne, elle ne correspond aucune structure syntaxique du langage dans cette expression, alors que la soussuite 23 * 2 a t reconnue comme facteur de cette expression.

- 35 -

Chane de production de programmes


expression facteur terme nombre 23 opr. mult. * oprateur additif facteur terme nombre 2 + expression facteur terme nombre 5

Fig. 4.1. Structure syntaxique de l'expression 23 * 2 + 5. La rigueur de la dfinition des rgles de production tient la ncessit d'viter toute ambigut dans la faon dont le programme est crit. Il est en effet ncessaire d'avoir une structure syntaxique unique pour une suite donne de symboles. Si plusieurs structures taient possibles, il pourrait arriver que le compilateur choisisse une structure qui ne corresponde pas celle voulue par le programmeur, ce qui pourrait donner lieu ensuite une interprtation smantique diffrente.

4.3. L'analyse smantique


Aprs avoir contrl la correction du programme, et en avoir obtenu la structure syntaxique, la traduction continue par la phase d'analyse smantique, qui a pour but de trouver le sens des diffrentes actions voulues par le programmeur. Trois problmes doivent alors tre rsolus: quels sont les objets manipuls par le programme, quelles sont les proprits de ces objets, quelles sont les actions du programme sur ces objets. Les objets manipuls sont en gnral dsigns par le programmeur au moyen d'identificateurs. Certains langages imposent que tous les identificateurs soient explicitement dclars, c'est--dire, que le programmeur doit donner des indications au traducteur sur la nature et les proprits de l'objet dsign par l'identificateur. D'autres langages dduisent implicitement ces informations de la faon dont l'identificateur est utilis dans le programme. Les proprits importantes sont les suivantes: Le type de l'objet permet au traducteur de connatre la smantique des oprations effectues sur l'objet, et de dterminer ainsi la combinaison des oprations de la machine qui auront le mme effet. La dure de vie de l'objet permet au traducteur de savoir s'il doit prvoir ou non d'engendrer des instructions permettant sa cration ou sa destruction, et quels moments de l'excution du programme. La taille de l'objet permet au traducteur de savoir le nombre d'emplacements de mmoire occups par sa reprsentation. L'adresse de l'objet permet au traducteur de dsigner l'objet dans les intructions de la machine qui le manipulent. L'analyse smantique des actions du programme a pour but de permettre au traducteur de dterminer avec prcision la suite des actions qu'il doit excuter indpendamment de tout aspect langage. Prenons par exemple le morceau de programme suivant:
var i: entier; s: rel; dbut s := 0; i := 0; tantque i < 10 faire s := s + sqrt (i); i := i + 1; fait; fin;

- 36 -

Traduction des langages Des dclarations, le traducteur peut conclure que l'affectation s := 0 est une affectation de la valeur 0 un nombre rel, alors que i := 0 est une affectation entire. De mme, l'addition dans s := s + sqrt (i) est une addition entre des nombres rels, alors que l'addition dans i := i + 1 est une addition entre des nombres entiers. Cette phase d'analyse comporte une part importante de contrle, puisque le traducteur peut constater des lments incompatibles ou ambigus, ou des actions qui n'ont pas de sens. Les erreurs qui peuvent tre dcouvertes cette tape, sont par exemple l'absence de dclaration ou des dclarations incompatibles, des identificateurs dclars, mais inutiliss, des expressions sans signification (ajouter des rels et des chanes de caractres, par exemple), etc... Bien des contraintes que l'on trouve dans les langages de programmation modernes, et qui paraissent superflues a priori, n'ont en fait pour but que de garantir au programmeur que la smantique dduite par le traducteur de son programme ne prsente aucune ambigut. Si ce n'tait pas le cas, cela impliquerait que le traducteur pourrait prendre une smantique diffrente de celle voulue par le programmeur, et que deux traducteurs diffrents du mme langage pourraient dduire des smantiques diffrentes.

4.4. La gnration et l'optimisation de code


La phase de gnration de code est la phase de traduction proprement dite. Elle n'est entreprise que si aucune erreur n'a t trouve. Elle consiste construire un programme quivalent la smantique obtenue dans la phase prcdente, dans un nouveau langage, et donc en particulier dans le langage de la machine lui-mme. Le plus souvent, l'analyse smantique produit une structure particulire qui regroupe l'ensemble des informations obtenues sur le programme. La gnration exploite simplement cette structure pour produire le code. La notion d'optimisation est plus intressante. L'criture de programmes dans un langage volu permet de s'abstraire des particularits de la machine, mais a pour consquence de ne pas toujours donner un programme traduit aussi efficace que si l'on avait directement programm dans le langage d'assemblage. L'optimisation de code a pour but de compenser cet inconvnient. On peut dire que la qualit d'un compilateur peut se mesurer par l'efficacit du code machine produit, et repose en grande partie sur les techniques d'optimisation qui sont mises en jeu. Il n'est pas question d'en expliquer ici le fonctionnement, mais de donner quelques indications sur ses possibilits. Tout d'abord, le compilateur peut dterminer les expressions constantes, c'est--dire dont le rsultat peut tre connu la compilation, et propager cette valeur le plus possible dans le programme. Il est facile galement d'liminer le code inaccessible. Le but essentiel est de diminuer l'espace mmoire du programme rsultat. C'est une solution lgante au problme de la compilation conditionnelle. Par exemple, si le compilateur constate qu'une condition d'une instruction conditionnelle est toujours fausse, il peut liminer toutes les instructions qui devraient tre excutes dans le cas o la condition est vraie. Il peut dplacer des parties de code pour faire sortir d'une boucle des instructions qui produiront le mme rsultat chaque pas de la boucle. Il peut liminer les calculs lis aux variables d'induction de boucle, pour les remplacer par d'autres plus essentiels. Par exemple, la progression d'un indice dans un tableau peut tre remplace par la progression d'une adresse sur les emplacements du tableau. Il ne s'agit pas d'amliorer un programme mal crit, mais d'attnuer certaines inefficacits des l'criture de programmes dans un langage volu.

4.5. La traduction croise


Un traducteur est un programme excutable particulier qui prend pour donne un module source, et fournit comme rsultat un module objet. En tant que programme excutable, il s'excute sur une machine particulire qui comprend le langage dans lequel il est crit. Si cette machine est bien souvent la mme que celle laquelle sont destins les modules objets qu'il produit, ce n'est pas une obligation. Lorsque les deux machines sont diffrentes, on parle de traduction croise. Le
- 37 -

Chane de production de programmes traducteur s'excute alors sur une machine hte, et produit des modules objets pour une machine cible (figure 4.2).

programme source

compilateur

programme objet

programme objet machine cible

machine hte

Fig. 4.2. Traduction croise. Plus gnralement, le traducteur est lui-mme crit dans un langage d'assemblage, ou plus souvent dans un langage volu L1 ; il accepte en entre un module source crit dans un langage L qu'il traduit en un module objet crit en un langage LM. Par le biais d'un traducteur de L1 vers LM2 s'excutant sur une machine M1, on obtient un traducteur de L vers LM crit en LM2, qui peut s'excuter sur une machine M2 si le langage de M2 est LM 2. Ce traducteur de L vers LM permettra de traduire sur la machine M2 les programmes crits en L en des programmes crits en LM qui pourront s'excuter sur les machines M dont le langage est LM (figure 4.3).
L L1 LM L1 L LM 2 LM 1 M1 programme P crit en L LM 2 LM P L L LM 2 M2 LM P LM P LM M

compilateur de L vers LM crit en L1

Fig. 4.3. Reprsentation schmatique de la traduction croise. Le schma de traduction croise a un cas particulier reprsent par la figure 4.4. Le traducteur C du langage L vers le langage LM est crit dans le langage L lui-mme. On emprunte pendant quelque temps un traducteur C1 de L vers LM crit en LM. Il est donc capable de traduire C en un traducteur quivalent C', crit en LM. Les performances d'excution de C' sont directement lies aux performances du traducteur C1. On peut alors utiliser notre traducteur C' de L en LM crit en LM sur la machine M pour de nouveau traduire C en C". Cette fois, les performances d'excutions de C" sont celles que nous avons dfinies dans notre traducteur C de L en LM, qui s'est donc autocompil. En gnral C" est diffrent de C', car ils sont tous deux produits par deux traducteurs diffrents. Par contre, si on recommence l'opration en traduisant C par C", on robtiendra C". Ceci est parfois utilis des fins de contrle de bon fonctionnement de la suite des oprations.
L C L LM L C1 LM M L LM C' LM LM L C L LM L C' LM M L LM C" LM LM

compilateur C de L vers LM crit en L

Fig. 4.4. Reprsentation schmatique de l'autocompilation. Nous avons vu que, dans le cas du langage Java, il est habituel de combiner une phase de traduction de Java en bytecode et une interprtation du bytecode par une machine virtuel (simulation par
- 38 -

Traduction des langages logiciel de la machine). Ainsi tout programme java peut tre traduit en bytecode sur une machine M, envoy sur n'importe quelle autre machine M1 pour tre excut pourvu que celle-ci dispose d'un interprteur de bytecode. Cependant, pour pallier le manque de performance inhrent l'interprtation, la machine rceptrice peut galement traduire le bytecode en son langage propre et le rsultat tre excut directement sur M1. Un tel traducteur est encore appel just in time compiler (figure 4.5).
P Java Java LM programme P crit en Java M bc P bc P bc bc LM1 M1 P bc bc LM1 LM1 M1 P LM1 P LM1 M1

interprteur de bytecode

Fig. 4.5. Reprsentation schmatique du systme Java.

4.6 Conclusion
L'assembleur est un programme qui traduit un programme crit en langage d'assemblage, base de codes mnmoniques d'oprations d'une machine dans le langage binaire de cette machine. L'interprteur est un programme qui simule une machine qui comprend un langage volu. Le compilateur est un programme qui traduit un programme crit dans un langage volu dans le langage binaire d'une machine, pour que celle-ci puisse l'excuter. L'analyse lexicale consiste reconnatre dans une chane de caractres la suite des symboles du langage et en donner une codification interne. L'analyse syntaxique consiste retrouver la structure syntaxique d'une suite de symboles et vrifier sa conformit aux rgles du langage. L'analyse smantique consiste trouver une signification, indpendante de tout langage, aux actions dfinies par le programme. L'optimisation a pour but d'attnuer certaines inefficacits des l'criture en langage volu. La gnration de code consiste traduire la smantique du programme dans le langage binaire de la machine. La traduction croise consiste utiliser un traducteur qui s'excute sur une machine hte pour produire un rsultat qui s'excute sur une machine cible diffrente. En fait, tout programme qui interprte des donnes venant d'un utilisateur devrait comporter les phases d'analyse lexicale, syntaxique et smantique.

- 39 -

L'dition de liens et le chargement

Les programmes relativement complexes ne peuvent tre crits est ncessaire de pouvoir les dcouper en morceaux, chacun d'eux pouvant alors tre modifi, compil et test sparment des autres. Les morceaux doivent ensuite pouvoir tre rassembls pour former le programme complet. Nous avons appel module source un tel morceau de programme pouvant tre trait de faon indpendante par un traducteur, et module objet le rsultat de cette traduction. Nous nous intressons maintenant la reconstruction du programme complet partir des modules objets. Nous avons appel dition de liens cette opration. Elle est ralise par un programme spcifique, appel diteur de liens (en Anglais link editor). Pour prciser clairement ce dont on parle, on utilise parfois le terme module ditable ou programme ditable pour dsigner le rsultat d'une traduction qui ncessite le passage par l'dition de liens, et le terme programme excutable pour dsigner un programme complet prt tre charg et excut.

5.1. La notion de module translatable


Un module objet, lorsqu'il est inclus dans un programme excutable, occupe un certain nombre d'emplacements en mmoire. Ces emplacements doivent tre disjoints de ceux occups par les autres modules objets du mme programme. L'architecture matrielle (par exemple, Multics, iAPX432, etc...) permet parfois de conserver la modularit l'excution en attribuant des espaces mmoires disjoints chaque module. Les adresses sont alors des couples <n, d> o n dsigne l'espace attribu au module, et d un dplacement relatif dans cet espace. Dans ce cas, le traducteur est entirement matre de la gestion interne, dans cet espace, des objets appartenant au module qu'il traite, et donc des valeurs des dplacements relatifs. Par contre, dans la majorit des cas, il faut pouvoir mettre dans un espace unique plusieurs modules issus de traductions diffrentes. Les traducteurs doivent alors mettre dans les modules ditables qu'ils produisent les informations qui permettent de placer ces modules n'importe o en mmoire. En principe, il suffit qu'ils indiquent les diffrents emplacements o sont ranges des adresses internes au module. En fait, les traducteurs sparent souvent l'espace mmoire du module en plusieurs sections suivant la nature de leur contenu, comme par exemple: code des instructions, donnes constantes, donnes variables. Ces diffrentes sections, gres sparment par le traducteur peuvent tre mises n'importe o en mmoire. Les informations de placement produites par le traducteur prcisent alors pour chaque emplacement qui contient une adresse, la section laquelle cette adresse se rfre. On dit alors que le module objet est translatable. L'opration de translation consiste ajouter chacun des
- 41 -

Chane de production de programmes emplacements qui contient une adresse, la valeur de l'adresse effective d'implantation finale de la section. Considrons, comme exemple, le petit programme suivant en assembleur 68000, dont la traduction en hexadcimal est donne ct, ( droite du :) aprs l'adresse relative du premier octet dans la section ( gauche du :). Deux instructions, la deuxime et la cinquime font rfrence un emplacement mmoire: l'adresse gnre sur 4 octets a t souligne. La premire est relative l'identificateur C qui repre une instruction, dont l'emplacement est l'adresse relative 0E dans la section du code des instructions. La seconde est relative l'identificateur MEMO qui repre une donne, dont l'emplacement est l'adresse 02 dans la section des donnes variables.
AJOUT10: move.w #10,D0 0 : 30 3C 00 0A jmp C 4 : 4E F9 00 00 00 0E AJOUT16: move.w #16,D0 A : 30 3C 00 10 C: add.w D1,D0 E : D1 01 move.w D0,MEMO 10 : 33 C0 00 00 00 02 rts 16 : 2E 75 .data LOC: ds.w 1 0 : 00 00 MEMO: ds.w 1 2 : 00 00 .end informations de translation: en 6 section code, adresse 4 octets relative au code en 12 section code, adresse 4 octets relative aux donnes

Si l'diteur de liens dcide de mettre la section de code l'adresse hexadcimale 012340, et la section des donnes l'adresse hexadcimale 023220, le module doit tre modifi en consquence. A l'adresse relative 6 de la section de code, il faut ajouter l'adresse de dbut de la section de code, donc 012340, (sur 4 octets), et l'adresse relative 012 de la section de code, il faut ajouter l'adresse de dbut de la section des donnes, donc 023220. On obtient alors le code suivant, o nous laissons figurer le texte assembleur pour permettre au lecteur de comparer avec ce qui prcde.
move.w jmp AJOUT16: move.w C: add.w move.w rts .data LOC: ds.w MEMO: ds.w .end AJOUT10: #10,D0 C #16,D0 D1,D0 D0,MEMO 1 1 012340 012344 01234A 01234E 012350 012356 : : : : : : 30 4E 30 D1 33 2E 3C F9 3C 01 C0 75 00 0A 00 01 23 4E 00 10 00 02 33 22

023320 : 00 00 023322 : 00 00

5.2. La notion de lien


La construction d'un programme partir d'un ensemble de modules n'est pas simplement la juxtaposition en mmoire de l'ensemble de ces modules. Il est ncessaire d'assurer une certaine forme de coopration entre les modules, et donc qu'ils puissent communiquer. Cette communication peut se faire par variable globale, c'est--dire qu'une variable appartenant un module est accessible depuis un ou plusieurs autres modules. Elle peut se faire par appel de procdure , c'est-dire qu'une procdure ou une fonction appartenant un module est accessible depuis un ou plusieurs autres modules. On appelle lien l'objet relais, qui permet un module d'accder un objet appartenant un autre module. L'tablissement de ce lien passe par un intermdiaire, le nom du lien, permettant de le dsigner dans les deux modules. Ce nom est en gnral une chane de caractres. Nous appellerons lien satisfaire la partie du lien situe chez l'accdant, et lien utilisable la partie situe chez l'accd (figure 5.1).
[lien satisfaire] [lien utilisable] procdure module M1 - 42 lien lien [lien satisfaire] module M2 [lien utilisable] variable

Edition de liens Fig. 5.1. La notion de lien.

5.2.1. Expression de la nature du lien dans le module source


Lors de la traduction d'un module, le traducteur doit tre capable de dfinir ces deux types de liens. Par ailleurs, le traitement, par le traducteur, des objets qu'ils dsignent est diffrent, puisque un lien satisfaire correspond un objet pour lequel le traducteur ne rserve pas de place en mmoire. Certains de ces objets sont connus, a priori, du traducteur. Il s'agit, en particulier, de tous les sousprogrammes de travail lis au langage, dont le traducteur dcide d'engendrer l'appel au lieu de la squence d'instructions correspondante: conversion de type, contrle et transmission de paramtres des procdures du langage source, fonctions standards, etc... Pour ces objets, c'est le traducteur qui dcide des liens satisfaire. Quant aux objets de l'utilisateur, le traducteur doit dterminer quelle catgorie ils appartiennent: Les objets peuvent tre internes au module, et inaccessibles de l'extrieur du module. Aucun lien n'est engendrer dans le module objet. Les objets peuvent tre internes au module, et accessibles de l'extrieur du module. On dit qu'ils sont exports, ou encore publics. Le traducteur doit engendrer un lien utilisable, dont le nom est alors l'identificateur dsignant l'objet dans le module. Les objets peuvent ne pas appartenir au module, mais tre accds depuis ce module. On dit qu'ils sont imports, ou encore externes. Le traducteur doit engendrer un lien satisfaire, dont le nom est alors l'identificateur dsignant l'objet dans le module. Le langage de programmation doit prciser la faon dont le programmeur exprime cette catgorie au traducteur. S'il ne le fait pas, c'est alors au concepteur du traducteur de le prciser, mais ceci entrane une divergence entre les traducteurs diffrents du mme langage, et nuit la portabilit des programmes. La catgorie d'un objet peut tre implicite, ou partiellement implicite, comme dans le cas du FORTRAN, qui considrera, par exemple, comme sous-programme externe un objet dsign par un identificateur non dclar, et dont une occurence dans le module source est suivie du symbole "(". La catgorie peut tre dfinie explicitement, c'est--dire que les objets sont considrs normalement comme uniquement internes, sauf si le programmeur les spcifient explicitement comme exports ou imports. Ceci peut prsenter diverses formes, comme le montrent les exemples suivants, o A est import et B est export. Pascal 6.02 Multics
program P (A); (* importation de A *) var def B: integer; (* exportation de B *) procedure A (x : integer); pascal; (* dclaration du type de A *) begin ...end.

Pascal Multics, versions ultrieures


program P; $IMPORT 'A(pascal)': A$ (* importation de A $EXPORT B$ (* exportation de B var B: integer; (* dclaration de B procedure A(x: integer); external; (* dclaration du type de begin ...end. *) *) *) A *)

Pascal Micromga
program P; var B: integer; (* exportation implicite *) procedure A(x: integer); external;(*dclaration et importation *) begin ...end.

Certains langages rcents orients vers la modularit sparent le module source en deux parties, la partie dfinissant les exportations, et celle dfinissant l'implantation du module. Ainsi, en langage Ada, la partie spcification contient une liste de dclaration de types, d'objets ou de procdures qui appartiennent au module, et sont exports par ce module, alors que la partie corps renferme l'implantation du module, et ce qui lui est propre. L'importation se fait en nommant dans une clause particulire situe devant le module, la liste des modules dont on dsire importer des objets. L'exemple ci-dessus se dcrirait de la faon suivante:
- 43 -

Chane de production de programmes


package E is procedure A (x : integer); -- procdure du module exporte end E; package P is B : integer; -- exportation de B end P; with E; -- importation des objets du module E package body P is -- contenu de P end P;

5.2.2. Reprsentation des liens dans le module objet


La reprsentation d'un lien utilisable dans un module objet ne pose gure de problmes. Il s'agit d'un couple <nom, valeur>, o la valeur dfinit d'une part la section contenant l'objet, d'autre part l'adresse relative de l'objet dans la section. Lorsqu'on connait l'adresse effective d'implantation de cette section, il est ainsi possible de calculer la valeur finale du lien. En reprenant l'exemple du module assembleur, et en supposant que AJOUT10 et AJOUT16 sont dclars publics, l'assembleur fournira les informations suivantes:
AJOUT10 AJOUT16 00 0A relative au code relative au code

Ceci permettra l'diteur de liens de calculer les adresses finales suivantes:


AJOUT10 AJOUT16 012340 01234A

La reprsentation d'un lien satisfaire dans un module objet peut prsenter diverses formes suivant les systmes, dont voici quelques exemples: 1) C'est un couple <nom, liste> qui associe au nom du lien la liste des emplacements du module qui font rfrence au lien (nous notons contenu[j] le contenu de l'emplacement d'adresse j du module). Cette liste peut tre obtenue par chanage de ces emplacements entre eux, liste tant alors l'adresse du premier emplacement, et chacun d'eux contenant l'adresse du suivant. L'tablissement des liaisons est alors obtenu par l'algorithme suivant:
procdure relier (liste, valeur); dbut tant que liste <> nil faire x := contenu [liste]; { x repre le suivant de la liste } contenu [liste] := valeur; { on tablit le lien } liste := x; fait; fin;

Cette liste peut tre un tableau des adresses des emplacements. L'tablissement des liaisons est alors obtenu par l'algorithme suivant:
procdure relier (liste, n, valeur); dbut pour i de 1 n faire contenu [liste [i]] := contenu [liste [i]] + valeur; fait; fin;

Contrairement la deuxime reprsentation, la premire ne permet pas de modifier statiquement le lien, comme, par exemple, dans A + 5. 2) C'est un couple <nom, numro>, qui dfinit le numro sous lequel est rfrenc dans le module ce lien satisfaire. Les rfrences au lien sont alors transcrites dans le module objet sous forme d'informations de translation: ajouter l'emplacement e, la valeur du lien n.

5.3. Fonctionnement de l'diteur de liens


L'dition de liens peut se faire parfois de faon dynamique (Multics). Dans ce cas, le module correspondant au programme principal est lanc par l'utilisateur, sous sa forme objet ditable.
- 44 -

Edition de liens Lorsque ce module accde un lien satisfaire, le systme (matriel et logiciel) appelle alors automatiquement l'diteur de liens pour trouver le module contenant ce lien en tant que lien utilisable, et tablir la liaison. Peu de systmes offrent cependant cette possibilit. Dans tous les autres cas, l'dition de liens est faite de faon statique par appel de l'diteur de liens (ou relieur, ou linker), en fournissant en paramtres la liste des modules relier, L = (M1, M2, ... , Mn ).

5.3.1. dition simple de la liste L


L'dition de liens d'un ensemble fixe de modules donns par une liste L peut se faire en trois tapes. Les deux premires tapes sont parfois fusionnes. tape 1: Construction de la table des adresses d'implantation des sections des diffrents modules, par acquisition de leur taille depuis les modules objets, et placement de ces sections les unes derrire les autres. En gnral ce placement tient compte de la nature des sections, c'est--dire regroupe ensemble les sections de mme nature, ce qui permettra, l'excution, de protger diffremment ces sections, et donc d'en limiter les accs. Par exemple: nature oprations autorises code instruction excution donnes constantes lecture donnes variables lecture, criture tape 2: Construction de la table des liens utilisables. Cette table associe aux noms des liens l'adresse effective en mmoire de l'objet que le lien dsigne. Cette adresse est obtenue par transformation de l'adresse relative dans sa section, fournie par le module objet. tape 3: Construction du programme final lui-mme. Chaque module est translat, en tenant compte des informations de translation du module objet. Les noms des liens satisfaire sont recherchs dans la table des liens utilisables. S'ils y sont trouvs, les emplacements du module, qui se rfrent ce lien satisfaire, sont modifis conformment la valeur associe au lien dans la table. Si un lien satisfaire n'est pas trouv dans la table, il reste indfini dans le programme (ou non rsolu , ou unresolved), et un message d'anomalie est alors imprim par l'diteur de liens. Ceci ne veut pas dire que le programme ne peut s'excuter, car une excution particulire peut ne pas accder ce lien, par exemple, en phase de mise au point partielle. videmment un programme oprationnel ne devrait plus contenir de liens indfinis.

5.3.2. Construction de la table des liens


Posons LUM l'ensemble des noms des liens utilisables d'un module M, et LASM l'ensemble des noms des liens satisfaire du module M. Remarquons d'abord que les ensembles LUM devraient tre deux deux disjoints pour les modules d'une mme liste, dont on veut faire l'dition de liens. Si ce n'est pas le cas, un mme lien possde plusieurs dfinitions, parmi lesquelles l'diteur de liens fera, en gnral, un choix, qui ne sera pas forcment le bon; il signalera cette anomalie. Les dfinitions multiples peuvent se dcrire par l'ensemble suivant:
Mi , M j L , Mi M j

( LU

Mi

LU M j

Par ailleurs, nous avons vu que certains liens satisfaire pouvaient ne pas tre trouvs. Nous pouvons dfinir, pour une liste de modules L : LASL = LASM LU M
M L M L

La deuxime tape de l'dition de liens peut tre modifie pour permettre la connaissance de LASL ds la fin de cette tape, et avant d'entamer la troisime tape. Il suffit, pour cela, de remplacer la table des liens utilisables par une table plus gnrale, dite table des liens (figure 5.2), qui associe chaque nom de lien: l'tat du lien considr comme utilisable, satisfaire ou non rsolu,
- 45 -

Chane de production de programmes la valeur du lien, qui n'a de signification que lorsque le lien est dans l'tat utilisable. nom tat valeur A _satisfaire B utilisable 3281 Fig. 5.2. Exemple du contenu de la table des liens aprs traitement du module donn en 5.2.1. La construction de la table des liens peut alors tre obtenue en parcourant les modules de la liste, et en effectuant pour chacun d'eux l'algorithme de la figure 5.3. Cet algorithme lui-mme met dans la table des liens les noms de tous les liens rencontrs dans ces modules, en tenant compte de leur tat. En particulier, tous les noms qui correspondent un lien utilisable dans un module de la liste, sont dans la table avec l'tat utilisable, la fin de l'tape. De mme, tous les noms qui correspondent un lien satisfaire dans un des modules de la liste, sont dans la table avec l'tat _satisfaire si aucun des modules de la liste ne contient de lien utilisable de mme nom. Aprs avoir excut l'algorithme de la figure 5.3 sur tous les modules de la liste, on a: LASL = { n | n table tat (n) = _satisfaire }
procdure lire_les_liens_du_module; dbut pour tous les liens du module faire soit n son nom, recherche de n dans la table si n a t trouv alors si n LUM alors si tat (n) = utilisable alors double_dfinition (n) sinon tat (n) := utilisable; valeur (n) := sa_valeur; finsi; finsi { s'il est lien satisfaire dans le module, et dja dans la table, on ne fait rien } sinon ajouter n dans la table; si n LUM alors tat(n) := utilisable; valeur(n) := sa_valeur; sinon tat (n) := _satisfaire; finsi; finsi; fait; fin;

Fig. 5.3. Procdure de lecture des liens d'un module et de construction de la table des liens.

5.3.3. Notion de bibliothque


La notion de bibliothque de modules objets a pour but de complter la liste L avec des modules provenant de la bibliothque, et qui, par les liens utilisables qu'ils contiennent, permettraient de satisfaire les liens de LASL. On peut distinguer trois fonctions qui justifient le regroupement de modules objets dans une bibliothque: La bibliothque de calcul contient des sous-programmes standards tout faits, tels que sinus, cosinus, racine_carre, etc... On peut y adjoindre galement les sous-programmes de travail lis un langage, dont nous avons dj parl, et dont le traducteur gnre l'appel au lieu de la squence d'instruction correspondante. La bibliothque d'interface systme contient les sous-programmes qui excutent les appels systmes. Si un tel appel peut paratre quivalent un appel de sous-programme, nous avons vu dans le chapitre 2 deux raisons militent pour les traiter diffremment. La premire est le besoin ventuel de faire passer le processeur en mode matre et lui permettre de disposer du jeu complet d'instructions. La deuxime est qu'un contrle doit tre effectu au moment de l'appel, et il ne faut pas qu'un programmeur mal intentionn puisse contourner ce contrle, or la connaissance de l'adresse A de la fonction dans le systme permettrait au programmeur de faire un appel au sous programme en A+5 par exemple. Notons que, par ailleurs, si les programmes excutables sont relis directement par l'diteur de liens avec les sous-programmes du systme, un changement de systme ncessiterait de refaire l'dition de liens de tous les programmes excutables de l'installation. Aussi, comme nous l'avons dj dit, un appel systme est en gnral ralis par une instruction particulire de la machine (par exemple, SVC pour supervisor call sur IBM370, ou
- 46 -

Edition de liens INT pour interrupt sur MS-DOS). Ces instructions droutent le processeur vers un emplacement de mmoire connu du matriel, o se fera le contrle et la redirection vers les instructions du systme qui ralisent la fonction demande. Par ailleurs, le passage des paramtres se fait souvent en utilisant les registres du processeur et non en utilisant une pile comme le font beaucoup d'implantations des langages de programmation. Les sous-programmes de la bibliothque d'interface systme ont pour but de prparer les paramtres et d'excuter l'instruction d'appel, en vitant ainsi aux traducteurs d'tre trop dpendants du systme. La bibliothque de l'utilisateur contient les sous-programmes crits par un utilisateur ou un groupe d'utilisateurs pour les besoins courants de leurs applications. videmment il peut en exister plusieurs qui satisfont des besoins spcifiques. Une telle bibliothque est, en gnral, une structure de donnes constitue, au minimum de la collection des modules objets qu'elle contient, et ventuellement d'une table dont les entres sont les noms des liens utilisables de ces modules, et qui associe chacune de ces entres le module qui le contient comme lien utilisable. Cette table permet d'viter de devoir parcourir l'ensemble des modules de la bibliothque pour savoir celui qui contient un lien utilisable de nom donn (figure 5.4).
nom alpha bta gamma delta epsilon module module M LU M = { alpha, bta, gamma } module M' LU M' = { delta, epsilon }

Fig. 5.4. Exemple de structure de bibliothque de modules objets. En gnral, les ensembles des liens utilisables des modules situs dans une mme bibliothque B sont deux deux disjoints, c'est--dire que: M, M' B, LUM LUM ' = ce qui garantit l'unicit du module associ une entre de la table. Par contre, une dition de liens particulire peut demander l'utilisation de plusieurs bibliothques, dont les ensembles de liens utilisables ne sont pas forcment disjoints. Les bibliothques doivent alors tre fournies dans l'ordre o l'on dsire que l'diteur fasse la recherche. Ainsi en UNIX, la demande d'dition de liens suivante:
ld A.o B.o C.o -lpc -lm -lc

est interprte comme l'dition de liens, tout d'abord, de la liste des trois modules A.o, B.o et C.o, et qui peut tre complte par des modules recherchs dans les bibliothques pc, m ou c, dans cet ordre.

5.3.4. Adjonction de modules de bibliothques


Plus gnralement, considrons l'dition de liens d'une liste L avec les bibliothques B1, B2, ..., Bp. L'diteur de liens commence par construire la table des liens partir de la liste L. Il doit ensuite chercher tendre cette liste initiale pour y ajouter des modules provenant des bibliothques, et qui permettent de satisfaire des liens qui ne le sont pas encore. Chaque fois qu'il trouve un tel module, il l'ajoute la liste L, et excute l'algorithme de lecture de ses liens prsent plus haut. Pour viter de rechercher indfiniment un lien satisfaire qui n'existe, comme lien utilisable, dans aucun module de bibliothques, on se sert de l'tat inexistant. Nous utiliserons les notations suivantes: LAS = { n | n table tat (n) = _satisfaire } LU = { n | n table tat (n) = utilisable } LIN = { n | n table tat (n) = inexistant }
- 47 -

Chane de production de programmes Deux mthodes peuvent tre utilises par l'diteur de liens. Ces deux mthodes peuvent ne pas donner le mme rsultat. i) Chaque lien est recherch successivement dans les bibliothques. On obtient l'algorithme de la figure 5.5. On notera qu' la fin du traitement, on a: LIN = LASL LU M
M L, Bi tant que LAS faire soit n LAS i := 1; tant que tat (n) = _satisfaire faire si n est une entre dans la table de Bi alors soit M le module qui lui est associ ajouter M L lire_les_liens_du_module (M) sinon si i < p alors i := i + 1 sinon tat (n) := inexistant finsi finsi fait fait

Fig. 5.5. Premire mthode de recherche en bibliothque. En d'autres termes, si un lien est inexistant la fin du traitement, c'est qu'il n'existe effectivement comme lien utilisable dans aucun module de l'une des bibliothques. ii) La recherche est effectue pour tous les liens en parcourant les bibliothques successives. C'est la mthode utilise habituellement dans l'diteur de liens de UNIX. L'algorithme est donn en figure 5.6. On notera que dans ce cas, il est possible qu' la fin du traitement on ait: LASL LU M M Bi Il suffit qu'un tel lien satisfaire soit introduit par un module M provenant d'une bibliothque Bi , et qu'il soit lien utilisable dans M' appartenant Bj , avec j<i, sans l'tre dans aucun M" appartenant Bk , avec ik.
pour i de 1 p faire tant que LAS faire soit n LAS si n est une entre dans la table de Bi alors soit M le module qui lui est associ ajouter M L lire_les_liens_du_module (M) sinon tat (n) := inexistant finsi fait tant que LIN faire { prparer pour la bibliothque suivante } soit n LIN tat (n) := _satisfaire fait fait

Fig. 5.6. Deuxime mthode de recherche en bibliothque. L'intrt de cette deuxime mthode est de permettre de prendre en compte des bibliothques non structures, qui sont simplement une suite de modules (sans table), par simple parcours de cette suite. Il est vident que l'ordre dans lequel les modules sont placs dans cette suite est important. Si un module M d'une bibliothque contient un lien satisfaire qui est lien utilisable d'un module M' de la mme bibliothque, il faut que le module M prcde le module M' pour que la slection de M entrane celle de M'.

- 48 -

Edition de liens Il va sans dire que, lorsque l'algorithme d'adjonction de modules de bibliothques est termin, l'diteur de liens excute l'tape 3 de construction du programme excutable final, en utilisant la liste L ainsi augmente par la recherche des modules provenant de bibliothques.

5.3.5. Edition de liens dynamique


Certains systmes offrent la possibilit de retarder l'dition de liens, soit jusqu'au moment du chargement du programme, soit jusqu'au moment o la liaison est utilise au moment de l'excution. Ceci peut se faire soit module par module (c'est la mthode par dfaut utilise dans Multics en 1970), soit au niveau global d'une bibliothque complte (c'est la mthode utilise par windows 95). Une des mthodes utilises consiste remplacer les modules ainsi relis par un module particulier, que nous appelons module relais, qui va servir d'intermdiaire aux liaisons. Ce module est en fait une table o chaque entre est un relais vers un lien utilisable de l'un des modules effectifs et tient lieu de lien utilisable pour l'dition de lien statique. Lors du chargement effectif des modules correspondants, les entres de cette table assureront le relais vers le lien effectif du module. La figure 5.7 montre la liaison entre un lien satisfaire du module M1 vers un lien utilisable du module M2, par l'intermdiaire du module relais. L'diteur de lien ne se proccupe que du lien entre le module M1 et le module relais, l'tablissement du lien dynamique tant report un instant ultrieur (chargement ou excution).
[lien satisfaire] lien module M1 [lien utilisable] lien [vrai lien utilisable] dynamique procdure module M2

module relais

Fig. 5.7. Liaison dynamique.

5.4. Notion de recouvrement


Lorsqu'on construit un programme de grande taille, il est possible que la mmoire centrale relle dont on dispose soit insuffisante. Certains systmes rsolvent ce problme en offrant une mmoire virtuelle de grande taille (par exemple 2 Go), et se chargent de ne mettre en mmoire relle, un instant donn, qu'une partie du programme et des donnes, celle qui est ncessaire son excution cet instant. D'autres systmes n'offrent pas cette possibilit qui ncessite des dispositifs matriels. Dans ce cas, l'diteur de liens propose souvent une solution par le biais de ce que l'on appelle le recouvrement (en Anglais overlay). La mmoire virtuelle entrane, sans doute, la disparition de cette notion dans un avenir proche. Le principe de base reste cependant, mme si l'utilisateur ne s'en aperoit pas: un instant donn, un programme n'utilise qu'une petite partie du code et des donnes qui le constituent. Les parties qui ne sont pas utiles en mme temps peuvent donc se recouvrir, c'est--dire occuper le mme emplacement en mmoire relle. Dans le cas de la mmoire virtuelle, ce recouvrement sera assur dynamiquement par le systme, au fur et mesure de l'excution du programme. S'il n'y a pas de mmoire virtuelle, l'utilisateur doit assurer lui-mme un dcoupage de son programme, indiquer ce dcoupage l'diteur de liens et prciser les parties qui peuvent se recouvrir, et prvoir explicitement dans son programme des oprations de chargement de ces parties lorsqu'elles sont ncessaires. L'diteur de liens tiendra compte de ces informations lors de la dfinition des adresses d'implantations des diffrents modules du programme. En gnral, le dcoupage et le recouvrement sont indiqus sous la forme d'un arbre, dont la figure 5.8 est un exemple. L'diteur de liens dduira de cet arbre que, entre autre, les modules E et H peuvent tre implants au mme endroit, de mme que les modules C, J et Q.
C A B J Q D K R E H L S F I M P T N O G

- 49 -

Chane de production de programmes Fig. 5.8. Exemple d'arbre de recouvrement.

5.5. Les rfrences croises


L'diteur de liens, au cours de son travail, dispose de certaines informations qui peuvent tre intressantes pour le programmeur (en dehors des anomalies rencontres). La carte d'implantation des modules peut aider l'utilisateur dans la mise au point ou la maintenance du programme, lorsqu'une erreur est dtecte l'excution une adresse donne. Nous verrons, cependant, que les metteurs au point peuvent apporter une aide plus intressante de ce point de vue. Notons, pour le moment, qu'ils exploiteront cette carte d'implantation si l'diteur de liens la leur fournit dans le programme excutable. Au cours du travail, l'diteur de liens associe les liens satisfaire d'un module aux liens utilisables des autres modules. Il peut tre intressant qu'il fournisse cette information l'utilisateur. Il s'agit alors d'indiquer cet utilisateur, pour chaque lien utilisable, la liste des modules (et ventuellement les emplacements l'intrieur de ces modules) qui ont ce lien comme lien satisfaire. En d'autres termes, on peut ainsi savoir qui utilise quoi. C'est ce que l'on appelle les rfrences croises. Ces rfrences croises peuvent tre obtenues en sous-produit de l'dition de liens. Il est aussi possible de raliser un programme spcifique pour cela, dont le fonctionnement sera assez voisin de l'diteur de liens, du point de vue de la gestion de la table des liens. videmment, un tel outil est alors plus simple, puisqu'il n'a pas construire le programme excutable. Il offre aussi l'avantage de pouvoir tre appliqu sur un ensemble de modules qui ne constituent pas un programme complet, sans avoir de messages d'erreurs inutiles. Voici un exemple d'dition de telles rfrences croises: lien module o il est "utilisable" modules et emplacements o il est " satisfaire" alpha M1 M2(10, 50, 86), M3(26) bta M2 M1(104), M4(34) gamma M3 M4(246, 642) delta M3 M5(68, 94), M6(4), M7(456, 682, 624) L'intrt de disposer de ces rferences croises est multiple, suivant que l'on regarde les variables ou les sous-programmes, et que l'on se place du point de vue de la mise au point ou de la maintenance des applications. Par exemple, si un identificateur export par un module dsigne une variable, on peut ainsi savoir la liste des modules qui accdent directement cette variable. Outre l'aspect contrle ainsi obtenu, cela permet, en phase de mise au point, si la valeur n'est pas conforme ce qu'elle devrait tre, de savoir quels sont les modules qui peuvent tre en cause. Cela permet galement, en phase de maintenance, si on change l'interprtation du contenu de cette variable, de savoir quels sont les modules qui sont concerns par ce changement. De mme, si un identificateur export par un module dsigne un sous-programme, on peut connatre la liste des modules o se trouvent les appels de ce sous-programme. En phase de mise au point d'une application, lorsque l'on constate que les variables permanentes internes au module ne sont pas conformes, il faut dterminer quels sont les appels prcdents qui ont conduit cette non-conformit. On peut alors savoir quels sont les modules qui peuvent tre en cause. En phase de maintenance, en cas de changement de la spcification ou du fonctionnement de ce sous-programme, on peut savoir quels sont les modules qui sont concerns par ce changement. Enfin, la connaissance des relations entre les modules que l'on peut ainsi obtenir, peut permettre d'amliorer le dcoupage de ces modules en regroupant ensemble les parties de module ou les modules entiers qui ont de fortes interactions. Ces relations peuvent tre galement utiles pour faciliter la construction des bibliothques de modules lorsque l'ordre des modules a de l'importance pour l'diteur de liens.

5.6. Le chargement
Plusieurs raisons militent pour que le rsultat de l'dition de lien ne soit pas le programme install quelque part en mmoire centrale prt tre excut. La premire est que cela limiterait
- 50 -

Edition de liens arbitrairement la taille des programmes, puisqu'elle ne pourrait atteindre que l'espace total moins l'espace occup par l'diteur de liens lui-mme. La deuxime raison est que l'dition de liens consomme du temps machine, et qu'il n'est pas conomique de la refaire chaque fois que l'on dsire faire excuter le programme lui-mme. Il s'ensuit que l'diteur de liens produit plutt un fichier contenant le programme excutable. Pour excuter un programme, il faut donc prendre sa version excutable, et la mettre en mmoire (relle ou virtuelle). On appelle chargement cette opration, et chargeur le programme qui l'effectue. Cette opration pourrait consister en une simple lecture du contenu du fichier dans un emplacement mmoire fix a priori par l'diteur de liens. Cette mthode est simple, mais restrictive, puisqu'il faut dcider de l'endroit dfinitif en mmoire o le programme s'excutera au moment o l'dition de liens est faite. Elle n'est souvent utilise que pour les programmes autonomes (stand alone), car elle permet d'avoir des programmes d'amorage trs simples. Il est facile de concevoir que, puisque l'diteur de liens a dispos des informations qui lui ont permis de translater les modules, il laisse ces informations dans le fichier qui contient le programme excutable. Le chargeur peut alors les utiliser pour translater le programme complet, et le mettre ainsi n'importe o en mmoire. Il est vident que les informations de translations provenant des modules doivent tre modifies lgrement pour tre maintenant relatives au programme. En gnral, l'diteur de liens fournira galement la taille mmoire centrale totale ncessaire l'excution du programme, qu'il dduira des tailles de l'ensemble des modules qui le composent. Enfin, une dernire information minimale est ncessaire au chargeur pour terminer le travail, et lancer l'excution du programme, c'est l'adresse de lancement, ou l'adresse de l'emplacement o se trouve la premire instruction excuter. Pour l'utilisateur, c'est la premire instruction d'un module particulier, qu'est son programme principal . Pour les langages volus, le compilateur est mme de dterminer si un module est ou non un programme principal, et si oui quelle est l'adresse dans le module objet de la premire instruction excuter. Pour le langage d'assemblage, cette information est, en gnral, prcise explicitement par le programmeur l'assembleur. Les traducteurs doivent donc informer l'diteur de liens de l'adresse de lancement ventuelle du module. Comme l'diteur de liens est en prsence de plusieurs modules, il ne devrait trouver qu'un et un seul module contenant une telle adresse de lancement, qu'il peut alors transmettre au chargeur, aprs ventuelle modification pour la rendre relative au programme et non plus au module dont elle provient. Par ailleurs, le programme excutable a t conu pour tre excut dans un certain environnement. S'il est prvu pour fonctionner en autonome, son environnement est alors simplement la machine nue. S'il est prvu pour fonctionner sur un systme particulier, il peut tre ncessaire d'tablir les liaisons avec ce systme. Nous avons dj mentionn l'existence de bibliothque d'interface systme qui peut rsoudre compltement ces liaisons. Nous avons galement mentionn (5.3.5) que certains systmes prvoient de retarder les liaisons effectives avec certains sous-programmes standards, ce qui permet en particulier de les partager entre l'ensemble des programmes prsents en mmoire, de faon conomiser de la place (VMS ou Windows NT par exemple). Le chargeur doit alors remplir la table contenue dans le module relais avec les adresses effectives actuelles de ces sous-programmes. On peut considrer que le programme en mmoire est prvu pour s'excuter sur une machine abstraite, et que le chargeur doit non seulement mettre le programme en mmoire, mais aussi prparer la machine abstraite ncessaire son excution.

5.7. Conclusion
La translation d'un module consiste modifier son contenu pour qu'il puisse s'excuter un endroit diffrent de celui pour lequel il tait prvu initialement. Un lien est l'information qui permet un module d'accder un objet appartenant un autre module. Il est dsign par un nom. On appelle lien satisfaire la partie du lien situe chez l'accdant, et lien utilisable celle situe chez l'accd. L'expression de la nature d'un lien dpend du langage de programmation et du traducteur. Elle peut prendre des formes varies.

- 51 -

Chane de production de programmes L'dition de liens se fait en deux phases. La premire construit la table de l'ensembles des liens trouvs dans les modules relier. La seconde construit le programme excutable en translatant les modules et en remplaant les liens satisfaire par la valeur du lien utilisable correspondant. Entre les deux phases, l'diteur de liens peut complter la liste des modules relier avec des modules provenant de bibliothques, en tenant compte des liens restant satisfaire. Une bibliothque peut tre une simple collection de modules parcourue squentiellement par l'diteur de liens, mais l'ordre des modules est important. Elle peut tre structure de faon savoir rapidement quel module, s'il existe, contient un lien donn comme lien utilisable. Une bibliothque regroupe en gnral des modules de fonctionnalit voisine. On peut avoir, par exemple, une bibliothque de calcul, une bibliothque d'interface systme, et des bibliothques spcifiques aux utilisateurs. Le recouvrement est une technique qui permet de diminuer l'encombrement total en mmoire centrale d'un programme, en dcidant que des parties du programme peuvent se trouver au mme endroit, car elles ne sont pas utiles au mme moment pour la bonne excution du programme. L'dition des rfrences croises consiste diter une table qui, pour chaque lien trouv dans une liste de module, donne le module dans lequel il est utilisable, et ceux dans lesquels il est satisfaire. Elle peut tre obtenue en sous-produit de l'dition de liens, ou par un outil spcifique. Elle est utile pour la mise au point et pour la maintenance. Le chargement est l'opration qui consiste mettre en mmoire centrale un programme excutable, avec une ventuelle translation, et en lancer l'excution. Il consiste galement construire la machine abstraite demande par le programme.

- 52 -

Autres outils de la chane de production

Nous allons tudier ici quelques uns des autres outils qui participent la chane de production des programmes. Ils ne sont pas aussi indispensables que les traducteurs, l'diteur de liens ou le chargeur, mais ils facilitent grandement le travail du programmeur lorsqu'ils sont disponibles. Leur prsence sur un systme particulier dpend du bon vouloir du constructeur de la machine, ou plus souvent, de la reconnaissance de leur intrt en fonction des applications.

6.1. Les outils d'aide la mise au point


6.1.1. La notion de trace
La mise au point d'un programme est en gnral une tche difficile, et diverses mthodes ont t proposes pour aider le programmeur dans cette tche. La premire, et la plus simple, a t de lui permettre de suivre l'volution de l'tat du programme au cours du temps, c'est ce que l'on, appelle la trace du programme. Pratiquement, il n'est pas possible de suivre cette volution sur l'tat complet du programme. Il est ncessaire de restreindre ce suivi sur une petite partie de cet tat. Les principales informations utiles sont les suivantes: tracer les appels de sous-programmes avec les paramtres correspondants, et leurs retours avec la valeur du rsultat, tracer le droulement des instructions, en particulier pour reconnatre les ruptures de squences, tracer les valeurs prises successivement par des variables, connatre l'tat des donnes en certains points prcis du programme. L'obtention de ces traces peut tre dfinie en introduisant dans les modules sources des instructions spciales qui sont ou non prises en compte par le traducteur en fonction d'options dcides lors de la demande de traduction. C'est alors le traducteur qui insre dans le module objet des instructions, en gnral d'impression, qui permettent de suivre le droulement de l'excution. La difficult essentielle de cette mthode est qu'il faut prvoir ces options au moment de la traduction du module. Il est possible que lors de l'analyse du rsultat de l'excution, il soit ncessaire de connatre d'autres informations pour dterminer l'erreur. Il faut alors refaire la traduction du module en adaptant les options de mise au point en consquence. Pour viter cela, la tendance est de prendre le maximum d'options, mais alors il faut dpouiller une quantit importante d'informations pour trouver celles qui sont effectivement utiles. L'introduction des instructions de trace par l'diteur de liens lui-mme, ou par le chargeur, a t trs peu utilise, car ce n'est pas d'un emploi commode.

- 53 -

Chane de production de programmes

6.1.2. La notion de point d'arrt, de reprise et de pas pas


L'inconvnient majeur des options de traces traites par le traducteur est le manque de souplesse pendant l'excution. Lors de la recherche d'une erreur, il est souvent ncessaire de disposer de beaucoup d'informations sur l'volution de l'tat du programme au voisinage de l'endroit o se produit cette erreur. Pour faciliter le suivi de cette volution, il suffit de pouvoir arrter temporairement cette excution, pour permettre l'observation de l'tat complet du programme. Ceci est obtenu par le biais de points d'arrt, qui sont des adresses d'emplacements particuliers du programme o on dsire que l'excution soit interrompue, avant que l'une des instructions situes ces emplacements ne soit excute. Lorsqu'un programme est ainsi interrompu en un point d'arrt, le programmeur doit avoir le moyen de consulter l'tat du programme, en regardant le contenu de l'espace mmoire qu'il occupe. Il doit pouvoir ventuellement modifier ( ses risques et prils) le contenu de cet espace mmoire, pour en corriger certaines valeurs. Il doit pouvoir galement en reprendre l'excution, ce que l'on appelle la reprise. On appelle metteur au point ou dbogueur (en Anglais debugger) un outil interactif qui permet de crer des points d'arrt dans un programme pour en consulter ou modifier le contenu mmoire et en reprendre ensuite l'excution. Le pas pas est un cas particulier du couple <point d'arrt, reprise>, puisqu'il s'agit, sur un programme interrompu, d'en reprendre l'excution pour une instruction avant de l'arrter de nouveau. Ce pas pas peut tre au niveau machine, c'est--dire que la reprise n'a lieu que pour excuter une seule instruction de la machine. Pour un programmeur en langage volu, ceci n'est gure agrable, car il n'a souvent que peu de connaissance des relations entre les instructions de la machine et les instructions en langage volu. C'est pourquoi, on lui prfre le pas pas au niveau langage volu. Cependant, il faut alors que le metteur au point ait une connaissance du dcoupage de la suite des instructions machines en instructions en langage volu.

6.1.3. Les metteurs au point symboliques


La dfinition d'un point d'arrt doit localiser un emplacement particulier de l'espace mmoire du programme. La consultation de l'tat du programme demande galement de localiser les emplacements dont on veut connatre ou modifier la valeur. Cette localisation peut videmment tre donne par une valeur numrique dans une base adapte, octal, dcimal, hexadcimal, etc... Cela demande au programmeur de connatre ces valeurs numriques. Ce sont en fait des valeurs connues de faon disperse par les traducteurs, l'diteur de liens et le chargeur. Pour le programmeur, elles correspondent des identificateurs de ses modules sources. Une coopration entre l'ensemble permet d'exprimer ces adresses par les identificateurs eux-mmes. C'est ce que l'on appelle un metteur au point symbolique. Pour permettre cette localisation, le traducteur doit tout d'abord complter le module objet qu'il produit par une table de symboles, qui associe aux identificateurs internes aux modules (en plus des liens) les adresses relatives des emplacements attribus aux objets correspondants. Cette table a la mme signification que les liens utilisables du module. L'diteur de liens n'utilise pas cette table, si ce n'est pour translater les adresses pour les rendre relatives au programme excutable et non plus au module objet. Cette table associe galement chaque identificateur des informations sur le type de l'objet, pour permettre au metteur au point d'diter (ou saisir) les valeurs des objets conformment leur type. Cela permet aussi d'accder aux champs d'une structure par la notation pointe habituelle aux langages de haut niveau. Le traducteur produit enfin une deuxime table qui associe aux numros de lignes contenant des instructions du langage de haut niveau, l'adresse relative de la premire instruction en langage machine correspondant. Aprs translation des valeurs de cette table par l'diteur de liens, il sera ainsi possible de dfinir les points d'arrt ou le pas pas en terme d'instructions de haut niveau, clairement identifies par le programmeur. Le traducteur, puis l'diteur de liens, mettra les informations ncessaires l'identification du module source. Le metteur au point pourra ainsi lister les lignes du texte source la demande de l'utilisateur, lui permettant de contrler effectivement o il en est dans le programme.

- 54 -

Autres outils Disposant de toutes ces informations dans le fichier du programme excutable, le metteur au point peut offrir les oprations suivantes l'utilisateur: 1. Possibilits de trace. Il est possible de mettre en route ou d'arrter tout instant des options de trace comme indiques ci-dessus. 2. Consultation et modification des variables du programme. Ceci permet ventuellement de corriger des valeurs erronnes et poursuivre la mise au point sans tre oblig de corriger le texte source et le recompiler. 3. Cration et suppression de points d'arrt. On peut ainsi lancer des parties d'excution longues et s'arrter aux endroits o l'on dsire effectuer des contrles plus prcis. 4. Excution en pas pas. Elle permet de contrler plus finement le comportement du programme certains endroits. 5. Consultation des appels de procdure en cours. Lorsqu'un programme est interrompu, on peut ainsi savoir si on est dans le programme principal ou dans une procdure, et dans ce dernier cas, quels sont les appels imbriqus depuis le programme principal qui ont conduit la procdure courante. 6. Lister le fichier source. En particulier on peut ainsi savoir quelles sont les instructions de haut niveau qui seront excutes la reprise. 7. diter le texte source. Le metteur au point peut permettre de faire appel l'diteur de texte pour porter des corrections au fur et mesure dans les modules sources, et poursuivre ensuite la mise au point. videmment, ceci ne modifie pas le programme excutable, les modules ainsi modifis devant tre recompils, et l'dition de liens refaite, mais permet d'avoir un aide-mmoire des corrections apporter. Les metteurs au point offrent toujours au moins les quatre premires oprations. S'ils sont simples (on dira parfois qu'ils sont binaires), ils ne connaissent que l'organisation de la machine physique, et ne prennent pas en compte le langage d'criture des modules qui constituent le programme. ventuellement ils sont dots d'un dsassembleur qui permet de lister les instructions de la machine sous forme mnmonique. Ils peuvent aussi exploiter une table des symboles dans le programme excutable, vitant l'utilisateur de devoir dfinir des adresses uniquement sous forme numrique. Les metteurs au point symboliques par contre exploitent un minimum d'informations provenant du langage de haut niveau utilis pour crire les modules. C'est pourquoi, ils peuvent prendre en compte les structures principales de ces langages pour les quatre premires fonctions et fournir les trois fonctions supplmentaires.

6.1.4. Les metteurs au point symboliques multi-fentres


Lorsqu'on dispose d'un systme multi-fentres, permettant de dcouper l'cran en plusieurs zones distinctes, les metteurs au point symboliques peuvent en tenir compte pour faciliter le travail de l'utilisateur. Trois fentres sont alors le plus souvent utilises: fentre des variables, o le metteur au point affiche les valeurs des variables dont la consultation ou la trace sont demandes, fentre de commandes, qui sert l'change des commandes de l'utilisateur au metteur au point, fentre de source, o le metteur au point affiche en permanence les quelques lignes du module source qui entourent le point d'arrt sur lequel on est. La manipulation du metteur au point par l'utilisateur en est alors grandement facilite, puisque certaines commandes sont implicites et qu'il a devant les yeux les informations essentielles pour cette mise au point.

6.1.5. Les mesures de comportement dynamique


Certains systmes offrent la possibilit de faire des mesures sur le comportement dynamique d'un programme l'excution. En gnral, deux types de mesures sont possibles: compter le nombre de fois o chaque instruction ou suite d'instructions est excute, mesurer le temps pass, l'excution, dans chaque instruction ou suite d'instructions du programme.
- 55 -

Chane de production de programmes Ces mesures peuvent tre effectues sur la totalit du programme, ou sur certains modules spcifiques. Elles sont obtenues, au moyen d'une option de traduction, qui demande au traducteur d'introduire des instructions aux endroits judicieux du programme. Par exemple, l'incrmentation d'un compteur avant l'excution d'une instruction en langage volu permet de compter le nombre de ses excutions; l'appel une fonction systme spcifique permet d'obtenir les mesures de temps d'excution. Ces mesures peuvent tre plus ou moins prcises, suivant les caractristiques du matriel. Les rsultats sont mmoriss dans un fichier, au fur et mesure, et peuvent tre exploits par un outil spcifique qui rattache les mesures aux instructions des modules sources correspondants. Multics permet de faire ces mesures au niveau de chaque instruction des langages volus, grce une horloge trs prcise (de l'ordre de la microseconde). Mais on les trouve plus souvent au niveau des appels de sous-programmes, car la dure d'excution plus importante exige une prcision moins grande des mesures de dures. L'intrt de ces mesures rside surtout dans l'amlioration ultrieure de l'efficacit du programme par l'utilisateur, qui sait alors exactement o il doit porter son effort. Il est, en effet, inutile de gagner quelques microsecondes sur une instruction qui est excute une seule fois, alors que l'on peut tre surpris de la dure effective d'une instruction banale, mais qui fait intervenir des conversions coteuses.

6.2. Les prprocesseurs et les macrognrateurs


Il arrive souvent que l'on ait besoin de disposer d'un module source sous diffrentes versions assez proches les unes des autres, sans que la fonctionnalit et les spcifications du module soient changes. C'est le cas, par exemple, lorsque le module utilise des constantes d'adaptation qui permettent de configurer les tailles des zones de donnes internes. C'est le cas galement lorsque le module est intgr une application qui doit pouvoir tre porte sur des machines et systmes diffrents, entranant des variantes mineures de ce module. Si on dispose d'autant de copies de ce module source qu'il y a de versions, on rencontre deux problmes: le premier est le nombre de ces copies presque identiques, et le second est la maintenance de toutes ces copies, lorsqu'une modification doit tre apporte toutes les versions. Certains langages de programmation, ou leur traducteur, intgrent la prise en compte de ces diffrentes versions. Cependant une autre solution consiste disposer d'un seul exemplaire du module source qui est alors paramtr pour permettre la construction d'une version particulire immdiatement avant la traduction. C'est le rle d'un programme spcifique appell prprocesseur. L'intrt de reporter au niveau d'un prprocesseur ce travail, au lieu de le laisser au traducteur, est que, d'une part, le prprocesseur n'est pas attach un langage particulier, et peut donc servir beaucoup de langages, d'autre part, cela simplifie le traducteur. Nous allons nous baser sur le prprocesseur construit par les concepteurs du langage C, pour expliquer succintement le fonctionnement gnral. L'ide est qu'un prprocesseur prend en entre un module source, et fournit en sortie un module source transform. Il s'agit donc bien d'un outil qui travaille au niveau texte source. Il doit tre capable de distinguer dans ce texte source les commandes qui lui sont destines du reste du texte. Dans le cas du prprocesseur de C, on les distingue par la prsence du caractre "#" en dbut de ligne. Ces commandes doivent permettre des modifications simples du reste du texte. En voici les principales:
#include "nom de fichier" #define TOTO 2456

demande au prprocesseur d'inclure cet endroit le fichier correspondant. demande au prprocesseur de remplacer systmatiquement, partir de maintenant la chane de caractres TOTO par 2456 partout o elle se trouve. demande au prprocesseur d'arrter le remplacement systmatique de la chane TOTO. demande au prprocesseur de transmettre les lignes qui suivent la commande #ifdef, s'il y a une demande de remplacement en cours pour la chane TOTO, et de les supprimer s'il n'y en a pas. La
- 56 -

#undef TOTO #ifdef TOTO

Autres outils
#else #endif

prochaine commande #else, si elle existe, entranera l'action oppose (suppression ou transmission) pour les lignes qui suivent, et la commande #endif reprendra le cours de fonctionnement normal. Ces commandes peuvent tre imbriques, avec la signification habituelle des langages de haut niveau.

Il faut remarquer que le langage de dfinition des commandes ainsi que les oprations de remplacement dans le texte n'impliquent aucune relation avec le langage C lui-mme. Ce prprocesseur est d'ailleurs communment utilis pour le langage Pascal dans les systmes Unix. Les remplacements dfinis ci-dessus sont rudimentaires. En fait ils peuvent tre paramtrs. Ainsi la commande
#define NUMERO(A, B) 25 * A + B

demande le remplacement des chanes de la forme NUMERO (u, v), o u et v sont des chanes quelconques ne contenant pas de virgules, par la chane 25 * u + v. On dit parfois que l'on a une macrodfinition. Il est important de rappeler que le prprocesseur travaille au niveau chane de caractres, sans avoir de connaissance du langage reprsent. C'est l'utilisateur de prendre garde que la chane obtenue aprs remplacement soit conforme ce qu'il dsire. Par exemple, dans le contexte de la commande prcdente, NUMERO(x + 1, y) deviendra 25 * x + 1 + y NUMERO((x + 1), y) deviendra 25 * (x + 1) + y Il est probable que le premier remplacement n'est pas celui dsir. Il serait en fait prfrable d'crire:
#define NUMERO(A, B) 25 * (A) + (B)

pour que l'interprtation du remplacement obtenu conserve la structure syntaxique 25 * A + B, quels que soient A et B. Plus gnralement on parlera de macrognrateur pour un outil qui a pour but de produire un module source dans un langage de programmation donn, partir d'un module source qui mlange des commandes dans le langage du macrognrateur, parfois appell mta-langage, et des parties dans ce langage de programmation. L'une des utilisations les plus courantes est de faciliter l'interfaage d'un programme d'application avec une base de donnes. Le programmeur exprimera ses requtes la base de donnes dans le mta-langage, le macrognrateur traduira ces requtes en une suite d'instructions du langage de programmation, souvent constitues d'appels des sousprogrammes spcifiques.

6.3. Le make
Nous avons vu qu'un programme tait constitu de plusieurs modules. Mais chacun de ces modules peut lui-mme servir construire plusieurs programmes. Lorsque le nombre de modules impliqus dans un ensemble de programmes est important, il devient difficile de matriser compltement les consquences d'une modification d'un module particulier sur les programmes excutables. Plus gnralement, le problme est d'tre certain que les programmes excutables refltent bien toutes les modifications qui ont t apportes dans les modules sources. Une solution est videmment de refaire la traduction de tous les modules, et de refaire ensuite l'dition de liens de tous les programmes. Ceci peut entraner des traductions inutiles, et des ditions de liens inutiles. Le make est un programme qui rsout ce problme en ne faisant que ce qui est ncessaire, sous rserve que les informations qu'il exploite soient cohrentes. Initialement crit pour le systme Unix, de nombreuses versions existent maintenant pour des systmes varis.

6.3.1. Graphe de dpendance


Pour dterminer ce qui doit tre fait, make utilise trois sources d'informations: un fichier de description, appell makefile, construit par l'utilisateur, les noms et les dates des dernires modifications des fichiers, des rgles implicites lies aux suffixes des noms de fichiers.
- 57 -

Chane de production de programmes partir de ces informations, il construit d'abord un graphe de dpendance sur l'ensemble des fichiers qui servent la construction du fichier cible que l'on cherche obtenir, et qui est fourni en paramtre make. Considrons par exemple un programme excutable appell prog, obtenu par dition de liens des modules objets situs dans les fichiers x.o, y.o et z.o. On dit que prog dpend de ces fichiers. De mme, si le module objet x.o est obtenu par compilation d'un module source situ dans le fichier x.c, avec inclusion du fichier source defs, on dit que x.o dpend de x.c et de defs. Remarquons que la compilation de x.c demandant l'inclusion de defs n'entrane pas de dpendance entre x.c et defs, puisque x.c n'est pas construit partir de defs. Par contre, il y a bien dpendance de x.o sur defs, puisqu'une modification de defs ncessite de reconstruire x.o. La figure 6.1 reprsente le graphe de dpendance complet.
prog x.o x.c defs y.o y.c z.o z.c

Fig. 6.1. Graphe de dpendance. Les dpendances peuvent tre directement dcrites dans le fichier makefile, et c'est un de ses rles. On pourrait ainsi mettre dans ce fichier les lignes suivantes:
prog : x.o y.o z.o x.o y.o : defs

Certaines dpendances peuvent tre aussi obtenues au moyen de rgles implicites simples et naturelles. Prenons comme convention (c'est assez habituel, et nous l'avons dj fait), que les modules objets, rsultats d'une traduction, sont dans des fichiers dont le nom est le nom du module suffix par .o; ces fichiers dpendent videmment du fichier qui contient le module source. Il est naturel, et galement courant, de donner au fichier source le nom du module avec un suffixe li au langage dans lequel il est crit, comme par exemple .c pour le langage C, .p pour la langage pascal, ou .f pour le Fortran. Make peut alors chercher utiliser les noms des fichiers du rpertoire courant pour complter les rgles de dpendances. Ainsi, pour le fichier x.o, il recherche dans le rpertoire un fichier dont le nom commence par x et suffix par l'un de ceux correspondant un langage source. Le fait de trouver le fichier x.c, lui permet d'tablir la dpendance correspondante.

6.3.2. Exploitation du graphe de dpendance


Pour dterminer si un fichier est jour, c'est--dire reflte les dernires modifications, il suffit de contrler que chaque fichier existe et a une date de dernire modification suprieure ou gale celle des fichiers dont il dpend. Si c'est le cas pour tous les fichiers du graphe, rien n'est faire, et le fichier cible est jour. Si ce n'est pas le cas, il est ncessaire de reconstruire ceux qui ne vrifient pas cette proprit. Il est ncessaire de faire cette reconstruction depuis le bas du graphe en remontant vers le haut, puisque la reconstruction d'un fichier entrane celle de tous ceux qui dpendent de lui et qui sont donc situs au dessus. Le problme est alors de savoir comment on peut reconstruire un fichier partir de ceux dont il dpend. Pour cela, il est possible d'attacher une rgle de dpendance dans le fichier makefile un ensemble de commandes dont l'excution sera demande au systme par make lorsque la rgle ne sera pas respecte. De mme, aux rgles implicites sont attaches une ou plusieurs commandes qui jouent le mme rle. Pour notre exemple, le fichier makefile pourrait associer la rgle relative prog la commande d'appel de l'dition de liens avec l'utilisation de la bibliothque de nom s, et dont le rsultat serait mis dans le fichier prog:
prog : x.o y.o z.o ld x.o y.o z.o -ls -o prog x.o y.o : defs

La commande associe la rgle implicite de dpendance du suffixe .o sur .c pourrait tre l'appel du traducteur correspondant sur le fichier source.

- 58 -

Autres outils

6.3.3. Macro substitution


Pour faciliter l'criture du fichier makefile, make propose un mcanisme simple de macro substitution. Une dfinition de macro est simplement une ligne contenant un nom suivi du signe "=" et du reste de la ligne. Une rfrence une macro est constitue du signe "$" suivi du nom de la macro entre parenthses s'il fait plus d'un caractre. Par ailleurs, avant de lancer des commandes relatives une rgle de dpendance, make initialise certaines macros, comme par exemple $? qui reprsente la chane des noms de fichiers qui ont t trouvs plus rcents que le fichier cible, et qui sont donc la cause de cette excution. Dans le contexte du fichier makefile de la figure 6.2, l'excution de
make prog

entrane la construction du graphe de dpendance donn en figure 6.1, et les recompilations ventuellement ncessaires ainsi que l'dition de liens. Le nom de l'diteur de liens est paramtr par $(LD), implicitement identifi ld, pour permettre sa redfinition lors de l'appel de make. De mme, la dfinition des bibliothques utilises lors de cette dition de liens est paramtre explicitement par la dfinition de la macro LIBES.
OBJECTS = x.o y.o z.o FILES = x.c y.c z.c defs LIBES = -ls P = imprint -Plplaser prog : $(OBJECTS) $(LD) $(OBJECTS) $(LIBES) -o prog x.o y.o : defs print : $(FILES) $P $? touch print arch : ar uv /usr/src/prog.a $(FILES)

Fig. 6.2. Exemple de fichier makefile. Pour dater certaines oprations, il est possible de crer des fichiers vides, et de demander au systme de modifier la date de leur dernire modification lorsque l'opration est excute (commande touch avec Unix, par exemple). Supposons qu'il existe un tel fichier de nom print, dans le contexte du mme fichier makefile, l'excution de
make print

entranera l'impression des fichiers qui sont plus rcents que ce fichier. Les commandes associes la rgle de dpendance non seulement impriment ceux qui sont plus rcents, mais force la date du fichier print pour mmoriser la date laquelle cette opration a t faite. Enfin, aprs construction du graphe de dpendance, si un fichier n'existe pas, le make excute les commandes associes la rgle de dpendances qui lui correspond. En gnral, ces commandes entranent sa construction effective. Cependant, si le fichier n'est pas cr, le make considre qu'il a la date actuelle vis--vis des rgles de dpendances au-dessus de lui. Il n'est donc pas obligatoire qu'un fichier soit effectivement attach aux oprations. Ainsi, dans le contexte de l'exemple, l'excution de
make arch

entrane toujours l'excution des commandes associes, puisque le fichier arch n'existe pas. Lorsque la commande est excute, le fichier n'est toujours pas cr, mais make considre qu'il est dat du moment prsent, et donc que les proprits d'antriorit sont respectes.

6.4. Les outils complmentaires


Il est courant de trouver sur la plupart des installations, des outils d'aide la gestion des modules. Ce peut tre, par exemple, un archiveur qui permet d'archiver des modules sources, ou plus gnralement des fichiers quelconques. Leur intrt est d'une part de regrouper ensemble des fichiers qui forment un tout cohrent, d'autre part de diminuer l'encombrement sur support
- 59 -

Chane de production de programmes secondaire de cet ensemble, par le biais de techniques complexes de compression d'informations. Le rsultat est souvent au moins deux fois moins encombrant. Pour faciliter le suivi de l'volution d'un module source, on peut disposer d'un programme, appell diff, qui dtermine la diffrence entre deux fichiers de texte. Le rsultat est la suite de commandes d'dition qui permet un diteur orient lignes, de reconstruire le deuxime fichier partir du premier. On voit que ceci permet un programmeur de diffuser les modifications apporter une version du source pour passer la version suivante. Celui qui reoit le rsultat du diff, n'a pas faire les modifications la main, mais les faire excuter par l'diteur orient lignes correspondant. La prsentation externe d'un module source est souvent trs importante pour la mise au point et la maintenance. Un paragrapheur, encore appell indenteur, est un programme qui donne une forme standard un fichier source crit dans un langage donn. Il est adapt au langage lui-mme, car cette forme ne peut tre obtenue que par une analyse lexicale et surtout syntaxique du texte source, pour en reconnatre les structures fondamentales. La gestion des modules objets et des bibliothques de ces modules est souvent assure par un bibliothquaire. Nous avons vu qu'une telle biblothque de modules pouvait ncessiter une structure de donnes pour rendre plus efficace le travail de l'diteur de liens. De nombreux autres outils existent. Nous ne pouvons les dcrire tous, certains tant ddis des tches trs prcises. La raison est que souvent lorsque l'on doit faire ponctuellement une activit automatisable, il est prfrable de faire l'outil qui ralisera cette activit plutt que de faire l'activit soi-mme, car l'outil pourra resservir.

6.5. Conclusion
La trace d'un programme est une suite d'informations qui permettent de contrler l'volution de l'tat d'un programme au cours de son excution. En fait on ne cherche bien souvent connatre qu'une partie de cette trace. Un point d'arrt dans un programme est un endroit o l'on dsire arrter l'excution du programme pour consulter son tat interne. La reprise est la possibilit de poursuivre l'excution du programme aprs qu'il ait t interrompu. Le pas pas est la possibilit d'excuter le programme une instruction la fois. Un metteur au point est un outil qui permet de contrler interactivement l'excution d'un programme. Il est symbolique lorsqu'il permet l'expression des commandes en utilisant les structures du langage volu dans lequel le programme a t crit. Les mesures de comportement dynamique d'un programme permettent de savoir o il faut porter son effort pour amliorer son temps d'excution. Un prprocesseur ou un macrognrateur est un programme qui permet de faire un traitement simple sur le texte source avant de le donner un traducteur. Il existe un graphe de dpendance entre l'ensemble des fichiers utiliss dans la chane de production de programmes: un fichier A dpend d'un fichier B si B est utilis pour construire A. Un fichier contenant un programme excutable est jour si pour tous les fichiers A et B de son graphe de dpendance, tels que A dpende de B, la date de dernire modification de A est postrieure celle de B. Le make est un outil qui, l'aide d'un fichier parmtre, construit le graphe de dpendance d'un programme excutable, contrle qu'il est jour et excute les commandes minimales pour assurer cette mise jour, si ce n'est pas le cas. Le make peut tre utilis chaque fois qu'il existe un graphe de dpendance entre des fichiers, pour contrler que ces fichiers sont jour, et excuter les commandes ncessaires cette mise jour, si ce n'est pas le cas. Beaucoup d'autres outils existent, car il est souvent prfrable de faire un outil pour une activit automatisable, plutt que de raliser l'activit la main.
- 60 -

TROISIME PARTIE

ENVIRONNEMENT EXTERNE

- 61 -

La notion de fichier

Nous avons vu dans les premiers chapitres que l'un des rles du systme d'exploitation tait de fournir l'utilisateur une machine virtuelle adapte ses besoins. Les connexions avec les priphriques prsentant des formes varies, il est ncessaire d'tudier quels sont les vrais besoins des utilisateurs pour raliser cette adaptation. Rappelons, tout d'abord, que nous avons distingu quatre sortes de priphriques: les priphriques de dialogue homme-machine, pour lesquels le transfert se fait caractre par caractre, ou par criture directe en mmoire pour les crans graphiques, les priphriques de stockage squentiel, pour lesquels le transfert se fait par paquet de caractres, de taille variable, les priphriques de stockage alatoire, pour lesquels le transfert se fait par paquet de caractres, de taille fixe, les priphriques de communication de machine machine, pour lesquels le transfert se fait par paquet de caractres, de taille variable mais borne, un protocole assez complexe tant utilis pour assurer ces transferts.

7.1. Le but des objets externes


Rappelons que lors de l'excution d'un programme, le processeur ne manipule que des objets en mmoire centrale, dont les caractristiques gnrales imposent que de tels objets ne puissent, en gnral, exister avant le chargement du programme, ou aprs la fin de son excution. Leur dure de vie est limite la dure de prsence du programme en mmoire. On dit que ces objets sont internes au programme. Par opposition, on appelle objet externe ceux qui ne sont pas internes.

7.1.1. Les objets externes comme outils d'change d'informations


On peut distinguer deux objectifs dans l'utilisation des objets externes par un programme. Le premier est l'change d'informations, qu'il soit avec l'homme ou avec une autre machine. La consquence de cet change est la ncessit de trouver un langage commun entre les deux partenaires de l'change. Avec l'homme comme partenaire, cela implique la transformation de la reprsentation interne des donnes en une forme comprhensible par l'homme, et rciproquement. Lors de l'change entre machines, plusieurs solutions peuvent tre adoptes, suivant la nature des machines qui communiquent. Notons tout d'abord que l'change de base est ralis sous forme d'une suite d'octets. l'mission, la reprsentation interne des donnes doit donc tre convertie en une
- 63 -

Environnement externe suite d'octets, et l'opration inverse effectue la rception. Les donnes dj sous forme de suite d'octets, comme par exemple les chanes de caractres, ne posent en gnral pas de difficult, du moins si les deux machines utilisent le mme codage des caractres (il en existe deux principaux: EBCDIC et ASCII). Les donnes dont la reprsentation interne regroupe plusieurs octets posent plus de difficults. Lors du dcoupage d'un mot, deux ordres des octets sont possibles. Certains constructeurs mettent d'abord les bits de poids faibles, c'est--dire, ceux de droite en premier. D'autres font l'inverse, c'est dire mettent les bits de poids forts d'abord. L'interprtation smantique de la reprsentation varie d'un constructeur l'autre, en particulier, pour les nombres flottants. Si les reprsentations des donnes sont les mmes pour les deux machines, en particulier si elles sont du mme modle, la communication peut se faire en binaire, c'est--dire, dans la reprsentation interne commune. Si ce n'est pas le cas, on peut faire, sur l'une des machines ou sur l'autre, la conversion entre les reprsentations binaires. Une dernire solution plus courante est d'utiliser une reprsentation normalise des donnes pour assurer l'change d'informations entre ces machines. L'avantage, dans ce cas, est que le producteur de l'information n'a pas se proccuper du destinataire, et rciproquement. L'inconvnient est, bien entendu, la perte de temps machine qui rsulte de ces conversions. Notons que cette conversion de donnes est considre comme suffisamment importante pour que certains langages de programmation comme le COBOL permettent de les rduire au minimum. Les donnes conservent alors dans le programme leur reprsentation externe. La conversion ventuelle n'intervient alors que lorsque les traitements le ncessitent. Le programmeur doit videmment avoir conscience du compromis qu'il doit choisir: Soit il convertit les donnes lors des entres-sorties, les rendant plus coteuses, mais les traitements sont efficaces car les oprations s'effectuent sur des donnes en reprsentation interne. Soit il conserve les donnes en mmoire sous leur forme externe, rendant les entres-sorties plus efficaces, mais les traitements sur les donnes doivent les interprter ou faire chaque fois les conversions correspondantes.

7.1.2. Les objets externes comme outils de mmorisation long terme


Un programmeur a aussi besoin des objets externes pour disposer d'informations dont la dure de vie s'tend au-del de la dure de vie du programme. C'est le cas lorsque ces donnes existent avant le chargement du programme, ou doivent tre conserves aprs la fin de son excution. Contrairement au cas prcdent, c'est la mme machine qui cre ces donnes et les reprend ultrieurement5. On peut dire effectivement qu'il s'agit encore de pouvoir changer des informations mais cette fois entre des programmes qui s'excutent sur la mme installation. Le problme de conversion nonc ci-dessus ne se pose plus. Les donnes, en gnral, peuvent et doivent tre mmorises dans leur reprsentation interne. Un problme peut cependant se poser pour les donnes de type pointeur. Rappelons qu'un pointeur est une information binaire qui permet de dsigner un emplacement dans un espace mmoire; c'est donc une adresse. Si cette mmoire est la mmoire centrale, cela signifie que le pointeur dsigne un objet interne au programme, et n'a de signification que pour cette excution. Le conserver sous cette forme aprs la fin de l'excution de ce programme n'a pas sens. Sa valeur doit tre remplace par une information qui dsigne l'emplacement dans l'objet externe o sera rang la copie de la donne interne pointe.

7.2. La manipulation des objets externes par le programme


Le mot fichier est parfois utilis de faon ambigu, car il dsigne tantt l'objet externe mmoris sur un support magntique (bande ou disque), tantt l'entit manipule par le programme. Pour viter
5

au moins dans le cas des systmes centraliss. Dans un rseau local, avec un serveur de fichier, ce peut tre une autre machine. - 64 -

Notion de fichier cette ambigut, le premier pourrait tre appel fichier physique et le second fichier logique. En gnral nous n'utiliserons le terme fichier que pour dsigner la faon dont le programme manipule l'objet indpendamment de l'objet lui-mme et des contraintes physiques d'implantation comme des caractristiques du priphrique qui le supporte.

7.2.1. La notion de fichier


Le fichier est la faon dont un programme voit un objet externe. C'est d'abord une collection d'enregistrements logiques ventuellement structure, sur laquelle le programme peut excuter un ensemble d'oprations. Un enregistrement logique, encore appel article, est l'ensemble minimum de donnes qui peut tre manipul par une seule opration lmentaire du fichier. Il est souvent constitu de diverses donnes lmentaires, que l'on peut dcrire dans le langage de programmation utilis, comme le montre la figure 7.1. Ces donnes lmentaires ne sont accessibles individuellement par le programme que lorsque l'enregistrement logique est recopi dans un objet interne au programme. Dans cet exemple, le fichier est constitu d'une collection d'enregistrements qui ont la structure d'EMPLOYE. Les oprations sur le fichier permettent de transfrer le contenu d'un tel enregistrement entre la mmoire interne du programme et l'objet externe qui lui est associ.
01 EMPLOYE 02 NOM PICTURE X(30) 02 PRENOM PICTURE X(20) 02 NUM-S-S 03 SEXE PICTURE 9 03 DATE-NAISSANCE 04 ANNEE PICTURE 99 04 MOIS PICTURE 99 03 LIEU-NAISSANCE 04 DEPARTEMENT PICTURE 99 04 CANTON PICTURE 999 03 ORDRE PICTURE 999 02 CODE-INTERNE PICTURE 9999

Fig. 7.1. Exemple de description en COBOL d'un enregistrement logique.

7.2.2. Le fichier squentiel


La caractrisation des fichiers est dtermine par la nature des oprations que l'on peut effectuer sur le fichier. Le plus simple est le fichier squentiel. Les oprations se rsument, essentiellement, en la lecture de l'enregistrement suivant ou l'criture d'un nouvel enregistrement en fin du fichier squentiel. Bien souvent, pour affirmer le caractre squentiel du fichier, il n'est pas possible de mlanger les lectures et les critures. Le fichier est alors un fichier squentiel en lecture ou un fichier squentiel en criture. Le fichier squentiel en lecture est initialement positionn sur le premier enregistrement logique. Chaque opration de lecture (lire ou read) transfre dans une zone interne au programme un enregistrement du fichier, et prpare le fichier pour le positionner sur l'enregistrement suivant. On dispose souvent d'une opration complmentaire qui permet de savoir s'il y a encore des enregistrements lire dans le fichier (fin_de_fichier ou end_of_file), et ventuellement une opration permettant le retour au dbut du fichier (rembobiner ou rewind). Le fichier squentiel en criture peut tre initialement vide, ou positionn aprs le dernier enregistrement dj dans le fichier. Chaque opration d'criture (ecrire ou write) rajoute un enregistrement dans le fichier depuis une zone interne au programme, et positionne le fichier aprs cet enregistrement. L'criture d'un enregistrement se fait donc toujours aprs ceux qui sont dj dans le fichier. Noter que la caractristique essentielle d'un fichier squentiel est que les enregistrements sont lus dans l'ordre o ils ont t crits. Aucune conversion des donnes n'est applique, soit parce qu'elle est faite par le programme, soit parce qu'elle n'est pas ncessaire.

- 65 -

Environnement externe

7.2.3. Le fichier squentiel de texte


Le fichier squentiel de texte est analogue un fichier squentiel, mais avec conversion du format des donnes entre leur reprsentation interne et une reprsentation accessible l'tre humain. L'expression des oprations ncessitant la dfinition d'un format de conversion, la forme est trs dpendante du langage de programmation. On peut assimiler un fichier squentiel de texte un fichier squentiel o les enregistrements logiques sont en fait des caractres individuels. En lecture, les oprations sur un tel fichier sont compltes par des oprations qui permettent de lire une donne lmentaire, comme un entier, un nombre flottant, etc..., par conversion d'une suite de caractres lus depuis le fichier, suivant un certain format, implicite ou explicite. En criture, les oprations sur un tel fichier sont compltes par des oprations qui permettent d'crire une donne lmentaire, comme un entier, un nombre flottant, etc..., par conversion en une suite de caractres crits dans le fichier, suivant un certain format, implicite ou explicite. Certains langages de programmation, comme le FORTRAN, prsentent le fichier squentiel comme une collection d'enregistrements logiques correspondant une ligne de texte. En lecture, on peut alors lire l'enregistrement complet, par le biais d'un format, et d'un ensemble de variables lmentaires. Le format est alors utilis pour dcouper l'enregistrement en chanes de caractres et les convertir dans la reprsentation interne de ces variables. De mme, en criture, on peut crire un enregistrement complet, par le biais d'un format et d'un ensemble de valeurs lmentaires. Le format permet de convertir ces valeurs en leur reprsentation externe et de les placer dans l'enregistrement.

7.2.4. Le fichier accs alatoire


Le but du fichier alatoire est de permettre l'accs un enregistrement quelconque de la collection sans avoir parcourir tous ceux qui ont t crits avant lui. En gnral, il n'y a pas de restriction du type lecture seule ou criture seule, comme dans les fichiers squentiels, mais au contraire dfinition de trois oprations principales: lecture, criture et mise jour d'un enregistrement aprs sa lecture. Pour fournir l'accs l'un quelconque des enregistrements, il faut que le programmeur puisse le dsigner. Cette dsignation peut se faire par un numro. Dans ce cas, le fichier est vu comme une collection d'enregistrements numrots. Pour permettre d'implanter efficacement l'accs un enregistrement de numro donn, la taille d'un enregistrement, c'est--dire, le nombre d'octets de sa reprsentation, est en gnral fixe. Pour le programmeur, le fichier accs alatoire par numro peut s'assimiler un tableau une dimension. C'est videmment lui qui fixe l'attribution des numros aux enregistrements lors des critures. La dsignation d'un enregistrement peut se faire par l'intermdiaire d'une cl qui est en gnral incluse dans l'enregistrement. Lors d'une lecture, le programmeur peut, par exemple, donner d'abord une valeur aux champs correspondant la cl dans la zone mmoire interne de l'enregistrement, et en demander la lecture. L'opration du fichier recherchera l'enregistrement correspondant et en rangera la valeur dans la zone. L'opration de mise jour ou update, ultrieure rcrira cet enregistrement sans avoir besoin de le rechercher de nouveau. Une opration d'criture, avec en paramtre le contenu de l'enregistrement dans une zone en mmoire interne, consistera placer l'enregistrement dans l'objet externe, et mettre jour la structure de donnes qui permet de le retrouver (fichier squentiel index ou B-arbre). On trouve parfois un troisime type de fichier accs alatoire construit sur un fichier squentiel, mais qui ne doit pas tre confondu avec ce dernier. On dispose dans ce cas des deux oprations de lecture squentielle et d'criture squentielle (au bout), ainsi que de deux oprations supplmentaires permettant l'accs alatoire aux enregistrements du fichier: noter est une fonction qui retourne une valeur binaire reprsentant la position de l'enregistrement courant dans le fichier. Elle n'a de sens que pour le fichier. positionner avec en paramtre une valeur binaire prcdemment obtenue par l'opration noter cidessus, repositionne le fichier sur l'enregistrement sur lequel il tait au moment de cette opration.
- 66 -

Notion de fichier L'utilisation de ces oprations permet au programmeur de construire des structures de donnes quelconques sur un fichier. La valeur retourne par noter peut s'assimiler un pointeur externe et n'a de sens que sur le fichier dont il provient.

7.3. La liaison entre le fichier et l'objet externe


7.3.1. L'tablissement de la liaison
Un fichier (logique) peut tre vu comme un objet interne au programme. Pour pouvoir effectuer des oprations sur le fichier, il faut qu'il soit reli un objet externe. Il n'est pas intressant que cette liaison soit prise en compte par l'diteur de liens. En effet cela figerait cette liaison au moment de cette dition de liens, le programme excutable ne pouvant alors s'excuter que sur des objets externes dfinis ce moment. Par ailleurs l'diteur de liens se proccupe essentiellement des liaisons internes au programme, alors qu'il s'agit de liaisons externes. Pour les mmes raisons, il n'est pas judicieux que la liaison soit fixe au moment du chargement du programme. Au contraire elle peut tre tablie et rompue dynamiquement au cours de son excution. Nous reviendrons ultrieurement sur la dfinition de cette liaison, qui doit permettre d'associer un fichier interne au programme un objet externe. En supposant que cette dfinition existe, deux oprations sur un fichier quelconque permettent d'exploiter cette dfinition: L'opration d'ouverture (on dit aussi open) sur un fichier permet d'tablir la liaison avec un objet externe suivant les informations contenues dans sa dfinition. L'opration de fermeture (on dit aussi close) sur un fichier ouvert, permet de rompre temporairement ou dfinitivement la liaison avec l'objet externe. Les oprations que nous avons indiques dans les paragraphes prcdents ne peuvent tre appliques que sur des fichiers ouverts, puisqu'elles ont pour consquence des accs un objet externe qui doit donc avoir t associ au fichier. Il y a toutefois une exception cette rgle d'tablissement dynamique de la liaison. La plupart des systmes tablissent trois liaisons spcifiques pralablement l'excution du programme, pour les trois fichiers standards: - SYSIN pour l'entre des donnes provenant de l'utilisateur, - SYSOUT pour la sortie des donnes vers l'utilisateur, - SYSERR pour la sortie des messages d'erreurs vers l'utilisateur.

7.3.2. Reprsentation interne d'un fichier


La reprsentation interne d'un fichier logique dans le programme est une structure de donnes (appele parfois bloc de contrle de donnes ou encore Data Control Bloc). Elle contient quatre types d'informations: Les attributs de la liaison permettent de savoir quel est l'tat de la liaison (ouverte ou ferme), les variables internes de gestion de la liaison ainsi que les oprations autorises sur le fichier. Le descripteur de l'objet externe permet de localiser l'objet externe. S'il s'agit d'un priphrique, il faut connatre sa nature et son adresse. S'il s'agit d'un fichier physique, il faut connatre en plus la localisation de l'objet externe sur le priphrique qui le supporte. Les procdures d'accs sont en fait la concrtisation des oprations du fichier sur l'objet externe qui lui est reli. Il faut noter que, vu du programmeur, il s'agit toujours d'un ensemble d'oprations bien dfinies, mais l'implantation proprement dite de ces oprations dpend de la nature de l'objet externe et de son support. Les tampons d'entres-sorties permettent d'assurer l'interface entre les enregistrements logiques et les enregistrements physiques. Nous avons dit que les oprations du fichier manipulaient des enregistrements logiques tels que les dfinit le programmeur. Par contre les entres-sorties physiques ont des contraintes de taille et d'organisation qui dpendent du support. Par exemple, sur un disque, les enregistrements physiques occupent un nombre entier de secteurs. De mme, sur une bande, les enregistrements physiques doivent avoir une taille minimum si on veut avoir une bonne occupation de l'espace. Les tampons permettent de regrouper plusieurs
- 67 -

Environnement externe enregistrements logiques par enregistrement physique lors des critures, et de les dgrouper lors de la lecture. Ils servent aussi amliorer les performances du transfert entre le support externe et la mmoire centrale. Certaines des informations nonces ci-dessus sont statiques, c'est--dire, connues la compilation. Ce sont celles qui sont directement lies la nature du fichier tel que l'utilise le programmeur. La plupart sont en fait dynamiques, car elles dpendent du fichier et de l'objet externe avec lequel il est reli. La figure 7.2 montre une telle reprsentation d'un fichier logique lorsqu'il est ouvert ou ferm.
ferm nature

fichier logique ouvert nature tampons d'entres-sorties

descripteur de l'objet externe procdures d'accs

fichier logique

Fig. 7.2. Reprsentation d'un fichier ouvert ou ferm.

7.4. Conclusion
Les objets externes peuvent tre utiliss pour changer des informations. Cet change peut ncessiter de convertir les donnes dans une reprsentation commune. Les objets externes peuvent tre utiliss pour mmoriser des donnes long terme. Aucune conversion n'est ncessaire sauf pour les pointeurs vers la mmoire centrale qui perdent toute signification. Le fichier (logique) est le point de vue qu'a un programme d'un objet externe. On distingue en gnral le fichier squentiel d'enregistrements, le fichier squentiel de texte, et le fichier accs alatoire. Un fichier doit tre reli un objet externe pour pouvoir tre utilis. La liaison est tablie par l'ouverture, et supprime par la fermeture. En mmoire centrale, un fichier logique est reprsent par une structure de donnes (DCB) qui contient les attributs de la liaison, le descripteur de l'objet externe, les procdures d'accs et les tampons d'entres-sorties.

- 68 -

Implantation des objets externes sur disque

Avant d'tudier les diffrentes caractristiques d'une liaison entre un fichier interne et un objet externe, nous allons prsenter quelques mthodes actuelles de reprsentation des objets externes. Deux problmes se posent: d'une part comment allouer de l'espace disque un objet externe, d'autre part comment reprsenter l'espace allou l'objet externe. En fait ces deux aspects sont fortement lis. Par ailleurs, l'indpendance des objets externes implique de pouvoir donner une numrotation propre aux secteurs d'un objet. Nous applerons numro logique le numro relatif du secteur dans un objet externe. La reprsentation de l'espace allou l'objet doit permettre la transformation entre les numros logiques et les adresses disques. Nous allons tout d'abord linariser l'espace disque pour pouvoir nous ramener des problmes de gestion dans un espace une dimension.

8.1. La linarisation de l'espace disque


Nous avons dit qu'un disque est constitu d'un certain nombre de plateaux revtus d'une couche magntique. Des ttes magntiques, raison de une par face, sont fixes sur un bras qui permet de se dplacer perpendiculairement l'axe. Pour une position de bras donne, chaque tte dlimite une circonfrence sur son plateau, appel piste. Chaque piste est dcoupe en un nombre fixe de secteurs de taille fixe. Nous avons donc un espace trois dimensions. L'identification d'un secteur lmentaire est obtenue par trois nombres: Le numro de cylindre nc (on dit aussi le numro de piste) dtermine la position du bras. Il est compris entre 0 et le nombre de cylindres nbc moins 1. Le numro de face nf dtermine la tte devant faire le transfert. Il est compris entre 0 et le nombre de faces nbf moins 1. Le numro de secteur ns dtermine le secteur concern sur la piste. Il est compris entre 0 et le nombre de secteurs par piste nbs moins 1. Il est habituel de transformer cet espace trois dimensions en un espace une dimension, plus facile grer. En appelant numro virtuel de secteur nv, la dsignation d'un secteur dans ce nouvel espace, on peut dfinir: nv = ns + nbs * ( nf + nbf * nc ) Il s'ensuit que nv est compris entre 0 et nbs * nbf * nbc - 1 = N - 1, en notant N le nombre total de secteurs du disque. Cette transformation est bijective, et il est possible de retrouver ns, nf et nc partir de nv : ns = nv mod nbs nf = ( nv div nbs ) mod nbf nc = ( nv div nbs ) div nbf
- 69 -

Environnement externe o mod reprsente l'opration modulo, et div la division entire. L'avantage de cette numrotation par rapport aux autres que l'on pourrait faire, est que des numros de secteurs virtuels voisins impliquent des cylindres voisins; c'est donc une numrotation qui minimise les mouvements de bras. A noter que cette transformation est effectue automatiquement par les contrleurs de disque SCSI, qui grent galement les secteurs errons. Dans ce cas, le disque est vu directement comme une suite de secteurs numrots.

8.2. Allocation par zone


8.2.1. Implantation squentielle simple
La premire ide pour implanter un objet externe sur disque, est de lui attribuer un ensemble de secteurs contigus dans l'espace une dimension de la numrotation virtuelle. S'il est de taille T, et commence au secteur virtuel de numro D, il occupe alors les secteurs dont les numros virtuels sont tels que: D nv D + T - 1 L'information de localisation de l'objet externe est donc constitue du couple <D,T> (figure 8.1). L'accs au secteur de numro logique i dans l'objet externe, se fait de la faon suivante: 0 i T - 1 alors i nv = D + i <ns, nf, nc> Le premier inconvnient de cette mthode est li la difficult d'agrandir la taille de l'objet externe ultrieurement. En effet, ceci n'est possible que si un ensemble suffisant de secteurs virtuels, commenant en D + T, sont libres. Si un autre objet externe commence prcisment en D + T, il n'est pas possible d'agrandir la taille de celui qui commence en D.
D T objet extern e

Fig. 8.1. Implantation squentielle d'un objet externe localis par <D,T>. Le deuxime inconvnient est la consquence du premier: il faut connatre la taille exacte de l'objet externe au moment de sa cration, et avant toute autre opration. Ceci conduit souvent prvoir une taille suprieure ce qui est en fait ncessaire, de faon ne pas se trouver dans l'impossibilit de terminer un traitement parce que l'espace attribu l'objet externe est plein. Le troisime inconvnient est li la mthode d'allocation qui doit tre utilise: elle est appele allocation par zone. La cration d'un objet externe de taille T, ncessite d'allouer un espace de T secteurs conscutifs dans l'espace unidimensionnel des numros virtuels. videmment cet espace doit consister en des secteurs libres, c'est--dire, qui ne sont pas occups par un autre objet externe. Il est possible que, par suite d'allocations et de restitutions successives, l'espace se prsente comme une suite de zones libres et de zones occupes, aucune des zones libres ne pouvant satisfaire la demande de T secteurs, alors que la somme de toutes ces zones dpasse cette taille T. Il faut alors dplacer les diffrents objets externes, c'est--dire, tasser les objets, pour regrouper ensemble les zones libres dans un seul espace contigu. La difficult est que le dplacement d'objets sur disque est une opration coteuse en temps, puis qu'il faut lire son contenu en mmoire centrale et le rcrire. La consquence de ces trois inconvnients est en gnral une trs mauvaise utilisation de l'espace disque, au bnfice du constructeur qui vend donc plus de disques que ce qui est ncessaire. C'est pourquoi cette mthode tend tre abandonne.

8.2.2. Implantation squentielle avec extensions fixes


Pour viter les inconvnients de la mthode prcdente, on peut imaginer que l'espace occup par un objet externe n'est pas un unique espace contigu, mais un ensemble d'espaces contigus. L'objet externe peut tre rallong tout moment, si le besoin s'en fait sentir, en rajoutant un nouvel espace l'ensemble. Pour viter d'avoir fournir, et mmoriser, un paramtre de taille lors des rallongements successifs, on peut fixer une taille commune tous les blocs, sauf peut-tre le premier. Ainsi lors de la cration de l'objet externe, on fixe les paramtres <P, I> qui dterminent la
- 70 -

Implantation des objets externes taille de la premire zone alloue (P), encore appele partie primaire et la taille des zones en rallongement (I), encore appele incrments ou extensions. La plupart des systmes qui appliquent cette mthode imposent une limite au nombre d'incrments que peut avoir un objet externe, de faon donner une reprsentation fixe l'ensemble des informations qui localisent l'objet externe sur son support. La figure 8.2 donne un exemple d'implantation squentielle avec extensions. Les informations de localisation ncessitent de conserver les paramtres <P, I> de taille des zones primaires et extensions, mais aussi videmment la table DEBUTS des numros virtuels des premiers secteurs de chacune des zones alloues, ainsi que le nombre de zones alloues Q. La taille effective de l'objet externe un instant donn est: T = P + (Q - 1) * I. Si le tableau DEBUTS contient au plus M entres, la taille de l'objet externe est telle que: P T P + (M - 1) * I L'accs au secteur de numro logique i dans l'objet externe, est dfini comme suit: 0 i P - 1, alors nv = DEBUTS [0] + i P i T - 1, alors nv = DEBUTS [ (i - P) div I + 1 ] + (i - P) mod I
DEBUTS Q P zone primaire

zone secondaire 1 zone secondaire 2

zone secondaire 3

Fig. 8.2. Implantation squentielle, avec extensions, d'un objet externe localis par <P, I, Q, DEBUTS>. L'inconvnient de cette mthode est videmment li l'allocation par zone, comme pour la mthode prcdente. Pour crer l'objet externe, il faut disposer d'une zone contigu de taille P, et pour le rallonger, il faut disposer de zones contigus de taille I. Notons que ces valeurs peuvent tre notablement infrieures la taille totale, et donc le problme est ici moins important. Par contre, il est possible d'agrandir la taille de l'espace attribu l'objet externe, du moins dans certaines limites, et la taille totale maximale de l'objet ne doit pas tre connue lors de sa cration. Il faut nanmoins avoir une ide de cette taille pour dfinir les valeurs P et I. En gnral, P est toujours pris suprieur ou gal I. Il est en effet inutile de tenter de crer l'objet avec un zone primaire plus petite que les zones secondaires simplement pour avoir plus de chance de russir l'allouer, puisque le problme se produira, de toute faon, lors de l'allocation de la premire extension. Par ailleurs, l'objet externe n'occupe pas toujours la totalit de l'espace qui lui est allou. Si sa taille effective est, un instant donn, R, l'espace inoccup sera P - R si R P, et au pire I - 1 si R > P. On peut donc crire: T - R max (P - R, I - 1) S'il existe une taille minimum pour l'objet, disons Rmin, on obtient: T - R max (P - Rmin, I - 1) Par ailleurs, appelons Rmax la taille maximale de l'objet. On a donc: Rmax = P + (M - 1) * I Il s'ensuit que pour Rmax donn, une diminution de P entrane une augmentation de I. Pour avoir le moins de perte, il faut donc prendre: P - Rmin = I - 1, donc P = Rmin + I - 1
- 71 -

Environnement externe En reportant dans l'quation prcdente, on obtient: Rmax = Rmin + I - 1 + (M - 1) * I D'o on tire: I = (Rmax - Rmin + 1) / M P = Rmax - (M - 1) * I

En fait ceci peut conduire une valeur de P trop grande, et telle que l'allocation ne soit pas possible. Il est possible de diminuer cette valeur, mais, comme nous l'avons dj dit, la condition P I implique que P R max / M. Si l'allocation de la zone primaire n'est pas possible dans ce cas, il est ncessaire de rorganiser le disque pour tasser les objets qui l'occupent. La plupart des gros systmes d'IBM utilisent ce type d'implantation. Certains offrent la possibilit d'avoir des extensions de tailles diffrentes, mais le nombre d'extensions d'un fichier est limit.

8.2.3. Implantation squentielle avec extensions quelconque


Pour viter les inconvnients de la mthode prcdente, on peut imaginer que les diffrentes zones soient de taille quelconque, et qu'elles soient en nombre quelconque: <<D 1, T1>, <D2, T2>, ..., <Dn, Tn>>. L'objet externe peut tre rallong tout moment, si le besoin s'en fait sentir, soit en essayant de prolonger la dernire zone, s'il y a de l'espace libre derrire elle, soit en rajoutant un nouvel espace <Dn+1, Tn+1> l'ensemble. L'accs au secteur de numro logique i dans l'objet externe, est dfini comme suit: i nv = Dj + i - Sj o Sj = Tk et j tel que Sj i < Sj+1
k =1 j1

Dans le cas d'un parcours squentiel de l'objet externe, le systme passera simplement d'une zone la suivante, sans avoir rechercher la zone partir du numro logique. Par contre, dans le cas d'un accs alatoire, une boucle est ncessaire pour dterminer le numro de zone concerne. Notons que lorsque la demande d'allocation est implicite, comme par exemple lors de l'criture au del de la fin du fichier logique, le systme dterminera souvent lui-mme la taille ncessaire. Dans ce cas, il essayera souvent de prolonger d'abord la dernire zone, plutt que d'en rajouter une nouvelle. Il est galement possible de morceler la demande s'il n'y a pas de zone libre de taille suffisante. Cependant cela conduit une fragmentation de l'espace, et une certaine perte d'efficacit. Les systmes de gestion de fichier de MacOS, NTFS (Windows NT) et VMS utilisent cette mthode.

8.3. Allocation par blocs de taille fixe


Une autre mthode d'implantation des objets externes est de leur attribuer une collection de zones de taille fixe, qui est la mme quel que soit l'objet. On parle alors plutt d'une allocation par blocs de taille fixe, chaque bloc tant constitu videmment d'un nombre entier de secteurs. Les blocs sont appels parfois des clusters. Leur numrotation dcoule directement du numro du premier secteur virtuel qu'il contient. En effet, si on note nbsb le nombre de secteurs par blocs, le numro virtuel du premier secteur du bloc de numro j est nvj = nbsb * j (il faut parfois ajouter une constante).

8.3.1. Implantation par blocs chans


Le systme de gestion de fichier FAT, initialement cr pour MS-DOS, utilise une telle mthode, en chanant entre eux les blocs d'un mme objet externe. Au lieu de rserver dans les blocs eux-mmes la place pour mettre le numro du bloc suivant de l'objet externe, ce systme regroupe dans une table unique l'ensemble des chanons de blocs pour tous les objets externes. Cette table est appele la File Allocation Table (FAT), d'o le nom donn au systme. L'entre j de la table contient donc le
- 72 -

Implantation des objets externes numro du bloc suivant le bloc j dans l'objet externe qui le bloc j est allou. L'espace allou un objet externe peut alors tre simplement repr par le numro de son premier bloc (figure 8.3).
0 XXX 1 XXX 2 EOF 3 10 4 LIBRE 5 2 6 LIBRE 7 LIBRE 8 11 9 EOF 10 5 11 9 FAT bloc 3 bloc 10 bloc 5 bloc 2 objet externe D = 3 bloc 8 bloc 11 bloc 9 objet externe D = 8

Fig. 8.3. Implantation par blocs chans des objets externes. La FAT est en gnral conserve en mmoire centrale de faon ne pas pnaliser les accs. Pour obtenir le numro virtuel nv du secteur logique i d'un objet externe, il faut drouler l'algorithme suivant:
r := i div nbsb; { rang du bloc dans l'objet } j := D; { premier bloc de l'objet } tant que r > 0 faire j := FAT [j]; r := r - 1; fait; nv := j * nbsb + i mod nbsb;

Ceci montre que cette reprsentation est bien adapte aux objets externes lis des flots squentiels. Les flots accs alatoire sont pnaliss par la dure de cet algorithme qui est proportionnelle au rang du bloc recherch. Si la FAT est entirement en mmoire, les accs peuvent tre de l'ordre de quelques microsecondes. Par exemple, avec 10 s par pas, et un rang de l'ordre de 100, cela demande nanmoins 1 ms. Cette mthode a t conue initialement pour des disquettes, o le nombre de blocs est faible. Les numros de blocs dans la FAT occupent 2 octets, mais sont sur 16 bits. Il ne peut donc y avoir que 65535 blocs au plus. Cela donne une FAT de 128 Ko, qui commence occuper beaucoup de place, en particulier, lorsque la mmoire centrale est limite 640 Ko, comme dans les versions de MSDOS antrieure 1991. Si on ne peut la mettre compltement en mmoire, cela rallonge d'autant la fonction de passage au bloc suivant. Notons que, avec une taille de blocs de 512 octets, cela permettait de grer des disques de 32 Mo, ce qui tait amplement suffisant cette poque.

8.3.2. Implantation par blocs plusieurs niveaux


Les systmes UNIX et Linux utilisent galement une allocation par blocs de taille fixe. Les problmes de dimensionnement voqus ci-dessus sont ds au fait que les informations qui dfinissent l'espace allou un objet externe sont centralises dans une seule table. On peut donc les viter en les rpartissant entre plusieurs tables. Il est alors logique d'attribuer une table par objet externe. La taille de cette table ne doit cependant pas tre fige, car son encombrement serait prohibitif pour les objets de petite taille. Unix rpartit cette table sur plusieurs niveaux en fonction de la taille des objets eux-mmes. La localisation d'un objet est dfinie par (figure 8.4): une table, que nous appelons TABDIRECT, donnant les numros de blocs pour les 10 premiers blocs de l'objet externe, un numro de bloc, que nous appelons INDIRECT_1, qui contiendra les numros des p blocs suivants de l'objet externe, un numro de bloc, que nous appelons INDIRECT_2, qui contiendra les p numros de blocs contenant les numros des p2 blocs suivants de l'objet externe,
- 73 -

Environnement externe un numro de bloc, que nous appelons INDIRECT_3, qui contiendra les p numros de blocs contenant, au total, p2 numros de blocs contenant les numros des p3 blocs suivants de l'objet externe.
TABDIRECT

INDIRECT_1

INDIRECT_2

INDIRECT_3

Fig. 8.4. Implantation par blocs de taille fixe sur plusieurs niveaux. Le numro de secteur virtuel nv du secteur logique i de l'objet externe est obtenu par l'algorithme donn en figure 8.5. Un objet externe qui occupe moins de 10 blocs a des numros de blocs indirects nuls (pas de bloc allou), tous les accs disques seront immdiats. Si un bloc fait 1 Ko, cela signifie que cette mthode n'entrane aucune pnalisation pour les objets externes de 10 Ko ou moins. Or cela reprsente en moyenne plus de 90% des fichiers d'une installation Unix. Si un objet externe occupe entre 10 et 10 + p blocs, il peut y avoir 1 accs disque supplmentaire pour chaque accs un bloc de donnes. Si les numros de blocs sont sur 4 octets, il s'ensuit que p = 256. Les objets externes qui font moins de 266 Ko entrent donc dans cette catgorie. De mme il y a deux accs disque supplmentaires pour les objets externes qui ont entre 266 Ko et 64 Mo. Enfin, nous aurons 3 accs disques supplmentaires pour ceux qui ont entre 64 Mo et 16 Go. Ceci ne veut pas dire que la taille du disque soit elle-mme limite 16 Go, puisque les numros de blocs tant sur 32 bits, il peut y en avoir 4 milliards (ou 2 si ce sont des entiers signs) et le disque peut atteindre 4 To. Notons que la reprsentation de la longueur utile dun fichier, si elle est sur 32 bits, limite de fait la taille des fichiers 4 Go. Pour viter de relire un bloc sur le disque si on l'a dj lu peu de temps auparavant, Unix implante une technique de cache des blocs disques, Cela veut dire que le dcompte des accs supplmentaires est un maximum, qui peut en fait tre beaucoup plus faible si les blocs contenant des numros de bloc n'ont pas besoin d'tre relus. Il en est souvent ainsi lorsque l'objet externe est reli un fichier squentiel. Une telle structuration peut tre rapproche de celle vue en 8.2.3, o nous avions un nombre quelconque de zones de taille variable. Lorsque ces zones se morcellent, et deviennent de plus en plus petites, dans le cas d'un disque fragment, il y a augmentation de la taille de la reprsentation de l'espace allou l'objet externe et perte d'efficacit, en particulier lors des accs alatoires. Dans la structuration aborde ici, au contraire, l'efficacit n'est pas influence par le contexte et est prise en compte par le systme ds sa conception.

- 74 -

Implantation des objets externes


r := i div nbsb; si r < 10 alors j := TABDIRECT [r]; sinon r := r - 10; si r < p alors lire_bloc ( INDIRECT_1, TAB_LOCALE ); j := TAB_LOCALE [r]; sinon r := r - p; si r < p * p alors lire_bloc ( INDIRECT_2, TAB_LOCALE ); lire_bloc ( TAB_LOCALE [r div p], TAB_LOCALE ); j := TAB_LOCALE [r mod p]; sinon { r suppos < p * p + p * p * p } r := r - p * p; lire_bloc ( INDIRECT_3, TAB_LOCALE ); lire_bloc ( TAB_LOCALE [r div (p * p)], TAB_LOCALE ); r := r mod (p * p); lire_bloc ( TAB_LOCALE [r div p], TAB_LOCALE ); j := TAB_LOCALE [r mod p]; finsi; finsi; finsi; nv := j * nbsb + i mod nbsb;

Fig. 8.5. Algorithme de calcul de nv du secteur logique i d'un objet externe.

8.4. Reprsentation de l'espace libre


8.4.1. Notion de quantum
Les oprations lmentaires sur les disques doivent se faire par un nombre entier de secteurs. Il est normal que les secteurs soient entirement allous un unique objet externe. Cependant, on peut noter qu'un disque de 20 Mo structur en secteurs de 512 octets, en comporte 40000, alors qu'un disque de 5 Go structur en secteurs de 4096 octets, en comporte 1.2 millions. Devant une aussi grande diversit, et de telles valeurs, il est ncessaire de dfinir ce que l'on appelle le quantum d'allocation qui est la plus petite unit d'espace qui peut tre allou lors d'une demande. L'espace est ainsi dcoup en units de mme taille, constitues de secteurs conscutifs, ce que nous avons dj appel des blocs (rappelons que ces blocs sont parfois appels des clusters). La valeur du quantum a deux consquences: La perte d'espace. L'espace effectivement ncessaire un objet peut se mesurer en nombre de ses enregistrements logiques, ou plus gnralement, en nombre effectif d'octets qu'occupe sa reprsentation. L'espace qui lui est allou se mesure en nombre de quanta qu'il a reu. Comme il reoit un nombre entier de quanta, le dernier reu n'est que partiellement occup. Ceci induit une perte d'espace que l'on peut valuer 1/2 quantum par objet existant sur le disque. Pour un nombre donn d'objets, la perte sera d'autant plus grande que le quantum sera plus important. Le nombre d'units allouables . Pour un disque de N octets, et un quantum de q octets, le nombre d'units allouables est N/q. Il s'ensuit que, plus le quantum est petit, plus le nombre d'units allouables est grand, ce qui a, en gnral, pour consquence une augmentation de la taille de la reprsentation de l'espace libre, et de la dure d'excution de l'algorithme d'allocation. Pour les systmes utilisant une allocation par zone de taille variable, une demande doit tre exprime en donnant le nombre de quanta d'espace contigu. Le quantum peut tre une unit de base impose par le systme, et connue de l'utilisateur. Il s'ensuit alors que le nombre de quanta d'une unit de disque dpend du disque lui-mme. Le systme doit alors avoir un algorithme d'allocation qui en tienne compte. l'oppos, certains systmes imposent un nombre maximum de quanta quelle que soit la taille du support. Le quantum varie alors d'un disque l'autre. Pour viter que l'utilisateur ait se proccuper de cette taille, on fixe un quantum de base, et il exprime alors ses besoins en donnant le nombre de quanta de base qu'il dsire. Le systme dterminera alors le nombre de quanta de l'unit support qui donne une taille suprieure ou gale ce nombre. L'utilisateur se verra ainsi allou un espace suprieur ou gal celui qu'il a demand.
- 75 -

Environnement externe Par exemple, si on fixe le nombre maximum de quanta 100 000, un disque de 256 Mo peut avoir 64 000 quanta de 4 Ko, et un disque de 5 Go peut avoir 78 000 quanta de 64 Ko. Le quantum de base pourrait tre fix 4 Ko. Un utilisateur qui en veut 10, obtiendrait effectivement 10 quanta, soit 40 Ko, sur le disque de 256 Mo, et obtiendrait 1 quantum de 64 Ko sur celui de 5 Go. Il va sans dire que, dans tous les cas, l'objet peut utiliser la totalit de l'espace allou. Ainsi dans le deuxime cas, si on a une implantation avec extension, cela veut dire que l'objet aura moins d'extensions. Le nombre maximum de quanta est galement influenc par l'identification de chaque quantum. Ainsi, la FAT dans le cas de MSDOS, ou HFS dans le cas de MacOS limitaient 16 bits cette identification, et donc interdisaient d'avoir plus de 65 536 quanta sur un disque, ce qui n'tait pas un handicap pour les petits disques, mais l'est devenu avec les disques actuels. Pour pallier cet inconvnient, Microsoft a construit NTFS, et Apple HFS+. Pour les systmes utilisant une allocation par blocs individuels, le quantum se confond avec la taille du bloc. Pour l'utilisateur, la taille, et donc la valeur d'un quantum importe peu, puisqu'il n'exprime directement aucun besoin d'allocation, les allocations tant faites automatiquement lors des accs. Le quantum peut mme dpendre du disque, et non pas tre impos par le systme.

8.4.2. Reprsentation par table de bits


Plusieurs mthodes sont utilises pour reprsenter l'espace libre. Il faut en fait savoir quelles sont les diffrentes units d'allocation de un quantum, ou blocs, qui sont libres. La premire consiste utiliser une table de bits indice par les numros de blocs, et prcisant leur tat libre ou occup. L'algorithme d'allocation consiste parcourir cette table pour rechercher une entre, ou plusieurs conscutives, ayant l'tat libre. Au lieu de partir du dbut de la table, on peut considrer que l'on a une table circulaire, et commencer sur un numro quelconque correspondant un numro de bloc au voisinage duquel on cherche faire l'allocation de faon minimiser ultrieurement les mouvements de bras. En voici trois exemples, dans le cas d'implantation par blocs individuels: Minix, systme voisin d'Unix sur micro-ordinateur crit pour l'enseignement de systme par Andrew Tanenbaum et son quipe, utilise une telle table de bits, et commence la recherche sur le numro du premier bloc allou l'objet externe. NTFS utilise galement cette mthode. Linux utilise galement une table de bits, mais pour amliorer l'efficacit des accs, dcoupe le disque en groupes, chaque groupe ayant sa propre table de bits. Le systme cherche allouer les blocs prioritairement dans le groupe o est dj situ l'objet externe, lui assurant ainsi une certaine localit. MS-DOS fusionne la table de bits avec la FAT dont nous avons dj parl. Lorsqu'un bloc est libre, l'entre de la FAT qui lui correspond reoit une valeur particulire (0). Lors d'une allocation, le systme recherche une entre ayant une valeur nulle, au voisinage du dernier bloc courant de l'objet externe concern. La mthode est galement utilisable pour l'allocation d'une zone de p blocs. On recherche le premier bit LIBRE, et on regarde s'il est suivi d'au moins p bits LIBRE. Si ce n'est pas le cas, on recommence au del. Voici l'algorithme:
i := 0; trouv := faux; k := 0; { k = nombre de bits LIBRE trouvs successifs } tant que i < N et non trouv faire si tat [i] = LIBRE alors si k = 0 alors j := i; { repre le dbut } finsi; k := k + 1; trouv := k = p; { on en a trouv p successifs } sinon k := 0; finsi; i := i + 1; fait; { si trouv alors allouer de j j + p - 1 }

Pour amliorer cette recherche, certains systmes compltent la table de bits par un liste partielle de zones libres contigus. On ne recherche dans la table que si on n'a pas trouv satisfaction dans cette liste.

- 76 -

Implantation des objets externes

8.4.3. Reprsentation par liste des zones libres


La deuxime mthode consiste avoir une ou plusieurs listes des zones libres, avec leur longueur. Il en existe de nombreuses variantes, suivant la faon dont les zones sont ordonnes dans la liste par tailles croissantes ou par adresses croissantes. On peut aussi clater la liste en plusieurs listes, chacune d'elle correspondant une taille donne. Nous ne dcrirons cette mthode que dans un cas particulier simple, le cas li l'implantation par blocs individuels, car alors toutes les zones peuvent tre ramenes des blocs individuels, c'est--dire des zones d'une seule taille. Elle est souvent utilise dans les systmes Unix. Pour chaque disque, le systme dispose d'une petite liste de ce type en mmoire centrale. L'allocation consiste allouer le premier bloc de la liste. La libration d'un bloc consiste le remettre en tte de la liste. Lorsqu'elle devient trop importante, l'un des blocs est extrait de la liste, et on y range une partie de la liste. Ces blocs de liste de blocs libres sont eux-mmes chans entre eux. Lorsque la liste en mmoire centrale devient trop petite, on la complte avec celle contenue dans le premier bloc de la liste des blocs libres (figure 8.6). Cette mthode ne permet pas de regrouper un objet sur des blocs voisins sur disque, mais permet une allocation/libration immdiate, tout en ayant un nombre quelconque d'units d'allocation. Si beaucoup de blocs sont libres, cette liste est rpartie dans des blocs libres eux-mmes. Lorsqu'il y en a peu, la liste occupe peu de place sur disque.
TETE LIBRES

mmoire centrale

blocs sur disque

Fig. 8.6. Reprsentation des listes de blocs libres.

8.5. Conclusion
L'espace disque peut tre linaris par les numros virtuels de secteur. Les secteurs de l'espace appartenant un objet peuvent recevoir un numro logique propre l'objet. La reprsentation de l'espace allou l'objet doit permettre de transformer ces numros logiques en numros virtuels. L'allocation par zone consiste allouer des secteurs contigus. Elle prsente l'inconvnient de ne pas toujours tre possible, bien que l'espace libre soit suffisant. L'implantation squentielle d'un objet consiste l'implanter dans des secteurs contigus, en utilisant l'allocation par zone. Pour permettre les rallongements, on peut utiliser des extensions, chacune delles tant constitue galement de secteurs contigus. Le nombre d'extensions est en gnral faible et born. L'allocation par blocs de taille fixe consiste dcouper l'espace en blocs, qui sont tous constitus du mme nombre de secteurs, et qui sont allous individuellement. L'avantage de l'allocation par blocs est qu'elle est impossible uniquement lorsque tout l'espace est occup. L'implantation par blocs peut tre obtenue en chanant entre eux les blocs d'un mme objet externe, ce qui peut tre inefficace pour les accs alatoires. Elle peut encore tre obtenue par une table qui fait correspondre aux numros logiques de blocs le numro virtuel de celui qui a t allou cet endroit. La taille de cette table peut tre adapte la taille de l'objet en utilisant plusieurs niveaux. Le quantum d'allocation est la plus petite quantit d'espace qui peut tre alloue lors d'une demande. Si elle est petite, le nombre d'units diffrentes est important. Si elle est grande, cela induit une perte d'espace.

- 77 -

Environnement externe Le quantum peut tre fixe pour un systme, ou dpendre du type de disque. Dans ce dernier cas, l'utilisateur exprime ses besoins en quanta de base et le systme en dduit le nombre de quanta du disque qui est ncessaire. L'espace libre peut tre reprsent soit par une table de bits indiquant l'tat libre ou occup de chaque unit individuelle soit par des listes de zones libres. Ces deux reprsentations sont utilisables pour les deux types d'algorithmes d'allocation.

- 78 -

La dsignation des objets externes

Nous avons dit prcdemment que l'accs un objet externe dans un programme se faisait par l'intermdiaire d'un fichier logique, point de vue du programmeur, qui devait tre reli l'excution avec un tel objet externe. L'tablissement du lien proprement dit est ralis par l'opration d'ouverture du fichier. Les paramtres de cette opration doivent permettre de localiser l'objet externe, et d'en trouver les caractristiques.

9.1. La dfinition d'une liaison


Les avis divergent sur l'endroit o doit se trouver cette dfinition. Dans certains systmes, cette dfinition ne fait pas partie du programme, mais de son environnement. Aussi, c'est le langage de commande qui propose des commandes permettant cette dfinition. Ceci offre l'avantage de bien faire la sparation entre l'algorithme et les objets sur lesquels s'excute l'algorithme. Par ailleurs, cela permet de prendre en compte un grand nombre de paramtres, avec des valeurs par dfaut pour chacun d'eux, ce qui n'est pas toujours possible dans les langages volus. Enfin cela vite de faire dpendre certaines fonctionnalits du systme, de la possibilit de les exprimer dans les langages volus. Cette mthode est souvent applique sur les gros systmes qui privilgient le traitement par lots, et qui peuvent recevoir des priphriques divers, impliquant un nombre important de paramtres de la dfinition d'une liaison (prs de 150 paramtres pour une commande //DD d'IBM). Cela permet galement au systme de savoir quels seront les besoins du programme avant d'en lancer l'excution, et de la retarder si ces besoins ne peuvent tre satisfaits. En gnral, la mise en correspondance entre le programme et le langage de commande est obtenue par un nom logique (identificateur) donn au fichier explicitement par le programmeur ou implicitement par le traducteur, et repris par l'utilisateur dans la commande de dfinition. Par opposition, d'autres systmes supposent que les paramtres de l'ouverture d'un fichier sont dtermins par le programme et sont partie intgrante de la demande d'excution de l'opration. On vite de trop fortes contraintes entre les langages et le systme en ayant assez peu de paramtres, dont au moins un est une simple chane de caractres qui n'est pas interprte par le langage volu, et qui joue ainsi le rle de commande. Cette mthode offre l'avantage de permettre au programme d'avoir une certaine matrise sur la dfinition de la liaison. En particulier, lorsque le programme est utilis de faon interactive, il est possible de cacher l'utilisateur du programme la complexit de l'interface systme concernant les objets externes, sans pour autant devoir toujours relier le fichier avec le mme objet externe. Lorsque l'objet externe est directement un priphrique physique, la dfinition de la liaison est relativement simple, car ces priphriques existent en nombre trs limit, et leurs nombres ou caractristiques varient trs peu pour une installation donne. On peut donc leur donner un nom mnmonique spcifique qui est connu de tous les utilisateurs. Ce nom est ensuite utilis par le systme pour en trouver la localisation et les caractristiques au moyen d'une recherche dans ses
- 79 -

Environnement externe tables internes. Il trouve ainsi, non seulement le descripteur du priphrique, mais galement les procdures de traitement des oprations qui le concernent. Par ailleurs ces tables permettent de savoir l'tat libre ou occup de ces priphriques, et d'en assurer ainsi la gestion. Lorsque l'objet n'est pas un priphrique, mais est un fichier physique sur un support magntique, la dfinition doit permettre de: localiser le support physique de l'objet, localiser l'objet sur le support, dterminer les caractristiques de l'objet. La notion de volume est souvent utilise pour permettre la localisation du support, et la notion de rpertoire pour permettre la localisation sur le support ainsi que la dtermination des caractristiques de l'objet lorsqu'il existe dj.

9.2. La notion de volume


La localisation du support par localisation du priphrique n'est pas acceptable ds que le support lui-mme est amovible. Le priphrique permet d'accder au support qui est actuellement mont sur ce priphrique. Pour l'utilisateur, il importe plus d'accder un support donn que d'accder au priphrique sur lequel il est mont. Pour la bonne excution des oprations, il importe plus au systme de savoir quel priphrique est concern par les oprations. En premire approche, on appelle volume un support d'informations, tel que, par exemple, une bande magntique, une cartouche, une disquette, ou une pile de disque (une gamelle). Il est important de noter que le volume est quelque chose que l'on manipule comme un tout, et que, comme support d'objets externes, il a une structure qui lui est propre. En tant que support, il est de nature physique, mais en tant que structure, il est de nature logique. Le fait qu'il puisse tre amovible, implique qu'il peut ne pas tre accessible, et c'est alors sa nature physique seule qui nous intresse, puisqu'on ne peut lire alors son contenu. Au contraire, pour tre accessible, il doit tre disponible sur un priphrique particulier, et sa structure reconnue, et c'est donc sa nature logique seule qui nous intresse. On appelle montage d'un volume l'opration qui rend accessible son contenu, et dmontage l'opration qui le rend inaccessible.

9.2.1. La structuration d'un volume


Le fait qu'un volume puisse tre amovible implique que l'ensemble des informations qui y sont mmorises doivent tre suffisantes pour en dfinir le contenu. Il est donc ncessaire que l'on y trouve deux types d'informations: les caractristiques des objets externes qu'il contient, ainsi que leur localisation sur le volume, les informations permettant au systme d'y crer de nouveaux objets externes sans craser ceux qui y sont dj. Le permier type d'informations est directement li la localisation des objets sur le support. Nous verrons ultrieurement les structures permettant de rsoudre ce problme. Le deuxime type d'informations est en fait la reprsentation de l'espace libre dont nous avons parl dans le chapitre prcdent. Lorsqu'un volume n'est pas mont, c'est sa nature physique qui nous intresse. Encore faut-il tre capable de l'identifier parmi l'ensemble des volumes existants pour l'installation. Ceci passe en gnral par une tiquette colle directement sur le support, qui permet l'oprateur d'accder cette identification. Pour permettre un contrle par le systme de cette identification, le contenu de cette tiquette est souvent recopi dans le volume lui-mme. C'est ce que nous appellerons le nom du volume (en Anglais le label du volume). L'ensemble de ces informations de gestion doivent videmment tre places des endroits prdfinis par le systme de faon lui permettre de les retrouver. Ceci doit tre fait avant de faire un accs quelconque au support. C'est ce que l'on appelle le formatage du volume. Il consiste lui donner un nom, construire la reprsentation de l'espace libre initial et initialiser la structure de donnes qui permet de localiser les objets existants sur le volume.

- 80 -

Dsignation des objets externes Ce formatage peut tre conforme un standard international (ANSI) ou national (AFNOR), ce qui permettra aux utilisateurs d'changer ces volumes pour communiquer des donnes. C'est souvent le cas pour les bandes magntiques. Ce formatage peut galement tre un standard de fait, dfini par un systme et universellement adopt par d'autres systmes, comme par exemple les disquettes MSDOS. Ce formatage peut tre propre un constructeur pour tout ou partie de sa gamme. C'est souvent le cas pour les disques, car ils sont assez peu utiliss pour permettre la communication entre machines, mais essentiellement pour la mmorisation locale. La portabilit n'est pas alors un critre important, alors que l'efficacit de l'exploitation du support l'est.

9.2.2. Le montage de volume


L'opration de montage de volume est constitue de trois tapes: choix du priphrique, montage physique du volume sur le priphrique et modification des tables du systme. Lorsque ces oprations sont termines, le systme connat l'association entre le nom du volume logique et le priphrique. L'utilisateur n'a plus s'en proccuper et peut donc localiser le priphrique par le nom du volume logique. L'opration de dmontage est elle en deux tapes: modification des tables du systme puis dmontage physique. Il est en effet important qu'il y ait accord pralable entre l'oprateur et le systme pour qu'aucun lien ne soit tabli au moment du dmontage physique, ce qui pourrait nuire la cohrence des objets sur le support. Le choix du priphrique, que l'on appelle l'allocation, peut tre fait par le systme de faon automatique. En effet, le systme connat un besoin immdiat d'un programme, soit par la prsence de la dfinition d'un lien dans les commandes qui prcdent la demande d'excution d'un programme, soit par une demande d'tablissement du lien par le programme. Si le volume dsir n'est pas mont, le systme peut alors allouer lui-mme un priphrique parmi ceux qui sont libres, c'est--dire, ceux qui ne sont pas associs un volume, et demander l'oprateur de faire le montage physique du volume concern sur ce priphrique. Cette mthode est surtout applique lorsque la dfinition des liens est donne dans le langage de commandes, car le systme peut anticiper les allocations et faire les choix en fonction de l'ensemble des besoins de tous les programmes qui sont en attente d'excution. L'allocation peut tre faite par l'oprateur, par anticipation, car il a connaissance du besoin avant qu'il ne soit effectivement exprim au systme. C'est souvent le cas lorsque l'on dsire permettre les accs aux objets mmoriss sur un volume pendant une priode dfinie de la journe. Notons que l'oprateur peut constater de visu l'tat libre d'un priphrique par le fait qu'aucun support n'y est actuellement mont physiquement. Le montage physique est une opration manuelle (sauf pour les robots spcialiss de montage de cartouches). L'oprateur retrouve dans un stock plus ou moins important de volumes, celui qui est demand et qui est dsign par son tiquette, et le place sur le priphrique allou. Durant cette opration, le priphrique est dconnect de l'ordinateur, c'est--dire, que celui-ci ne peut y accder. On dit qu'il est en mode local (ou encore off line). Lorsque le placement est termin, l'oprateur le fait passer en mode distant (ou encore on line). Cette opration n'est en gnral pas instantane, car elle demande, par exemple, un positionnement sur les drouleurs de bande, et une mise en rotation sur les tourne-disques. Lorsque le montage physique est termin, le systme doit mettre jour ses tables. Ceci peut tre fait manuellement par une commande de l'oprateur, ou automatiquement lorsque le systme dtecte le passage en mode distant d'un priphrique. Dans ce dernier cas, on dit qu'il y a reconnaissance automatique de volume. Le systme peut alors lire le nom du volume sur le priphrique, et mmoriser dans ses tables ce nom associ au priphrique. Notons que mme si l'allocation de priphrique a t faite par le systme, l'oprateur peut nanmoins placer le volume sur un autre priphrique libre. C'est bien au moment o le systme lit le nom du volume sur le priphrique que l'association est faite. Avant cet instant, il ne s'agit que de propositions.

9.2.3. La relation entre volume et support


La notion de volume est videmment lie au support, ce qui implique des contraintes de taille de l'espace total, qui peuvent tre juges trop fortes. D'une part, un support peut tre de taille trop faible pour contenir un objet externe donn, qui pourtant doit se trouver sur un seul volume. D'autre part, nous avons vu dans le chapitre prcdent qu'un support de trs grande taille tait parfois mal adapt pour recevoir beaucoup de petits objets.
- 81 -

Environnement externe Le premier cas est surtout celui des bandes magntiques. Certains systmes offrent la notion de multi-volumes. Elle peut tre vue comme une facilit du logiciel, de dfinir la localisation du support non plus au moyen d'un volume unique, mais par une collection de volumes. Le systme considrera la collection comme une seule bande, les volumes tant dans l'ordre o la collection est dfinie. Le deuxime cas est celui des disques. Dans ce cas, il est assez courant maintenant de dcouper l'ensemble de l'espace d'un disque en partitions qui sont des portions indpendantes du disque, et qui en tant que tel seront considres comme des supports spars. Chaque partition est ensuite structure en volume. Lorsque le disque est mont, (passage en mode distant), le systme explore son dcoupage en partition pour identifier chacun de ces supports permettant ensuite le montage des volumes qui les structurent. Certains systmes combinent les deux principes, en permettant d'agrger plusieurs partitions situes ventuellement sur des disques diffrents en un seul support qui peut ainsi tre structur en un volume unique. Cela permet d'obtenir un volume de grande taille partir de plusieurs petits disques, ou d'utiliser au mieux de petites partitions restantes parpilles sur plusieurs disques. Notons que la rpartition des donnes d'un volume sur plusieurs disques peut amliorer les performances, car elle permet les accs simultans. Nous verrons d'autres applications dans le chapitre suivant.

9.3. La notion de rpertoire


Lorsque la localisation du support physique est obtenue, il faut localiser l'objet externe sur le support. La mthode qui consiste le localiser explicitement par les informations numriques dont nous avons parl dans le chapitre 8, a t utilise pendant quelques annes, mais s'est avre trs vite inapproprie car elle est beaucoup trop sujette erreurs. Il est plus judicieux de donner, aux objets externes, un nom symbolique constitu d'une chane de caractres. Un rpertoire (ou encore un catalogue, en anglais directory) est en fait une table qui associe le nom symbolique d'un objet externe et le descripteur de cet objet externe, c'est--dire, les informations de localisation de l'objet sur le support ainsi que ses caractristiques. Il est naturel de conserver ces informations sur le support lui-mme, puisqu'elles sont ncessaires si et seulement si le volume correspondant est mont.

9.3.1. Le rpertoire sur bande magntique


Sur une bande magntique, la nature squentielle du support conduit naturellement faire prcder l'objet externe d'un bloc spcial (appel label de fichier) qui contiendra son nom symbolique et ses caractristiques. Aucune information de localisation n'est alors ncessaire, puisqu'il est situ immdiatement derrire, si ce n'est un autre bloc spcial (appel label de fin de fichier) qui en indique la fin. Pour acclrer les accs lors de la recherche d'un objet externe par son nom, la suite des blocs est structure l'aide de blocs drapeaux: ce sont des blocs physiques sur la bande, qui sont crits par des commandes particulires et qui sont reconnus par le matriel mme lorsque le droulement se fait grande vitesse (dfilement rapide avant ou arrire). La figure 9.1 donne un exemple d'une telle structuration. Notons que si le dernier fichier est multi-volumes, la marque de fin de fichier n'est pas prsente, et on trouve directement la marque de fin de volume.
label de volume label de "FIC1" label de "FIC2" label de "FIC3" fin de volume bloc 1 bloc 1 bloc 1 bloc 2 bloc 2 bloc 2 bloc n bloc m bloc p EOF EOF EOF

Fig. 9.1. Exemple de structuration d'une bande magntique. label de fin de fichier.

reprsente un bloc drapeau, EOF le

9.3.2. Rpertoire simple sur disque


Sur disque, le secteur 0 est en gnral ddi pour donner les informations de base sur sa structure. Il faut en effet que ce soit au mme endroit sur tous les volumes, et les fabricants garantissent que ce
- 82 -

Dsignation des objets externes secteur est exempt de tout dfaut. Si le disque est partitionn, son secteur 0 dfinit la carte d'implantation des partitions, et le secteur 0 de chacune d'elles reoit les informations de base sur la structure de la partition. Ce secteur peut donc en particulier contenir le nom du volume, mais aussi la localisation des informations ncessaires la gestion de l'espace libre. Une premire solution consiste rserver une partie ddie de l'espace la reprsentation du rpertoire. Si elle est de taille fixe, cela limite le nombre d'objets externes que l'on peut mettre sur ce disque. Cette taille doit alors tre judicieusement choisie. La localisation du rpertoire peut tre fixe ou variable en fonction du volume. Lorsque sa localisation est variable, elle est en gnrale repre par des informations situes dans le secteur qui contient le nom du volume. Lorsque le disque doit recevoir des objets externes appartenant plusieurs utilisateurs diffrents et indpendants, il peut tre gnant d'avoir un seul rpertoire, car les noms des objets doivent tre distincts, et les utilisateurs doivent alors se mettre d'accord sur les noms qu'ils utilisent. Une solution consiste ajouter implicitement devant les noms des objets les noms des utilisateurs. On peut aussi dcouper le rpertoire en tranche, chaque tranche tant attribue un utilisateur particulier. En fait, on dispose plutt d'un super-rpertoire qui permet la localisation des rpertoires individuels des utilisateurs. Seul ce super-rpertoire doit tre localis de faon absolue, les autres sont considrs comme des objets externes particuliers, qui peuvent tre crs au fur et mesure des besoins. MS-DOS, dans ses premires versions, mais aussi certains gros systmes utilisent cette mthode.

9.3.3. Arborescence de rpertoires


Lorsque le nombre d'objets externes devient important, les solutions prcdentes ne sont plus viables. Dans un systme Unix, par exemple, on a constat qu'il y avait 47000 fichiers sur un disque de 400 Mo. Mme si on suppose que ces fichiers appartiennent 100 utilisateurs diffrents, cela donne 470 fichiers en moyenne par utilisateurs. Mme sur un ordinateur personnel, il n'est pas rare d'avoir prs de 5000 fichiers sur un disque de 500 Mo. Si tous ces fichiers sont reprs dans un rpertoire unique, cela implique d'une part de bien choisir les noms pour n'avoir pas de confusion, d'autre part cela entrane des temps de recherche importants dans le rpertoire. La solution qui est couramment adopte actuellement est de partitionner l'espace des noms des objets externes. Notons que, dans l'approche du paragraphe prcdent, nous avions introduit la notion de super-rpertoire permettant de disposer de rpertoires spars pour les utilisateurs. Ceci nous a conduit considrer qu'un rpertoire tait un objet externe particulier. La gnralisation de cette ide consiste considrer qu'un rpertoire est une table qui associe un nom et un descripteur d'objet externe au sens large, c'est--dire fichier de donnes manipul par un programme, ou rpertoire. Au lieu d'un rpertoire plat, on obtient une arborescence de rpertoire, dont seule la racine est localise de faon absolue.
documents appl_graph spcifications program sources objets includes module1.c module2.c

graph.spec

graph.doc

lib_objets module1.o module2.o

Fig. 9.2. Exemple d'arborescence de rpertoire. La figure 9.2 donne un exemple d'une telle arborescence. Le rpertoire racine contient trois entres pour les rpertoires de nom documents, appl_graph et specifications. Le rpertoire
- 83 -

Environnement externe contient aussi trois entres, la premire associe le nom program et un fichier, alors que les deux autres associent les noms sources et objets avec deux rpertoires. Enfin, le rpertoire sources contient une entre pour le rpertoire includes et deux entres pour les fichiers de nom module1.c et module2.c. Cet exemple montre tout le bnfice qu'un utilisateur peut retirer d'une arborescence, en regroupant dans un mme rpertoire des entits qui prsentent une proprit de cohrence donne. Ainsi, le rpertoire documents pourrait regrouper les fichiers de documentation, et le rpertoire sources regrouper les fichiers sources de l'application appl_graph, dont includes constitue le sous-groupe des fichiers qui peuvent tre inclus dans les fichiers sources par les prprocesseurs.
appl_graph

La dsignation d'un objet externe doit permettre d'une part d'identifier le volume qui contient l'objet et d'autre part de localiser l'objet sur ce volume. Lorsqu'on a une arborescence de rpertoires, la localisation de l'objet sur le volume consiste donc dfinir le chemin depuis la racine jusqu' l'objet dans cette arborescence. C'est donc une suite de noms qui doivent tre utiliss, pour dsigner la suite des rpertoires parcourir pour atteindre l'objet recherch. Chacun de ces noms permet de dsigner le rpertoire suivant (ou l'objet recherch) dans le rpertoire courant. Un nom tant une chane de caractres, il est courant de dfinir une structure lexicale rudimentaire qui permet de dfinir sous la forme d'une seule chane de caractres l'identification du volume et la suite de noms prcdente. C'est ce que l'on appelle le nom absolu de l'objet ou encore le chemin d'accs l'objet (en Anglais le pathname). Par exemple, les versions rcentes de MS-DOS utilisent le caractre : comme sparateur entre le nom du volume (en fait le nom symbolique du priphrique) et le nom de l'objet sur le volume, et le caractre \ comme sparateur entre les noms de rpertoires, ce que l'on peut noncer de la faon suivante:
[nom_de_volume:]{\nom_rpertoire}\nom_objet

Ainsi le nom absolu C:\appl_graph\sources\module1.c dsigne un objet sur le volume C. Sur ce volume, il faut rechercher dans le rpertoire racine le rpertoire appl_graph, puis dans celui-ci le rpertoire sources, et dans ce dernier l'objet module1.c.

9.4. Construction d'une arborescence unique la Unix


La structure de dsignation laquelle nous venons d'aboutir dans le paragraphe prcdent s'apparente une arborescence unique: la racine se trouve la dsignation des volumes ou des priphriques, permettant l'accs une sous-arborescence locale chaque volume. Le systme Unix prsente l'utilisateur l'ensemble des objets sous une vritable arborescence unique et une dsignation uniforme dans cette arborescence.

9.4.1. Les fichiers spciaux comme priphriques


On peut remarquer qu'une entre particulire d'un rpertoire associe un nom, local au rpertoire, et un descripteur d'objet. Si l'objet est un fichier au sens classique du terme, le descripteur doit contenir les caractristiques du fichier (organisation, par exemple) et les informations de localisation du contenu. Si l'objet est un rpertoire, le descripteur doit contenir galement les caractristiques, en particulier, l'indication qu'il s'agit d'un rpertoire, et les informations de localisation du contenu. Ce descripteur doit donc permettre de distinguer la nature fichier ou rpertoire de l'objet associ. L'ide des concepteurs d'Unix est que l'on peut crer un descripteur de nature diffrente des prcdentes, appel fichier spcial , pour dsigner cette fois un priphrique de l'installation. Un tel descripteur contient, en particulier, un numro de priphrique majeur qui dtermine le type du priphrique (terminal, disque, bande, etc...) et un numro de priphrique mineur qui dtermine le priphrique particulier du type correspondant. videmment ces numros n'ont de sens que sur une installation donne. Dans la plupart des installations, un rpertoire particulier (/dev) regroupe les descripteurs de tous les priphriques, et les noms locaux qui leur sont associs. Par exemple /dev/lp dsigne l'objet de nom lp dans le rpertoire de nom dev situ la racine. C'est la nature du descripteur de l'objet qui permet au systme de constater qu'il s'agit de l'imprimante de l'installation. L'intrt est donc essentiellement dans la dsignation uniforme ainsi obtenue.
- 84 -

Dsignation des objets externes

9.4.2. Le montage de volume dans Unix


Comme nous l'avons dit, un volume contient sa propre arborescence locale qui permet la dsignation des objets sur le volume. Pour obtenir une arborescence unique lorsque l'on monte un volume, il faut raccrocher cette arborescence locale quelque part dans l'arborescence courante. L'option adopte par le systme est de permettre de la raccrocher n'importe o, la place d'un rpertoire. L'arborescence locale vient alors remplacer la sous-arborescence issue de ce rpertoire. En gnral, on utilise un rpertoire vide, mais ce n'est pas obligatoire. Si ce n'est pas le cas, les objets qu'il contenait sont momentanment inaccessibles. arborescence initiale:
bin developt users

toto cp

arborescence finale:

bin developt users documents appl_graph spcifications program sources objets includes module1.c module2.c

toto

cp

graph.spec

graph.doc

lib_objets module1.o module2.o

Fig. 9.3. Exemple de montage d'un volume dans Unix. L'arborescence locale du volume remplace l'arborescence de /developt. La figure 9.3 montre le rsultat du montage du volume dont l'arborescence a t prsente en figure 9.2, sur le rpertoire de nom absolu /developt dans l'arborescence initiale. Lorsque le montage est termin, on accde aux objets du volume en faisant prcder le nom local de l'objet sur le volume par le nom absolu du rpertoire sur lequel le volume a t mont, comme, par exemple, dans:
/developt/appl_graph/sources/module1.c

En gnral les oprations de montage sont effectues par l'oprateur qui choisit le priphrique (allocation manuelle) et le rpertoire sur lequel les volumes sont monts. Pour l'utilisateur, il ne voit qu'une arborescence unique, et n'a plus se proccuper du support de ses objets. Comme les priphriques sont aussi dsigns dans l'arborescence, il a donc un mcanisme uniforme de dsignation de tous les objets externes.

- 85 -

Environnement externe

9.4.3. Les fichiers multi-rpertoires


Lorsque plusieurs utilisateurs travaillent sur un projet commun, ils doivent pouvoir accder des fichiers qu'ils ont en commun. En fonction de ce que nous avons dit ce n'est pas difficile, puisque tout objet a un nom absolu. Il arrive souvent que chacun aimerait le voir un endroit prcis de l'arborescence, qui n'est pas le mme pour tous. Certains systmes qui offrent une arborescence de fichiers (VMS, Unix, Multics) permettent de situer un mme fichier plusieurs endroits de cette arborescence. videmment, nous n'avons plus tout fait un arbre, mais un graphe orient sans cycle. Deux mthodes sont utilises pour cela. La premire utilise ce que l'on appelle les liens physiques . Ils ne sont autoriss que pour les fichiers de donnes (et donc interdits pour les rpertoires ou les fichiers spciaux). Pour pouvoir prendre en compte les liens physiques, les descripteurs d'objets ne sont pas mis dans les rpertoires, mais dans une zone particulire du disque, et sont reprs par un numro appel i-nud dans le systme Unix. Les rpertoires associent les noms symboliques locaux et les numros de descripteurs d'objets. Il est ainsi possible de crer une autre association entre un nom et ce numro dans un autre rpertoire. Le fichier possde alors deux (ou plus) noms absolus. L'utilisateur ne dtruit plus les objets directement, mais les liens physiques vers ces objets. La destruction d'un objet externe intervient lorsque le systme constate qu'il n'y a plus de lien physique pour cet objet. videmment si un utilisateur dtruit un lien physique dans un rpertoire vers un objet commun, et recre un nouvel objet de mme nom dans ce rpertoire, l'objet ancien reste dsign par ses autres noms symboliques absolus. La deuxime mthode utilise ce que l'on appelle les liens symboliques. Lorsque l'on cre un lien symbolique n dans un rpertoire pour un objet O situ ailleurs, le systme n'associe pas le nom local avec le descripteur de l'objet O, mais avec le nom symbolique absolu de l'objet O. L'objet O peut d'ailleurs ne pas exister au moment o l'on cre le lien symbolique. Par contre lorsque l'on cherche accder l'objet par le nom n, le systme interprtera ce moment le nom symbolique absolu qui lui est associ pour trouver O. videmment comme le nom symbolique absolu est rinterprt chaque dsignation qui utilise n, cela est plus coteux, mais on est sr alors de ne pas trouver une ancienne version de l'objet. Par ailleurs, les liens symboliques sont autoriss pour les objets de toute nature, y compris les rpertoires. Cette mthode se gnralise bien aux systmes rpartis.

9.4.4. La dsignation par rapport l'environnement


L'arborescence de rpertoire conduit une dsignation des objets relativement longue. On a donc cherch allger cette dsignation. De fait, si une installation comporte plus de 100 000 objets externes, un utilisateur n'a besoin d'accder qu' une petite partie d'entre eux un instant donn. Plusieurs solutions ont t proposes, en particulier, la notion de rpertoire de travail et la notion de rgles de recherche. Pour tout utilisateur actif, le systme privilgie un rpertoire particulier de l'arborescence, et que l'on appelle le rpertoire de travail. Des commandes permettent l'utilisateur de changer son rpertoire de travail tout instant. Outre la dsignation des objets par leur nom absolu, c'est--dire, en partant de la racine de l'arborescence, l'utilisateur peut dsigner un objet en donnant son chemin d'accs partir de ce rpertoire courant. En Unix, tout chemin d'accs ne commenant pas par / est considr comme relatif au rpertoire courant. Il en va de mme pour MS-DOS, si le chemin ne commence pas par \. Pour permettre de remonter dans l'arborescence, chaque rpertoire de ces systmes contient une entre, dont le nom est prdfini .., qui est associe au rpertoire situ audessus dans l'arborescence. Pour tre complet, signalons qu'il existe une deuxime entre de nom prdfini . qui est associe au rpertoire lui-mme. Ainsi, aprs la commande suivante qui dfinit le rpertoire courant:
cd /developt/appl_graph/sources

le fichier de nom absolu /developt/appl_graph/sources/module1.c peut tre dsign simplement par module1.c. La notion de rgles de recherche consiste dfinir une liste de noms absolus de rpertoires qui sont utiliss pour la recherche d'un objet dans un contexte particulier. Par exemple, on dfinit couramment une liste de rpertoire pour la recherche du programme excutable d'une commande, ce qui vite de devoir se rappeler dans quel rpertoire il est situ. De mme, on peut dfinir une liste de rpertoire dans lequel il faut rechercher les fichiers d'un manuel en ligne du systme. Ces rgles
- 86 -

Dsignation des objets externes de recherche peuvent tre dfinies implicitement par le systme, et modifiables au gr de l'utilisateur qui peut ainsi adapter son environnement sa convenance.

9.5. Conclusion
La dfinition d'une liaison doit permettre de localiser le support physique de l'objet, de localiser l'objet sur le support et de dterminer les caractristiques de l'objet. Elle est donne soit par le langage de commande soit par les programmes. Un volume est un support d'informations. Pour tre accessible il doit tre mont physiquement sur un priphrique et logiquement reconnu par le systme, c'est--dire que le systme associe ce priphrique son nom. Le formatage d'un volume consiste lui donner une structure qui comporte en particulier son nom, la reprsentation de l'espace libre et les structures de donnes ncessaires la localisation des objets qu'il contient. Un rpertoire est une table qui associe un nom symbolique et le descripteur d'un objet externe. Mmoris sur un volume, il permet de localiser les objets de ce volume. Lorsque le nombre d'objets est grand, on utilise une arborescence de rpertoire. Le chemin d'accs un objet est la concatnation du nom de volume sur lequel il se trouve et de la suite des noms dans les rpertoires de l'arborescence qui permet de l'atteindre. Unix construit une arborescence unique pour tous les objets, y compris les priphriques, qui ont ainsi une dsignation uniforme qui permet l'utilisateur de s'abstraire des priphriques. Les liens physiques ou symboliques permettent de donner plusieurs noms absolus aux objets. La dsignation peut tre allge en faisant rfrence l'environnement, au moyen de la notion de rpertoire de travail et de rgles de recherche.

- 87 -

10

La scurit et la protection des objets externes

L'utilisateur qui confie des donnes un systme informatique s'attend un certain service, et en particulier, dsire une certaine garantie de retrouver ses donnes tout moment, dans l'tat exact o il les a laisses. Nous distinguerons d'une part, une altration due une mauvaise utilisation des oprations sur les donnes et d'autre part, une altration de ces donnes par suite de dfaillance du matriel ou du logiciel. Dans le premier cas, on parle de protection pour dsigner l'ensemble des mthodes qui spcifient les rgles d'utilisation des oprations. Dans le deuxime cas, on parle de scurit pour dsigner l'ensemble des mthodes qui assurent que les oprations se droulent conformment leur spcification, mme en cas de dfaillance. La scurit concerne la spcification de chaque opration, alors que la protection concerne les rgles d'utilisation des oprations.

10.1. Les mcanismes de protection


10.1.1. La protection par droits d'accs
Le premier mcanisme propos par de nombreux systmes est bas sur la notion de droits d'accs. Pour chaque objet externe et pour chaque utilisateur, on dfinit les oprations qui sont autorises. Lors d'une demande d'tablissement d'un lien entre un programme et un objet externe, les paramtres de la demande prcisent les oprations que le programme dsire effectuer sur l'objet externe, et le systme vrifie que l'utilisateur, pour le compte de qui travaille le programme, est bien autoris effectuer ces oprations. En gnral, on distingue peu d'oprations diffrentes sur les objets externes. Les oprations essentielles sont la lecture, l' criture et ventuellement l'excution, sauf pour les rpertoires o les oprations essentielles sont la recherche, la cration et la modification d'une entre, en plus de l'opration de lecture de l'ensemble des entres, pour en faire une liste. Dans Unix les droits d'un utilisateur sur un objet sont dfinis par trois bits appels rwx: r correspond au droit de lire le contenu de l'objet quelle que soit sa nature, w correspond au droit de modifier le contenu de l'objet quelle que soit sa nature, x sur un rpertoire permet d'y rechercher une entre, alors que sur les autres objets, il permet de l'excuter. Par ailleurs, lorsque le nombre d'utilisateurs du systme est important, il n'est gure envisageable de disposer pour chaque objet des droits d'accs cet objet pour chacun des utilisateurs pris individuellement. D'une part ceci conduirait une occupation d'espace qui ne serait pas ngligeable, mais d'autre part ceci demanderait tre dfini lors de chaque cration d'objet. Les systmes

- 89 -

Environnement externe proposent en gnral des restrictions sur cette dfinition, et des rgles implicites de dfinitions. Il est courant, par exemple, d'tablir des groupes d'utilisateurs, et de dfinir les droits par groupe. Multics a introduit la notion de projet, pour regrouper des utilisateurs; tout utilisateur lors de son identification par le systme (login), indique implicitement ou explicitement le projet sous lequel il dsire travailler. La protection peut alors tre dfinie par projet, c'est--dire, globalement pour tous ceux qui travaillent sous ce projet, ou par utilisateur quel que soit le projet, ou enfin pour un utilisateur particulier lorsqu'il travaille sous un projet donn. Par exemple, la dfinition des droits
<r, COMPTABLE.*>, <rw, COMPTABLE.Jean, *.Paul> permet tous ceux qui travaillent sous le projet COMPTABLE de peuvent le lire et y crire, d'une part Jean lorsqu'il travaille sous

lire l'objet externe, alors que ce projet, et d'autre part Paul

quel que soit le projet sous lequel il travaille. Dans Unix, on dfinit galement la notion de groupe d'utilisateurs, mais pour simplifier la reprsentation de l'ensemble des droits d'accs un objet externe, on ne peut les dfinir que pour trois catgories d'utilisateurs: le propritaire, les membres d'un groupe donn attach l'objet et les autres. Dans l'exemple prcdent, si Jean est propritaire de l'objet et membre du groupe COMPTABLE attach l'objet, on peut dfinir les droits suivants: propritaire, r aux membres du groupe, et aucun accs aux autres. Remarquons que l'on ne peut fournir l'accs rw Paul dans ce cas, moins de devoir le fournir tous. Windows NT utilise galement la notion de groupe d'utilisateurs, un utilisateur pouvant appartenir plusieurs groupes en mme temps. A chaque objet est associe une liste de contrle d'accs. Par exemple,
<~r, Pierre>, <r, COMPTABLE>, <rw, Paul> rw- r-- --c'est--dire rw au

interdit Pierre la lecture de l'objet, mme s'il appartient au groupe COMPTABLE, permet tous ceux du groupe COMPTABLE de lire l'objet externe, et autorise Paul lire et crire dans l'objet. Notons que, dans ce systme, la nature des accs contrls sont plus tendus que ceux vus jusqu' maintenant. Certains sont standards quelque soit le type de l'objet, comme par exemple le droit de supprimer l'objet, d'autres sont dfinis en mme temps que la dfinition de ce type. Dans beaucoup de systmes les utilisateurs sont rattachs un numro de compte qui sert la facturation du cot machine. Dans l'entreprise, ce numro de compte dsigne alors un service ou un dpartement. La dfinition des droits d'accs se fait alors en donnant la liste des numros de compte autoriss lire et ceux autoriss crire.

10.1.2. La protection par mot de passe


Le deuxime mcanisme de protection est li l'utilisation de mots de passe. Lorsqu'un programme demande d'tablir un lien avec un objet externe, le systme recherche, dans une premire tape, l'objet lui-mme. S'il le trouve, et que son descripteur indique la prsence d'un mot de passe, le systme interrompt provisoirement l'opration d'ouverture, avec un code d'erreur particulier. Le programme peut rcuprer cette erreur et excuter une squence d'instructions qui a pour but de fournir le mot de passe. Au retour de cette squence d'instructions, le systme contrle la validit de ce mot de passe, et termine l'ouverture correspondante. Si le programme n'a pas prvu de rcuprer cette erreur, ou s'il l'a rcupre mais n'a pas fourni le bon mot de passe, la liaison n'est pas tablie, et le programme arrt. Un mcanisme analogue est mis en place lors de la cration d'un objet avec mot de passe. De cette faon, le mot de passe n'apparat pas dans le langage de commande qui dfinit la liaison, mais est toujours fourni par le programme lui-mme. Notons que la protection par mot de passe n'est efficace que si les mots de passe ne sont pas divulgus, et ne peuvent tre dcouverts qu'avec grande difficult.

10.2. Les mcanismes de scurit


Le problme de la scurit est en grande partie li aux dfaillances du matriel ou du logiciel. Il est plus ou moins bien rsolu par deux mthodes, la redondance d'informations et la sauvegarde priodique. Notons que la sauvegarde priodique est galement une certaine forme de redondance.

- 90 -

Scurit et protection

10.2.1. La scurit par redondance interne


La redondance interne consiste structurer les donnes de telle sorte que toute information de structure puisse tre dtermine de deux faons au moins, l'une tant l'information dite primaire, l'autre tant l'information secondaire. L'information primaire est l'information de base, l'information secondaire est souvent utilise pour acclrer les accs. On vrifie en permanence la cohrence entre les informations primaires et les informations secondaires. En cas d'incohrence, ou de perte des informations secondaires on utilise les informations primaires pour reconstruire les informations secondaires. On peut imaginer par exemple que chaque secteur (ou ventuellement bloc) du disque comporte deux parties, l'en-tte et le contenu. L'en-tte contient les informations primaires permettant de savoir quel objet appartient ce secteur, quelle est sa position relative dans l'objet (numro logique) et quelle est sa position absolue sur le disque. Le contenu est la partie de l'objet externe qui est mmorise dans ce secteur. Les informations primaires ne sont pas utilises pour localiser les objets ou les parties d'objets, mais pour contrler que le secteur accd est bien celui qui est recherch, c'est--dire, qu'il appartient bien l'objet, qu'il correspond bien la position physique demande sur le disque et la position relative demande dans l'objet. L'objet lui-mme peut tre complt par un en-tte mmoris dans un secteur dont le contenu contient la dsignation symbolique absolue de l'objet ainsi que des informations complmentaires situes dans le descripteur (protection, identification du propritaire, nature, etc...). Cet en-tte est galement une information primaire. Les informations secondaires sont situes dans les divers rpertoires et les descripteurs des objets, qui sont utiliss normalement pour les accs efficaces. En cas d'anomalie, on voit qu'il est possible (mais long) de parcourir tous les secteurs du disque pour accder aux informations primaires, et reconstruire les informations secondaires correspondantes. Un mcanisme de ce type a t mis en uvre dans l'Alto et le systme Pilot de Xerox. Certains contrleurs de disques implantent une partie de cette mthode, en mmorisant dans l'en-tte des secteurs, lors du formatage, le numro de disque, cylindre, face et secteur, et vrifient la concordance lors de la lecture ou l'criture d'un secteur. Cette mthode est en fait assez lourde, et occupe de la place. Aussi beaucoup de systmes ne l'appliquent que partiellement. Par exemple, MS-DOS dispose de deux exemplaires de la FAT sur le disque. Un seul exemplaire est lu en mmoire centrale lorsque ncessaire, la recopie sur disque tant faite systmatiquement dans les deux exemplaires. S'il s'avrait que le systme soit incapable de relire le premier exemplaire, il accderait alors au second, et le recopierait immdiatement dans le premier. De mme, dans la plupart des systmes, la reprsentation de l'espace libre sur disque est une information secondaire. Elle peut tre reconstruite en recherchant les secteurs qui ne sont pas actuellement allous un objet externe.

10.2.2. La scurit par sauvegarde priodique


La redondance peut tre obtenue par sauvegarde priodique. Il s'agit alors de prendre une copie exacte de l'ensemble des objets externes et de leur structure. Cependant, l'important est plus de pouvoir reconstruire la structure que de pouvoir utiliser la copie. Il s'ensuit que la sauvegarde peut se faire sur un support moins coteux, comme par exemple sur bandes magntiques. Si l'on sauvegarde la totalit des objets, on dit que l'on a une sauvegarde complte . Il faut noter cependant que, avec un dbit de 500 Ko/s, il faut 35 minutes et 7 bandes pour sauvegarder 1 Go. C'est pourquoi, on ne peut la faire trop souvent. On vite cette difficult tout d'abord en faisant la sauvegarde par volume. Pour avoir des volumes dont la taille soit raisonnable pour ces sauvegardes, certains systmes (MS-DOS ou Unix) permettent de partitionner un disque physique en plusieurs volumes indpendants. La notion d'arborescence unique telle qu'on la trouve dans Unix permet de cacher ce partitionnement l'utilisateur, tous les volumes d'un disque donn tant monts en mme temps par l'oprateur. Il est alors judicieux de faire en sorte que les objets soient placs sur les volumes en fonction de leur plus ou moins grande volution dans le temps. Par exemple, on peut ddier un volume l'ensemble des objets externes des utilisateurs, ou un volume par groupe d'utilisateurs; un autre volume peut tre rserv la documentation en ligne du systme, un volume l'ensemble des outils courants de la chane de production de programmes, etc... La sauvegarde priodique ne doit alors concerner que
- 91 -

Environnement externe les volumes des utilisateurs, les autres n'tant pas modifis pendant de longues priodes. On parle parfois de sauvegarde de reprise dans ce cas. L'inconvnient de la sauvegarde par volume telle qu'elle vient d'tre prsente est de sauvegarder systmatiquement les objets du volume, mme s'ils n'ont pas t modifis depuis la dernire sauvegarde. On peut viter cet inconvnient si pour chaque objet on connat la date de sa dernire modification: il suffit de ne sauvegarder que ceux dont cette date est postrieure la dernire sauvegarde. C'est ce que l'on appelle la sauvegarde incrmentale. Priodiquement, un programme spcial est activ, qui parcourt l'ensemble des objets de l'arborescence unique (ou par volume), et recopie sur bande ceux qui ont t modifis depuis la dernire sauvegarde priodique. En gnral, on ne recopie que les objets qui ne sont pas ouverts en modifications, pour garantir que la copie soit intrinsquement cohrente. Lorsqu'on constate une incohrence ou une perte d'objets, il faut restituer leur tat le plus rcent partir des sauvegardes. Ceci est obtenu en remontant les sauvegardes incrmentales successives, jusqu' trouver l'objet concern. Pour viter de devoir remonter trop loin dans le temps, on effectue de temps en temps des sauvegardes de reprise, qui permettent d'arrter cette recherche. Par ailleurs, lorsque la totalit du volume est perdu, on utilise alors la dernire sauvegarde de reprise de ce volume pour restaurer le volume dans un tat initial, sur lequel on applique ensuite les modifications constates dans les sauvegardes incrmentales postrieures, dans l'ordre des dates. Pour faciliter l'accs aux sauvegardes incrmentales, celles-ci sont parfois ralises sur un disque ddi. Comme, en principe, la proportion des objets modifis est faible par rapport l'ensemble des objets, cela ne ncessite pas de doubler l'espace disque total de l'installation. La priodicit et la dure de conservation des sauvegardes dpendent de leur nature. Le tableau suivant donne une ide de la valeur de ces paramtres. nature de la sauvegarde priode conservation incrmentale 8 heures 15 jours reprise 7 jours 3 mois complte 1 mois 1 an Notons que cela implique de conserver au total 45 sauvegardes incrmentales, 13 sauvegardes de reprise et 12 sauvegardes compltes. Si on suppose qu'une sauvegarde incrmentale reprsente 5% de l'ensemble des objets, cela ne reprsente qu'un peu plus de 2 sauvegardes compltes. La conservation reprsente donc, en capacit, 27 fois l'espace total. La sauvegarde complte doit tre excute sans qu'aucun accs aux objets ne soit autoris, de faon reprsenter une vritable photographie de l'tat de l'ensemble des objets. Cela prendra donc 6 heures pour 10 Go. Les sauvegardes de reprise ne doivent pas tre effectues pour l'ensemble des objets, mais par volume. On peut donc les rpartir sur tous les jours de la semaine, en sauvegardant par exemple 1,4 Go par jour, ce qui prendra environ 50 minutes. Lors de la sauvegarde de reprise d'un volume, ce volume ne doit pas tre modifi par les utilisateurs. Enfin les sauvegardes incrmentales porteront sur 500 Mo, et prendront environ 17 minutes. Notons que celle-ci est faite sans gne pour les utilisateurs, l'ensemble des objets restant accessibles. L'ensemble de la procdure peut paratre coteuse, mais c'est le prix payer pour offrir un minimum de service continu fiable aux utilisateurs. Par ailleurs, les procdures dcrites n'offrent qu'une scurit limite, puisque la sauvegarde incrmentale n'est effectue que toutes les 8 heures dans notre proposition. Si un incident survient juste la fin de la priode, le travail effectu dans la priode est perdu. Dans un systme temps partag, le risque tant faible est considr comme supportable. Dans un contexte transactionnel, ce n'est souvent pas acceptable. Les mcanismes mis en uvre sont alors ddis la base de donnes, mais sont assez voisins dans le principe: un fichier journal mmorise les modifications successives et joue le rle de sauvegarde incrmentale permanente.

10.2.3. Les disques tolrance de panne


La capacit des disques est devenue telle que la sauvegarde des informations peut prendre un temps considrable. D'un autre ct, leur prix n'est plus un critre conomique important. On a donc imagin des solutions qui permettent de grer une certaine redondance des donnes pour diminuer les risques de perte entre deux sauvegardes espaces. C'est ce que l'on appelle les disques RAID
- 92 -

Scurit et protection pour Redundant Array Inexpensive Disks. 5 types de RAID (1..5) ont t dcrits initialement, et 2 sont effectivement utiliss (1 et 5). Avant de les prsenter, rappelons que nous avons vu en 9.2.3 qu'un volume pouvait tre constitu de plusieurs partitions situes sur des disques diffrents. Lorsque ces partitions sont de mme taille, il est possible de les dcouper en bandes de tailles gales, chaque partition contenant le mme nombre de bandes. On peut alors entrelacer les bandes sur les diffrentes partitions comme indiqu sur la figure 10.1: le volume commence sur la bande 1, se poursuit sur la bande 2, puis la bande 3, etc. Notons que, en dehors de tout aspect de tolrance aux pannes, cette organisation rpartit les accs sur l'ensemble des partitions et amliore les performances. Ceci est parfois appel RAID-0.
1 5 9 13 17 partition a 2 6 10 14 18 partition b 3 7 11 15 19 partition c 4 8 12 16 20 partition d

Fig. 10.1. Entrelacement des bandes sur quatre partitions. Les deux niveaux de RAID intressants sont les suivants: RAID-1, ou encore disques miroirs. La redondance est obtenue en crivant les donnes sur 2 disques ou plus. En fait deux partitions sont ncessaires, par exemple les partitions a et b, qui sont des copies l'une de l'autre. Lorsque la bande 1 est crite, elle est duplique sur la bande 2, et ainsi de suite. Les lectures, par contre, peuvent tre faites sur n'importe laquelle des partitions. En cas de panne sur l'un des deux disques, les donnes sont encore accessibles sur l'autre, sans aucune perte. On peut constater que la moiti de l'espace disque est occup par la redondance. RAID-5, ou encore disques avec parit. En reprenant la figure 10.1, pour chaque ligne horizontale, l'une des bandes est la bande de parit des trois autres ("ou exclusif", not XOR); ainsi b4 = b1 XOR b2 XOR b3. Lors d'une criture de b1, b2 ou b3, le systme calcule la bande de parit b4 et l'crit dans la partition d. Notons qu'il n'est pas ncessaire de connatre toutes les bandes pour calculer b4: lorsqu'on change b1 en b1', la nouvelle valeur de la bande b4, est obtenue par b4' = b4 XOR b1 XOR b1'. Pour que le disque de la partition d ne soit pas surcharg, on rpartit les bandes de parits sur l'ensemble des partitions, par exemple la suivante sera b5, puis b10, puis b15, etc. En cas de panne sur le disque de la partition a, on peut reconstruire la bande b1 = b2 XOR b3 XOR b4. Notons que, si on utilise n disque, 1/n de l'espace est occup par la redondance. Evidemment, au moment d'une panne, on passe un fonctionnement sans redondance. Cela peut tre une panne locale, par exemple dans le cas d'un bloc dfectueux sur le disque, et il suffit d'allouer un bloc de remplacement et de reconstruire son contenu. Cela peut tre une panne du disque complet qu'il faut alors remplacer, et reconstruire ensuite les donnes sur ce nouveau disque. On peut voir que dans chaque cas, on augmente le nombre d'criture effectuer sur disque. Cependant, ces critures tant sur des disques distincts, peuvent tre excutes en parallle, si le systme le permet. Par ailleurs, les systmes pratiquent de plus en plus l'criture paresseuse: une demande d'criture par un programme d'applications entrane la modification de tampons en mmoire centrale et la reprise de l'excution du programme. L'criture effective sur le disque est diffre un moment ultrieur. Notons que ces techniques peuvent tre ralises dans le contrleur des disques, l'ensemble tant vu du systme comme un seul disque. De plus, il est parfois possible de remplacer un disque de l'ensemble sans arrter le systme.

10.3. Conclusion
La protection a pour but de se prmunir contre les altrations des donnes des une mauvaise utilisation des oprations. La protection par droit d'accs permet de dfinir quels sont les utilisateurs qui sont autoriss effectuer une opration donne sur l'objet.
- 93 -

Environnement externe La protection par mot de passe consiste autoriser les accs si l'utilisateur fournit le bon mot de passe. La scurit a pour but de se prmunir contre les altrations des donnes par suite d'une dfaillance du matriel ou du logiciel. La scurit par redondance interne consiste disposer des informations de structure de plusieurs faons, et de contrler la cohrence entre elles. La scurit par sauvegarde priodique consiste recopier rgulirement tout ou partie des objets externes sur un autre support, pour permettre de les restituer en cas d'incident. Un systme RAID est un ensemble de disques o l'un d'eux contient des informations redondantes de celles contenues dans les autres, et qui permet de ne perdre aucune information en cas de panne de l'un des disques de l'ensemble.

- 94 -

11

Quelques exemples de SGF

Pour terminer cette partie, nous allons prsenter brivement quelques systmes de gestion de fichiers (SGF), dont nous avons dj abords certains aspects titre d'exemple particuliers. Nous dcrirons surtout la structure, sans entrer dans le dtail des algorithmes utiliss par les systmes, et qui peuvent voluer d'une version l'autre.

11.1. Les systmes FAT et VFAT


VFAT est une extension de FAT dont nous avons dj parl. Ces SGF sont capables de grer des partitions dont la taille est limite 2 Go. Cet espace est constitu de 3 parties: la FAT proprement dite, ventuellement duplique, le rpertoire racine du volume, les donnes des objets externes du volume.

11.1.1. Reprsentation de l'espace


L'allocation d'espace se fait par bloc de taille fixe, appels cluster, qui est constitu d'un nombre entier de secteurs (au plus 255). Les clusters ont un numro sur 16 bits (au plus 65 535). La FAT a un double rle: dterminer les clusters occups, ceux qui sont libres et ceux qui sont invalides et pour lesquels il y a eu des erreurs de lecture auparavant, dterminer pour chaque cluster allou un objet externe quel est le cluster suivant de cet objet. L'allocation d'espace se fait bloc par bloc, par un parcours squentiel de la FAT. Lors d'un parcours squentiel d'un fichier logique, le systme suivra la liste chane des clusters. Lors d'un accs alatoire, il devra galement effectuer ce parcours depuis le dbut de l'objet externe jusqu'au cluster recherch.

11.1.2. Les rpertoires


Ce systme utilise une arborescence de rpertoires, la racine de cette arborescence tant situe derrire la FAT. Notons que cette racine peut contenir 512 entres, alors que les autres rpertoires peuvent en contenir un nombre quelconque. Une entre d'un rpertoire contient 32 octets et est constitue comme suit: Le nom du fichier sous la forme dite "8.3", c'est--dire, 8 caractres avant le point et 3 aprs. Ces noms doivent commencer par une lettre et sont insensibles la casse (pas de diffrenciation entre les majuscules et les minuscules).
- 95 -

Environnement externe Un ensemble d'attributs prcisant, entre autre, la nature de l'objet externe (fichier ou rpertoire) et sa protection (criture autorise). L'heure et la date de dernire modification de l'objet externe. Le numro du premier cluster de l'objet externe. La longueur utile en octet de l'objet externe sur 32 bits. De plus,10 octets sont inutiliss. Un rpertoire contient toujours deux entres particulires: "." qui dsigne le rpertoire lui-mme et ".." qui dsigne le rpertoire parent. Notons ici une extension apporte par le systme VFAT, pour permettre les noms longs. Lors de la cration d'un nom de fichier, qui peut tre sur 255 caractres, le systme cre en fait 2 noms: l'un est le nom origine, l'autre est un alias sous la forme DOS 8.3 construit partir du nom long. Le nom DOS occupe une entre du rpertoire, et les entres suivantes contiennent les tranches successives de 13 caractres du nom long. Un tel nom long peut donc occuper jusqu' 21 entres! Comme le rpertoire racine est limit 512 entres, ceci a pour consquence de limiter 24 objets externes ce rpertoire si on utilise des noms de 255 caractres ce niveau. Notons que si le systme FAT (et VFAT) a t cr par Microsoft pour le DOS, il est maintenant compatible avec un grand nombre de systmes. Par ailleurs, on peut noter qu'il permet une assez bonne occupation de l'espace et devrait donc tre rserv de petites partitions.

11.2. Les systmes HFS et HFS Plus de MacOS


Le systme HFS Plus est une nouvelle version de SGF, introduite par Apple pour pallier certaines limites de HFS, tout en reprenant les mmes concepts. Nous allons dcrire HFS, et montrerons les volutions. Une partition HFS (Hierarchical File System) est constitue de 6 parties: Les informations de dmarrage du systme permettent, par exemple, de localiser le systme dans la partition, ou de connatre la taille des tampons internes, etc. Cette partie contient des zros si la partition n'est pas une partition de dmarrage. Le descripteur du volume. On y trouve, en particulier, le nom du volume (limit 27 caractres), ainsi que des informations diverses sur la structure du volume. La table bitmap dcrivant l'tat d'allocation du volume. Le catalogue des fichiers et rpertoires. Le fichier de description des extensions. Les espace des objets externes du volume. Les objets externes (fichiers et rpertoires) crs sur le volume reoivent un numro interne unique d'identification que nous applerons Num-ID. Ce numro est dfini la cration du fichier ou du rpertoire.

11.2.1. La reprsentation de l'espace.


HFS utilise le principe de l'allocation par zone, un objet externe pouvant avoir un nombre quelconque de zones chacune tant de taille quelconque (cf. 8.2.3). La taille du quantum est un nombre entier de secteurs. Nous utiliserons le terme de bloc pour dsigner les units d'allocation. Les blocs sont numrots sur 16 bits, limitant 65536 le nombre de ces blocs. Ceci a deux consquences: La table bitmap voque ci-dessus est de taille fixe d'au plus 8 Ko. La taille d'un quantum est gal au moins la taille de la partition divise par 65536, soit 64 Ko pour une partition de 4 Go. Nous verrons ci-dessous que les rpertoires n'ont pas d'espace qui leur soit allou en propre. Par contre, tout fichier contient deux parties distinctes: la partie ressource et la partie donnes, chacune d'elles tant limite en taille 2 Go. Cette sparation est souvent utilise par les applications pour isoler la partie prsentation de la partie contenu. Ce qui nous importe ici est que chacune possde
- 96 -

Quelques exemples de SGF son propre espace allou. Notons que, en gnral, la partie ressource est assez petite, mais, si elle n'est pas vide, elle occupe au moins un bloc. Le descripteur de fichier contient la description des trois premires zones alloues chacune des parties du fichier, chaque zone tant dcrite par le numro du premier bloc et le nombre de blocs. Si une partie a besoin de plus de trois zones, les descriptions des zones manquantes sont regroupes, par groupe de 3, dans le fichier de description des extensions vu plus haut. Chaque entre de ce fichier est constitue des champs suivants, les trois premiers composant la cl d'identification de l'entre: Num-ID du fichier. Indicateur prcisant si on a affaire la partie ressource ou la partie donnes. Numro logique l'intrieur du fichier correspondant la premire zone. Ce numro est en fait gal la somme des longueurs des zones alloues qui prcdent la premire du groupe. Description des trois zones alloues. Pour faciliter les accs, les entres sont organises en arbre B*. Nous n'entrerons pas ici dans le dtail d'une telle structure, mais nous suggrons le lecteur de voir un cours de structures de donnes. Brivement, la figure 11.1 donne un exemple simple d'arbre B*, o les cls sont simplement des entiers. Dans notre cas, chaque nud occupe un secteur.
5 5 5 10 15 15 20 25 25 25 30 40 40 45

Fig. 11.1. Exemple d'arbre B* utilis dans HFS. Notons que si un fichier est fragment, et occupe plus de 3 zones, le systme devra rechercher dans l'arbre le ou les groupes de 3 zones ncessaires. Cependant, les entres correspondantes sont en fait ordonnes dans le fichier de description des extensions, puisqu'il s'agit d'un arbre B*. Le fichier de description des extensions est galement utilis pour conserver les blocs invalides, c'est--dire ceux pour lesquels on a dtect une erreur permanente. Ces blocs sont affects, comme zone d'extension, un objet externe de Num-ID particulier qui n'est repr par aucun rpertoire. Ainsi, ces blocs sont considrs comme allous, mais l'objet auquel ils sont allous n'est pas accessible.

11.2.2. Les rpertoires


Ce systme utilise une arborescence de rpertoires, mais avec une reprsentation originale de cette arborescence, puisque l'ensemble est galement reprsent dans un arbre B* unique, que nous avons appel ci-dessus le catalogue des fichiers et rpertoires. chaque objet externe, on associe une entre de ce catalogue qui est constitue essentiellement des champs suivants, les deux premiers composant la cl d'identification de l'entre: Num-ID de son rpertoire parent. Nom de l'objet externe, limit 31 caractres quelconque l'exception du ':', la casse n'intervenant pas dans les comparaisons. Le type de l'entre, et donc de l'objet externe, fichier ou catalogue. Dates de cration, modification et sauvegarde. Num-ID de l'objet lui-mme. Descripteur de fichier dans le cas d'un fichier. En particulier, pour chacune des parties du fichier, la taille physique (alloue), sa taille logique (utile) et les descripteurs des trois premires zones alloues cette partie.

- 97 -

Environnement externe Par ailleurs, le catalogue contient des entres spciales qui permettent de remonter dans l'arborescence depuis un rpertoire son parent, et que nous appellerons un lien. Une telle entre est constitue comme suit, les deux premiers champs tant toujours la cl de l'entre: Num-ID du rpertoire "", ou chane vide. Le type de l'entre en tant que lien. Num-ID de son parent. Nom du rpertoire lui-mme. Par ailleurs, le catalogue, en tant que arbre B*, a toutes ses entres ordonnes par cls croissantes. Par consquent, le lien d'un rpertoire vers son parent est immdiatement suivi des entres correspondant aux objets externes qu'il contient.

11.2.3. Cohrence du SGF


Comme dans tout systme de gestion de fichier, les informations sur la structure sont trs importantes et doivent tre cohrentes entre elles. Ainsi, la table bitmap ne doit pas indiquer comme libre un bloc qui serait allou un fichier. Conformment ce que nous avons dit en 10.2.1, lorsqu'il y a redondance d'informations, on peut distinguer les informations primaires et les informations secondaires, celles-ci ayant pour but de donner des accs efficaces. Dans le cas des informations sur l'tat d'allocation des blocs, les informations primaires sont les descriptions des zones alloues, et la table bitmap constitue les informations secondaires permettant d'acclrer les recherches de blocs libres. De mme, pour pouvoir attribuer un Num-ID aux objets lors de la cration, il faut connatre le dernier attribu. Cette information secondaire est mmorise dans le descripteur du volume. L'information primaire est reprsente en fait par la plus grande valeur des Num-ID existant sur le volume. Pour garantir cette cohrence, HFS maintient un indicateur dans le descripteur de volume, qui indique que le volume n'a pas t dmont proprement. Cet indicateur est crit sur disque lors du montage en criture du volume, et remis zro lors du dmontage du volume. Il permet donc de savoir lors d'un montage si une vrification de cohrence est ncessaire.

11.2.4. Le systme HFS Plus


Ce systme a pour but de lever les contraintes rencontres dans HFS. Nous ne mentionnerons ici que les modifications les plus importantes pour l'usager: La plus importante que nous ayons vu est la limitation du nombre de quanta d'une partition, impliquant d'avoir une taille de quantum importante pour les grosses partitions. Cette contrainte est leve en prenant 32 bits pour les numros de blocs d'allocation. videmment cela a pour consquence d'augmenter notablement la table bitmap, qui devient un fichier, permettant d'homogniser les accs. La taille maximale de chacune des parties d'un fichier est elle aussi augmente, puisqu'elle est porte 263 octets. Comme les blocs deviennent plus petits et peuvent conduire une fragmentation plus importante, et donc un nombre plus grand de zones, les groupes ont t ports 8, tant dans le descripteur de fichier que dans les entres du fichier de description des extensions. Les noms des objets ne sont plus limits 31 caractres MacRoman (codage sur 8 bits), puisqu'un nom peut avoir maintenant 255 caractres Unicode (16 bits). Ceci a conduit augmenter la taille des nuds de l'arbre B* du catalogue (4 Ko par dfaut), car plus ces nuds contiennent de valeurs, plus la hauteur de l'arbre est faible. Un troisime fichier de volume organis en arbre B* a t introduit pour permettre terme de grer plusieurs attributs d'un fichier, mais il s'agit plus d'ouverture vers l'avenir et d'viter ainsi d'avoir redfinir un nouveau SGF, car les spcifications compltes ne sont pas encore compltement dfinies en mars 1999. Ce fichier devrait permettre, par exemple, d'avoir plus de deux parties pour un mme fichier, et de pouvoir nommer ces parties.
- 98 -

Quelques exemples de SGF

11.3. Le systme NTFS


Ce systme a t cr par Microsoft pour tre le systme de gestion de fichier de Windows NT. Plusieurs systmes existaient initialement, comme VFAT ou HPFS de OS/2, mais aucun ne satisfaisait aux critres de fiabilit et de taille d'un systme moderne. En dehors du premier secteur de la partition, qui contient un ensemble minimal d'informations comme la localisation du fichier MFT dont il est question ci-dessous, ce SGF considre que "tout est fichier". Le formatage d'une partition en volume NTFS consiste donc crer un certain nombre de fichiers qui donnent la structure du volume. Nous ne dcrirons que certains de ces fichiers. Le fichier des descripteurs de fichiers, appel la Master File Table (MFT), qui commence par son propre descripteur. Il peut commencer n'importe o dans la partition, il est ncessaire de connatre cet endroit a priori, pour pouvoir accder son descripteur, ce qui est indiqu dans le premier secteur de la partition. Notons que ce fichier est doubl pour des raisons de scurit, la copie tant aussi repre par le secteur 0 de la partition. Le fichier du volume, contenant en particulier le nom du volume. Le fichier bitmap dcrivant l'tat d'allocation du volume. Le rpertoire racine du volume. Le fichier journal qui a pour but de garantir la fiabilit de la structure.

11.3.1. Les descripteurs de fichiers


Chaque objet externe reoit, sa cration, un numro qui est l'indice dans la MFT o est situ son descripteur. La taille de ces descripteurs est fixe la cration du volume et est comprise entre 1 Ko et 4 Ko, ce qui est donc relativement important. Un objet externe, fichier ou rpertoire, est constitu d'un certain nombre d'attributs qui peuvent tre rsidents, c'est--dire, rangs dans le descripteur de l'objet externe lui-mme, ou non rsident et donc l'extrieur de la MFT dans un espace qui lui est allou en propre. Voici quelques exemples d'attributs : Le nom de l'objet externe sous forme d'une suite de au plus 255 caractres Unicode. Les informations de base habituelles, comme les dates de cration, modification ou d'accs. Les informations de protections de l'objet. Le ou les contenus des fichiers ou rpertoires. Un mme objet externe peut avoir plusieurs attributs "nom", correspondant au principe des liens physiques noncs au 9.4.3. Si un fichier est suffisamment petit, tous ses attributs, et donc son contenu se trouvera dans le descripteur. Dans les autres cas, certains attributs (en particulier les donnes) seront non rsidents. NTFS utilise le principe de l'allocation par zone pour les attributs non rsidents d'un objet externe , et la valeur de l'attribut est remplace dans le descripteur par la suite des descriptions des zones alloues. Le nombre de zones est quelconque, chacune tant de taille quelconque (cf. 8.2.3). La taille du quantum est un nombre entier de secteurs, ce nombre tant une puissance de 2. Le terme de cluster dsigne les units d'allocation. Les clusters sont numrots sur 64 bits, ce qui implique qu'il n'y a pratiquement pas de limite aux nombres de clusters d'un volume. Comme un descripteur de zone doit localiser le premier cluster de la zone et son nombre de clusters, soit 16 octets, une technique de compression est utilise, d'une part en prenant son dplacement par rapport au premier cluster de la zone prcdente, et en supprimant les octets nuls en tte de ces deux valeurs. La longueur d'un attribut non rsident est mmorise sur 64 bits, ce qui permet donc des fichiers dont la taille n'est pratiquement limite que par l'espace disponible sur le volume. Notons que le contenu d'un fichier est un attribut sans nom, mais l'utilisateur peut crer des attributs nomms qui peuvent avoir des contenus spars dans des espaces distincts. L'implantation de serveur de fichier MacIntosh sur Windows NT utilise ce principe pour sparer la partie ressource et la partie donne (voir HFS).

- 99 -

Environnement externe

11.3.2. Les Rpertoires


NTFS utilise une arborescence de rpertoire. Le contenu d'un rpertoire est organis en arbre B+, qui se rapprochent des arbres B* vus plus haut, si ce n'est que les donnes associes aux cls sont rparties dans tous les nuds au lieu de n'tre que dans les feuilles comme sur la figure 11.1. Les entres d'un rpertoire contiennent les informations suivantes, la premire tant la cl: Le nom de l'objet, Le numro de l'objet dans la MFT, permettant de localiser son descripteur. Les dates de cration, modification ou d'accs de l'objet, La taille de l'objet Le numro du rpertoire parent qui le contient dans la MFT. En fait seuls les deux premiers sont effectivement ncessaires, puisque les trois derniers se trouvent dans le descripteur de l'objet. Cette duplication a un avantage et un inconvnient. L'avantage est que l'on a accs aux informations essentielles de l'objet sans devoir accder au descripteur. L'inconvnient est inhrent la duplication: toute modification de ces informations doit tre porte plusieurs endroits sur le disque, sous peine d'avoir des donnes incohrentes. Notons qu'il peut paratre surprenant de trouver dans cette entre le numro du rpertoire qui contient l'entre! En fait, Toutes ces informations, avec la cl, font partie l'attribut "nom de fichier", prsent dans le descripteur du fichier, et en sont une copie. Or, le numro du rpertoire parent d'un fichier permet de remonter l'arborescence des fichiers et rpertoires, en retrouvant ainsi le parent de chaque rpertoire. Le principe des arbres B implique que des nuds soient crs ou supprims au fur et mesure des adjonctions ou suppressions. La suppression d'un nud peut ne pas tre le dernier nud physique du rpertoire, et il faut prvoir sa rutilisation ultrieure. Ceci se fait en dfinissant un attribut "bitmap" pour chaque rpertoire qui indique quels sont les nuds libres. S'il n'y en a plus, une allocation d'une nouvelle zone est effectue, et la table bitmap est mise jour pour tenir compte des nuds libres ajouts.

11.3.3. Compression de donnes


NTFS propose une technique de compression/dcompression des fichiers au fur et mesure des accs. L'ide est de dcouper le contenu du fichier par tranche dont la taille correspond 16 clusters, et de tenter de compresser chaque tranche indpendamment les unes des autres. La compression n'est effective que si elle fait gagner au moins 1 cluster. Dans ce cas, les clusters gagns ainsi sont mmoris dans la suite des descripteurs de zones par une zone marque non alloue dont la taille correspond au nombre de clusters gagns. A la lecture, l'opration inverse est effectue. Notons que la mise en uvre de la compression/dcompression sur un fichier est mmoris dans le descripteur du fichier, l'utilisateur n'ayant pas s'en proccuper ensuite. videmment cette technique est coteuse en temps processeur, et doit tre utilise bon escient.

11.3.4. Scurit par fichier journal


Les oprations mises en uvre sur les structures de fichiers, en gnral, concernent plusieurs secteurs distincts rpartis sur le volume. Les modifications ne peuvent toutes tre portes sur le disque en une seule fois, mais doivent tre effectues en squence. videmment, les systmes tiennent compte de l'ventualit d'une panne qui empche le droulement complet de la squence et entrane une incohrence. Ceci est obtenu en dfinissant pour chaque opration l'ordre qui donnera le minimum de dgt en cas de panne. En particulier, il est prfrable de perdre de l'espace disque plutt que de risquer d'allouer deux fois le mme bloc deux objets diffrents. En fait, il est presque toujours possible de rtablir la cohrence et retrouver les blocs non allous, mais cela peut tre coteux en temps. Dans le cas des SGF modernes, le risque est aggrav par le fait que bien souvent les oprations sont effectues dans des tampons en mmoire, et que l'criture de ces tampons sur disque est effectue plus tard, pour gagner en performance et en efficacit (principe de l'criture paresseuse). Par exemple, une cration de fichier donnera souvent lieu dans un avenir proche une ou plusieurs
- 100 -

Quelques exemples de SGF allocations d'espace disque. Le report des critures de la table bitmap peut avoir pour consquence qu'elle ne sera crite qu'une seule fois lorsque tout sera termin. La structuration d'un volume en NTFS contient un fichier particulier, dit fichier journal, qui va avoir un rle analogue au fichier journal des systmes de gestion de bases de donnes classiques, dans lequel sera mmorise la squence des actions effectues sur le disque dans le but de pouvoir soit les refaire soit les dfaire aprs une panne. Cette utilisation fait appel la notion de transaction, qui signifie, entre autre, que l'on garantit que toutes les oprations lmentaires de la transaction sont effectues, mme en cas de panne, ou que aucune n'est faite. Expliquons brivement le droulement des oprations lors de la cration d'un fichier avec allocation d'espace. Les oprations sont les suivantes: - Initialisation d'une transaction. - Cration d'un descripteur du fichier dans la MFT. - Cration de l'entre dans le rpertoire parent, - Mise l'tat non libre des bits correspondants aux clusters allous, dans la bitmap, - Clture de la transaction. Les oprations 2, 3 et 4 sont faites dans des tampons en mmoire, et lors de la clture de la transaction, il est probable que ces tampons n'ont pas encore t crits sur disque. Chacune de ces oprations donne lieu un enregistrement dans le fichier journal qui dcrit comment "refaire" et comment "dfaire" l'opration correspondante. En fait ces enregistrements sont mis dans des tampons en mmoire, en vue d'une criture ultrieure, comme pour tout fichier. Cependant le gestionnaire de ces tampons fera en sorte que les tampons du fichier journal soient crits sur disque avant l'criture des autres tampons. De plus, priodiquement, l'tat des transactions ainsi que la liste des tampons en mmoire non encore crits sur disque sont enregistrs dans le fichier journal. En cas de panne une analyse du fichier journal permet de savoir les transactions cltures dont les actions n'ont pas t portes physiquement sur disque et qui doivent donc tre refaites, ou les transactions non cltures dont les actions portes physiquement sur disque doivent tre dfaites.

11.4. Le systme ext2fs de Linux


Linux est un systme d'exploitation qui s'apparente fort Unix, tout en tant un logiciel libre. Le systme de fichier initial tait driv de celui du systme Minix, lui aussi driv d'Unix pour l'enseignement. Le SGF de Minix tant cependant trop contraint, un nouveau systme de gestion de fichier a t crit, ext2fs.

11.4.1. La reprsentation de l'espace


Comme d'habitude, l'ensemble du disque est dcoup en blocs dont la taille est un multiple (puissance de 2) de la taille d'un secteur. Ext2fs pratique l'allocation par bloc de taille fixe, plusieurs niveaux (cf. 8.3.2). Les descripteurs d'objets externes sont reprsents dans ce qui est appel un inud, qui sont regroups dans une table, l'indice dans la table, appel le numro du inud (i est l pour integer), identifiant de faon unique cet objet. Une table bitmap dcrit l'tat d'allocation des inuds, et une autre dcrit l'tat d'allocation des blocs. Pour des raisons de performances, en particulier sur les gros disques, ces tables sont morceles et rparties dans la partition. Une partition est dcoupe en groupes de mme taille, chaque groupe comportant 6 parties: Le super bloc, qui contient les informations de structure du volume. La liste des descripteurs de groupe, qui localise sur le disque les informations essentielles de chaque groupe (localisation des tables). La table bitmap d'tat d'allocation des blocs du groupe. La table bitmap d'tat d'allocation des inuds du groupe. La table des inuds du groupe. Les blocs de donnes.

- 101 -

Environnement externe Le super bloc et la liste des descripteurs de groupe sont donc rpts au dbut de chaque groupe, pour des raisons de fiabilit. Lors du montage, on ne lit en fait que ceux du premier groupe. Cette sparation en groupes doit plus tre vue comme une rpartition des donnes sur le disque, dans le but d'amliorer les performances. La taille d'un groupe est d'ailleurs limite, puisque chaque table bitmap d'un groupe doit tenir dans un seul bloc. Si la taille de la partition est importante, il y aura beaucoup de groupes. Les groupes ont pour but de rapprocher dans un espace physique proche les informations qui sont relies entre elles. Ainsi, lors d'une allocation d'un inud, on cherchera de prfrence dans le groupe du rpertoire o il est rfrenc; de mme, lors de l'allocation d'un bloc, on cherchera d'abord le bloc qui suit le dernier allou l'objet, puis dans son voisinage immdiat (32), puis dans le mme groupe et enfin dans les autres groupes. Un descripteur d'objet externe contient videmment le type de l'objet, des informations pour sa protection, sa longueur, les dates habituelles de cration, modification, accs et destruction, ainsi que les informations de localisation du contenu, qui sont semblables celles de la figure 8.4 (la seule diffrence est qu'il y a en gnral 12 blocs directs au lieu de 10). La taille d'un objet externe est limit 2 Go, mais la taille d'une partition peut atteindre 4 To.

11.4.2. Les rpertoires


Ext2fs gre une arborescence de fichiers. Le contenu d'un rpertoire tant une liste d'entres constitues de couples <inud, nom>, le nom tant limit 255 caractres. Les deux premires entres d'un rpertoire sont les entres "." et ".." habituelles. Il est possible d'avoir plusieurs noms ou chemins d'accs pour le mme inud. Ceci a pour consquence que la suppression d'une entre dans un rpertoire n'entrane pas obligatoirement la suppression du inud correspondant. Celle-ci ne sera effective que s'il n'existe plus d'entre associe ce inud dans aucun rpertoire. En dehors de la suppression d'une entre dans un rpertoire, qui n'affecte donc que cette entre, toutes les autres oprations effectues par l'un des chemins aura les mmes rpercussions par l'autre. Ce systme permet aussi la cration de liens symboliques (cf. 9.4.3). Dans ce cas, il s'agit de crer un objet externe (avec inud et contenu), du type lien symbolique, et dont le contenu sera le chemin d'accs l'objet reli. Rappelons que dans ce cas la recherche de l'objet externe reli implique la rvaluation du chemin d'accs.

11.4.3. Scurit
Comme beaucoup de systmes, ext2fs est bas sur l'utilisation de caches mmoire des blocs disques, l'criture des blocs modifis tant reporte (criture paresseuse). Cela peut avoir pour consquence des incohrences dans la structure du volume. L'criture d'un bloc est effective lorsque le tampon qu'il occupait est rcupr pour un autre bloc. De plus, cette criture est force automatiquement une priode rgulire. Comme tous les systmes, il est cependant recommand de toujours l'arrter par la commande associe. Dans ext2fs, chaque objet externe, est attach un indicateur qui, lorsqu'il est positionn, demande que le inud et les blocs indirects sur disque soient synchrones avec leur contenu en mmoire, c'est--dire, que toute modification en mmoire soit porte immdiatement sur le disque, avant de retourner au programme d'application. Pour l'utilisateur, la fin d'excution de l'opration signifie pour lui un tat cohrent de la structure disque, en regard de son fichier. Notons deux attributs dfinis par ext2fs et attachs chaque fichier : L'attribut de "secret" implique que, lors de la destruction du fichier, le contenu doive tre effac en le remplissant de donnes alatoires. Cela vite que des donnes sensibles puissent tre vues lors de la rallocation des blocs qui les contenaient. L'attribut de "rcupration" permet la rcupration d'un fichier dtruit, jusqu' un certain point.

11.5. Structuration en couche du systme


Certains systmes permettent de manipuler, au mme moment, des volumes structurs diffremment. C'est assez naturel lorsque l'un des SGF est une extension de l'autre par le mme concepteur, comme par exemple HFS et HFS Plus. La caractristique de standard de fait de FAT
- 102 -

Quelques exemples de SGF fait que pratiquement tous les systmes implantent ce SGF en plus de leur propre SGF propritaire. Windows NT reconnat et gre FAT, VFAT, HPFS (de OS/2) et NTFS. Il ne reconnat pas HFS, mais est capable de simuler un serveur de fichier de ce type sur un rseau, en s'appuyant sur NTFS. Linux permet la manipulation de tous les SGF voqus dans ce chapitre, au moins en lecture, si ce n'est en criture. La reconnaissance simultane de plusieurs SGF est en gnral bas sur un dcoupage du logiciel en couches, en dfinissant les spcifications entre les couches: Le systme de fichier virtuel (SFV) est la vue homogne de tous les SGF rels. Il est dfini en interne en terme de structures de reprsentations et d'oprations de manipulations de ces structures. Le systme de tampons mmoire qui contiennent les blocs disque (le cache). Le disque abstrait est une vue homogne des tous les disques supports par l'installation. Il dfinit un ensemble d'oprations d'accs disques lmentaires indpendantes des priphriques physiques eux-mmes . Les couches du logiciel sont les suivantes: La couche haute, proche de l'application, implante les oprations d'accs ncessaires aux programmes d'applications en voyant le systme de fichier avec la structure de SFV. La couche intermdiaire, lie un SGF, assure l'interface entre le SFV et les tampons mmoire. Elle assure la transformation entre les structures du SFV et du SGF particulier et implante les oprations du SFV, selon les caractristiques du SGF, en se servant de ces tampons. Le gestionnaire de cache gre les tampons mmoire et lance les oprations ncessaires vers le disque abstrait. Les pilotes des disques, lis aux priphriques eux-mmes, implantent les oprations du disque abstrait en terme d'oprations concrtes du disque.

- 103 -

QUATRIME PARTIE

ENVIRONNEMENT PHYSIQUE

12

La gestion des processus

Nous avons vu dans les premiers chapitres que l'introduction des activits parallles avait permis d'amliorer la rentabilit des machines. Le paralllisme peut tre li des activits spcifiques, et donc obtenu par des processeurs spcialiss. Par exemple, un transfert d'entres-sorties peut tre excut en mme temps qu'un calcul interne au processeur. Il peut aussi tre le moyen d'obtenir plus de puissance de calcul dans le mme temps imparti, en utilisant plusieurs processeurs de calcul. Plus gnralement, un processeur peut excuter une squence d'instructions d'un programme, puis ensuite une squence d'instructions d'un autre programme, avant de revenir au premier, et ainsi de suite. Si la dure d'excution des squences est assez petite, les utilisateurs auront l'impression que les deux programmes s'excutent en parallle. On parle alors de pseudo-paralllisme. videmment, vu du processeur lui-mme, il s'agit d'une activit unique et squentielle, un programme de supervision dcidant de la squence excuter. C'est ce programme de supervision, inclus dans le systme, qui donne en fait l'illusion du paralllisme. Si la recherche de la meilleure efficacit du matriel a t l'origine du paralllisme et reste un aspect important, le pseudo-paralllisme permet plusieurs utilisateurs d'utiliser une mme machine au mme instant, et chacun d'eux de lancer plusieurs activits en mme temps, comme par exemple compiler un module source pendant que l'on modifie un autre module source. La gestion de ces activits parallles est en gnral assez complexe, et difficile apprhender. Le concept de processus est fondamental pour la comprhension de cette gestion, tant pour le concepteur de systme que pour l'utilisateur.

12.1. La notion de processus


Le terme de programme est souvent utilis des sens diffrents. Lorsqu'il est utilis pour dsigner l'ensemble des modules sources, l'ensemble des modules objets ou le rsultat de l'dition de liens, il reprsente toujours la mme abstraction, crite dans diffrents langages de reprsentation, de la description des actions entreprendre pour aboutir au rsultat recherch. Cet aspect description des actions est en fait fondamental, et le terme de programme ne devrait tre utilis que dans ce sens. Le terme de processeur est utilis pour dsigner l'entit (matrielle ou logicielle) qui est capable d'excuter des instructions. Jusqu' maintenant, nous l'avons utilis essentiellement pour dsigner une entit matrielle, comme le processeur de calcul, ou le processeur d'entres-sorties, et nous continuerons l'utiliser dans ce sens, mais il peut parfois tre intressant de considrer qu'un interprteur, par exemple, est un processeur logiciel capable d'excuter des instructions du langage qu'il interprte. La notion de processus a t introduite pour dsigner l'entit dynamique qui correspond l'excution d'une suite d'instructions. C'est un concept abstrait, en ce sens qu'il dsigne l'volution d'une activit dans le temps. C'est le processeur qui fait voluer cette activit en excutant les instructions dfinies par un programme. Le systme doit permettre de distinguer les diffrents
- 107 -

Environnement physique processus qui existent un instant donn, et doit reprsenter leur tat. Celui-ci permet, d'abord, de localiser le programme lui-mme, c'est--dire la suite d'instructions, ensuite, de dterminer les donnes propres et les variables, enfin de reprsenter l'tat du processeur aprs l'excution d'une instruction quelconque du programme (registres, compteur ordinal, mot d'tat programme,...). Pour bien montrer la diffrence entre programme et processus, nous reprendrons une image de Tanenbaum. Supposez qu'un informaticien dcide de faire un gteau pour l'anniversaire de sa fille. Pour tre certain de le russir, il ouvre devant lui son livre de recettes de cuisine la page voulue. La recette lui prcise les denres dont il a besoin, ainsi que les instruments ncessaires. ce stade, nous pouvons comparer la recette sur le livre de cuisine au programme, et l'informaticien au processeur. Les denres sont les donnes d'entres, le gteau est la donne de sortie, et les instruments sont les ressources ncessaires. Le processus est l'activit dynamique qui transforme les denres en gteau. Supposez que, sur ces entrefaites, le fils de l'informaticien vient se plaindre qu'il a t piqu par une abeille. L'informaticien interrompt son travail, enregistre l'endroit o il en est, extrait de sa bibliothque le livre de premire urgence, et localise la description des soins apporter dans ce cas. Lorsque ces soins sont donns et que son fils est calm, l'informaticien retourne sa cuisine pour poursuivre l'excution de sa recette. On constate qu'il y a en fait deux processus distincts, avec deux programmes diffrents. Le processeur a partag son temps entre les deux processus, mais ces deux processus sont indpendants. Supposez maintenant que la fille de l'informaticien vienne lui annoncer de nouveaux invits. Devant le nombre, l'informaticien dcide de faire un deuxime gteau d'anniversaire identique au premier. Il va devoir partager son temps entre deux processus distincts qui correspondent nanmoins la mme recette, c'est--dire au mme programme. Il est videmment trs important que le processeur considre qu'il y a deux processus indpendants, qui ont leur propre tat, mme si le programme est le mme. De mme que l'informaticien aura un seul exemplaire de la recette pour les deux processus, de mme dans une situation analogue en machine, le programme lui-mme pourra se trouver en un seul exemplaire en mmoire, pourvu que d'une part le code ne se modifie pas lui-mme, d'autre part qu'il permette d'accder des zones de donnes diffrentes suivant que les instructions sont excutes pour le compte de l'un ou l'autre des processus. On dit alors que le programme est rentrant. L'indpendance entre les processus conduit parfois introduire la notion de processeur virtuel. Chaque processus se voit attribuer un tel processeur virtuel qu'il possde en propre, et qui excute les instructions du programme pour le compte du processus. Le systme implante ces processeurs virtuels en attribuant le (ou les) processeur rel alternativement aux diffrents processeurs virtuels. Chaque processus avance au rythme de son processeur virtuel, induisant un temps virtuel, qui correspond au temps d'utilisation du processeur virtuel. Il correspond aussi la fraction du temps rel pendant laquelle un processeur rel a t attribu au processeur virtuel. En consquence un temps virtuel de 1 seconde correspond l'excution d'un certain nombre d'instructions par le processeur rel, que ces instructions aient t ralises en une seule fois, ou en plusieurs tranches de temps.

12.2. La hirarchie de processus


Nous avons dit que la reprsentation d'un processus comportait trois composantes principales, le programme, les variables et l'tat du processeur.

12.2.1. Un nombre fixe de processus banaliss


Certains systmes crent, l'initialisation, un nombre fixe de processus banaliss. Ces processus peuvent tre attachs chacun un terminal particulier. Le programme du processus consiste alors en l'identification de l'usager (login) suivi de l'excution de ses commandes et se termine par la remise dans l'tat initial lors de la dconnexion (logout).
- 108 -

Gestion des processus Ces processus peuvent tre attachs un terminal au moment de la demande de connexion depuis de terminal. Le programme est alors comparable au prcdent. Le nombre de processus peut tre infrieur au nombre de terminaux potentiels, entranant un refus de connexion si aucun processus n'est disponible. Il est galement possible d'allouer le processus un couple de fichiers <entre, sortie>, qui simulent le comportement d'un usager son terminal, ce qui fournit une certaine forme de traitement par lot. Ces processus peuvent tre allous la demande pour une excution d'une commande unique. Le programme, qui dcrit leur comportement, est une boucle infinie qui consiste en l'attente d'une commande, suivie de son excution. Suivant le cas, plusieurs processus pourront tre allous un mme usager en fonction de ses besoins. Cependant, il est ncessaire de disposer de plus de processus que dans les cas prcdents, et la reprsentation de la partie propre de leur tat occupe de la place en mmoire.

12.2.2. La cration dynamique de processus


La cration statique de processus banaliss prsente l'inconvnient d'occuper de la place en mmoire, mme lorsqu'ils ne sont pas utiliss. La deuxime mthode consiste fournir une opration de cration dynamique de processus ainsi qu'une opration de destruction de ces processus. Un telle opration de cration doit permettre d'initialiser l'tat du nouveau processus. Elle doit donc dfinir d'une part le programme (ou la suite d'instructions) dcrivant l'activit du processus, ainsi que l'tat initial de ses donnes, de ses variables et des registres du processeur. Elle doit donc se prsenter sous la forme suivante:
id := crer_processus (programme, contexte)

o les paramtres dfinissent cet tat initial. La valeur retourne ventuellement par cette opration permet d'identifier le processus qui a t ainsi cr. Cette dernire valeur n'a d'intrt que si le processus crateur peut agir ultrieurement sur le processus cr au moyen d'autres oprations. La plupart des systmes qui permettent la cration dynamique de processus considrent que la relation entre le processus crateur et le processus cr est importante, ce qui conduit structurer l'ensemble des processus sous la forme d'un arbre, et maintenir cette structure. Lors de la cration de processus, le processus cr est reli automatiquement comme fils du processus crateur. Si un processus est dtruit, on peut parcourir sa descendance pour la dtruire au pralable. Lors de la fin d'excution normale d'un processus P, deux solutions sont possibles: La destruction de P n'est effective que lorsque tous ses fils sont eux-mmes achevs. Ceci est ncessaire lorsque le contexte initial du fils est inclus dans le contexte de P, puisque la destruction de celui-ci entranerait la perte d'une partie du contexte du fils, et donc un droulement anormal du processus fils s'il pouvait exister aprs la destruction de son pre. La destruction de P entrane le rattachement de ses fils l'un de ses anctres. Cependant comme l'ascendance du processus P n'a pas de connaissance de ce qu'a fait P, on rattache souvent les fils soit au processus qui a initialis le travail (login), soit la racine qui est un processus standard et ternel.

12.2.3. L'exemple de Unix


Dans le systme Unix, la cration dynamique de processus est simplifie l'extrme, puisqu'il s'agit de crer un processus qui est une exacte copie de celui qui demande la cration. Aucun paramtre n'est donc ncessaire, puisque le programme est le mme, et que le systme ralise une copie des donnes, variables et registres du processus demandeur pour crer le nouveau processus. La seule distinction entre le processus crateur et le processus cr, rside dans la valeur retourne par la fonction de cration. Le processus crateur reoit l'identit du processus cr, alors que ce dernier reoit la valeur 0. Par ailleurs, le systme structure les processus en arbre. Considrons le petit morceau de programme suivant:
id_fils := fork (); { cration du fils } si id_fils = 0 alors { il s'agit du processus fils } sinon { il s'agit du processus pre }

La fonction fork () cre le processus fils comme copie conforme du processus pre. Les deux processus repartent donc aprs l'appel de la fonction, avec le mme programme, et leur propres
- 109 -

Environnement physique zones de donnes et de variables identiques ce moment. La mmorisation du rsultat dans la variable id_fils signifie la mmorisation dans un emplacement mmoire propre chacun d'eux. Notons que, puisque le fils obtient une copie des donnes du pre, celui-ci peut lui transmettre tout ce qu'il dsire ce moment. Par la suite, les deux processus sont effectivement indpendants et n'ont pas de donnes communes l'exception des objets externes. Si le processus pre se termine avant le processus fils, le fils est rattach au processus racine de faon conserver la structure d'arbre. Le processus pre peut attendre la terminaison d'un de ses fils par la fonction (en langage C):
id_fils := wait (&status);

qui retourne le numro d'un processus fils qui est termin, en mettant dans la variable status un code indiquant la faon dont ce processsus s'est termin. Si aucun fils n'est termin alors qu'il y en a encore d'actifs, le processus pre est mis en attente d'une terminaison de l'un de ses fils. S'il n'y a plus de processus fils, la fonction retourne la valeur -1. Par ailleurs le systme Unix fournit une fonction exec qui permet un processus de changer le programme en cours d'excution. Cette fonction n'affecte videmment que le processus demandeur. Elle change l'tat du processus en remplaant le code des instructions, en supprimant les donnes, variables et registres qui taient relatifs l'ancien programme et en les initialisant pour le nouveau. La combinaison de la fonction fork et de cette fonction exec par le processus fils permet de raliser la fonction crer_processus mentionne ci-dessus.

12.3. La notion de ressources


Si nous reprenons notre exemple du processus de ralisation du gteau d'anniversaire, ce processus ne peut s'excuter que si les denres ncessaires pour la recette sont disponibles, ainsi que les ustensiles de cuisines correspondants. Ce sont des ressources dont a besoin ce processus. Si on dsire faire un deuxime gteau identique, un deuxime processus doit tre cr pour le raliser. Cet autre processus aura besoin galement de ressources, et peut alors tre en conflit avec le premier processus s'il n'y a pas assez de certaines ressources. Par exemple, si la cuisson doit tre faite au four, il est possible que le four soit assez grand pour admettre les deux gteaux en mme temps. Le batteur ne pourra pas par contre tre utilis en mme temps par les deux processus. Le processeur tant unique (l'informaticien) ne pourra pas commencer de battre la pte pour le compte de l'un des processus, si l'autre possde la ressource batteur et ne l'a pas restitue (lav et essuy les embouts). Par contre, l'horloge peut tre partage par tous les processus ventuels grs par l'informaticien. On appelle ressource toute entit dont a besoin un processus pour s'excuter. Il en est ainsi du processeur physique, de la mmoire, des priphriques. Il en est galement ainsi des donnes dont a besoin le processus et qui seraient momentanment indisponibles. Il en est enfin ainsi de l'vnement de fin d'excution d'un processus Unix pour le processus pre qui l'attend. Pour chaque ressource, une caractristique importante est le nombre de processus qui peuvent utiliser la ressource au mme moment. Il peut y en avoir un nombre quelconque. Il n'y a alors pas de contrle mettre en uvre. Dans l'exemple culinaire, l'horloge a t considre comme une ressource qui peut tre accde par un nombre quelconque de processus. Il peut y en avoir plusieurs, mais en nombre limit. Il faut alors contrler lors des allocations que ce nombre n'est pas dpass. Dans l'exemple culinaire, le four ne peut tre utilis simultanment que par deux processus. Il peut y avoir au plus un processus qui utilise la ressource. Dans l'exemple culinaire, le batteur ne peut tre utilis que par au plus un processus. On dit alors que la ressource est une ressource critique. On dit aussi que les processus sont en exclusion mutuelle pour l'accs cette ressource. Il en est ainsi du processeur physique, d'une imprimante, d'un drouleur de bande, etc... Pour les ressources physiques critiques, nous avons dj propos une premire solution pour le processeur, qui peut tre gnralise dans certains cas, en remplaant une telle ressource physique par une ressource virtuelle . Dans ce cas, le systme met en uvre des mcanismes de coopration entre les processus, qui sont cachs dans le systme et donc invisibles des processus eux-mmes, pour leur permettre de faire comme si ils avaient la ressource pour eux seuls. On peut ainsi
- 110 -

Gestion des processus simuler un nombre quelconque d'imprimantes virtuelles sous forme de fichiers sur disque dont les impressions sont ralises successivement par le systme sur une mme imprimante physique.

12.4. Les tats d'un processus


Lorsqu'un processus n'a pas toutes les ressources dont il a besoin pour s'excuter, il est ncessaire de le bloquer en attendant que ces ressources soient disponibles. La figure 12.1 montre les diffrents tats que peut prendre un processus, lorsqu'il existe. Lors de la cration il est mis, en gnral, dans l'tat bloqu, en attendant qu'il ait toutes les ressources dont il a besoin initialement. Sa destruction peut subvenir dans n'importe quel tat la suite d'une dcision interne s'il est actif, ou externe s'il est dans un autre tat. Dans ce cas, il faut rcuprer toutes les ressources qu'il possdait.
actif 1 3 bloqu 4 prt 2

1 Le processus a besoin d'une ressource dont il ne dispose pas 2/3 Dcision de l'allocateur du processeur 4 Sur intervention extrieure au processus, lors de l'allocation de la ressource

Fig. 12.1. Les principaux tats d'un processus. Il est assez naturel de considrer de faon particulire la ressource processeur physique. Pour le moment c'est encore une ressource chre, qu'il vaut mieux ne pas gaspiller. Par ailleurs il est inutile de la donner un processus qui il manque une autre ressource, puisque ce processus ne peut alors voluer: le processeur ne pourrait que constater ce manque et attendre la disponibilit de cette ressource (c'est ce que l'on appelle l'attente active). C'est pourquoi on distingue trois tats: l'tat actif o le processus dispose de toutes les ressources dont il a besoin, l'tat bloqu o le processus a besoin d'au moins une ressource autre que le processeur physique, l'tat prt o le processus dispose de toutes les ressources l'exception du processeur physique. La transition 1 survient lorsque, le processus tant actif, il exprime le besoin de disposer d'une nouvelle ressource. Cette expression peut tre explicite, sous forme d'une demande au systme, ou implicite, sous forme d'un accs cette ressource non alloue. Le processus doit videmment disposer du processeur pour pouvoir exprimer ce besoin. Il peut se faire que la transition vers l'tat bloqu par manque de ressources, entrane que le systme lui retire d'autres ressources qu'il possdait, en plus de la ressource processeur physique, comme par exemple de la mmoire centrale. En gnral, on ne lui retire que des ressources chres, qu'il est relativement facile et peu coteux de lui restituer ultrieurement, dans l'tat o elles taient au moment o on les lui a enleves. Il est assez naturel de considrer de faon particulire la ressource processeur physique. L'tat bloqu correspond alors au manque d'une ressource autre que le processeur physique, et l'tat prt correspond alors au manque de la seule ressource processeur. La transition 4 est la consquence d'un vnement extrieur au processus. Celui-ci tait bloqu en attente d'une ou plusieurs ressources. Lorsque le systme constate qu'il a pu lui allouer toutes les ressources (autres que le processeur) dont il a besoin, il le fait passer dans l'tat prt. La disponibilit de la ressource attendue se prsente, en gnral, sous l'une des deux formes suivantes: C'est le rsultat d'une action par un autre processus. Il peut s'agir de la libration de la ressource, ou de la cration de la ressource elle-mme. Ainsi la fin d'excution d'un processus cre la ressource vnement attendue par son pre. C'est le rsultat d'une action extrieure. Il peut s'agir d'une interruption en provenance d'un priphrique, par exemple, ou d'un vnement dclench par l'oprateur ou un utilisateur. Les transitions 2 et 3 sont sous la responsabilit de la partie du systme qui alloue le processeur physique. C'est ce niveau que s'implante la notion de processeur virtuel dont nous avons dj
- 111 -

Environnement physique parl. Certains systmes n'implantent pas la transition 2. Il s'ensuit que lorsqu'un processus est actif, il le reste jusqu' ce qu'il soit termin ou qu'il ait besoin d'une ressource qu'il n'a pas. L'allocation du processeur consiste alors choisir un processus parmi les processus prts, et le faire passer dans l'tat actif. Cela peut entraner que les processus prts peuvent attendre trs longtemps pour devenir actif, si le choix a conduit rendre actif un processus qui calcule sans exprimer le besoin de nouvelles ressources. Ceci peut tre vit par le biais de la transition 2 qui doit tre la consquence d'une action extrieure au processus actif. C'est en gnral un des rles attribus l'interruption d'horloge de dclencher cette transition. Il est important de noter que ces transitions ne sont pas instantanes, puisqu'il s'agit de ranger en mmoire l'tat du processeur relatif l'ancien processus actif, et de restituer l'tat du processeur avec celui relatif au nouveau processus actif, une fois le choix de celui-ci effectu. L'excution de ces transitions consomme du temps de processeur physique, qui n'est pas utilis par les processus eux-mmes. C'est ce que l'on appelle la dperdition (overhead) rsultant de la gestion des processus. Tous les systmes visent rduire cette dperdition dans des limites raisonnables. C'est le prix payer pour une meilleure fonctionnalit.

12.5. Conclusion
Un processus est l'entit dynamique qui correspond l'excution d'une suite d'instructions dfinie par le programme. Le processeur est l'entit qui excute les instructions pour le compte du processus. Lorsqu'un processus n'a pas le processeur, il ne peut voluer, et son tat doit tre conserv en mmoire. Lorsqu'il a le processeur, son tat volue, et est reprsent en partie par les registres du processeur. Il peut y avoir un nombre fixe de processus dans un systme, ou bien les processus peuvent tre crs dynamiquement. Dans ce cas, l'ensemble des processus est structur en arborescence suivant la relation crateur-cr. La cration d'un processus doit dfinir le programme qu'il doit excuter, et le contexte initial de cette excution. Sur Unix, le processus cr est une copie conforme du processus crateur. Une ressource est une entit dont a besoin un processus un instant donn pour s'excuter. Elle est caractrise, en particulier, par le nombre de processus qui peuvent l'utiliser au mme moment. Ce nombre peut tre illimit, et aucun contrle n'est ncessaire lors de l'allocation. Si le nombre de processus pouvant utiliser une ressource est born, il faut contrler lors de l'allocation que la borne n'est pas atteinte. Lorsque cette borne est gale 1, on dit que la ressource est critique, et que les processus sont en exclusion mutuelle pour cette ressource. Les ressources induisent trois tats sur les processus: l'tat actif lorsque le processus a toutes ses ressources, l'tat prt lorsque le processus a toutes ses ressources sauf le processeur et l'tat bloqu lorsqu'il lui manque des ressources autres que le processeur. Le passage de l'tat actif l'tat bloqu est en gnral volontaire, ou la suite d'une rquisition. Le passage de l'tat bloqu l'tat prt est d une action externe au processus.

- 112 -

13

Synchronisation et communication entre processus

Nous avons dj dit que, si les processus taient des entits autonomes et indpendantes, ils pouvaient se trouver en conflit pour l'accs certaines ressources communes. Ceci ncessite la mise en uvre de mcanismes dits de synchronisation pour grer ces conflits. Par ailleurs, si les processus sont en gnral indpendants, cela ne doit pas interdire la communication. La consquence de ces mcanismes est le blocage des processus en attente d'une ressource momentanment indisponible. Deux problmes en dcoulent: l'interblocage et la famine.

13.1. Les mcanismes de synchronisation


Considrons un compte bancaire, dont le montant est mmoris dans un emplacement donn A sur disque. Le programme qui consiste ajouter 100 ce compte pourrait tre le suivant, o N est une variable locale du programme:
lire (N, A); N := N + 100; crire (N, A);

Si maintenant deux processus diffrents consistent en l'excution de ce mme programme, le processeur sera allou chacun d'eux dans un ordre quelconque. En particulier, on peut imaginer que l'ordre soit le suivant: processus P1 processus P2
lire (N, A); lire (N, A); N := N + 100; crire (N, A); N := N + 100; crire (N, A);

tant une variable locale du programme, implique qu'il en existe un exemplaire pour chacun des deux processus. Il s'ensuit que, si la valeur initiale du compte est 1000, on constate qu'aprs ces excutions, il est de 1100 au lieu de 1200. Les deux processus ne sont pas en fait totalement indpendants. Ils partagent la ressource commune qu'est la valeur du compte bancaire l'adresse A sur disque. Cette ressource doit tre un seul point d'accs, c'est donc une ressource critique, et les processus sont en exclusion mutuelle sur cette ressource critique.
N

Si la variable N est commune aux deux processus, le problme n'est pas rsolu pour autant. En effet l'instruction N := N + 100 n'est pas une instruction indivisible. En fait elle est dcompose en trois instructions de la machine qui sont par exemple:
- 113 -

Environnement physique
LOAD ADD STORE N 100 N

L'allocateur du processeur prend en compte les instructions de la machine et non les instructions du langage volu pour dterminer les moments o il peut remplacer le processus actif par un autre. En particulier, dans cet exemple, il est possible que le changement ait lieu juste aprs la premire instruction, donnant la squence suivante: processus P1 processus P2
LOAD N LOAD ADD STORE ADD STORE 100 N N 100 N

13.1.1. Les verrous


Un mcanisme propos pour permettre de rsoudre l'exclusion mutuelle d'accs une ressource est le mcanisme de verrou (en anglais lock). Un verrou est un objet systme sur lequel deux oprations sont dfinies. Un tel objet peut s'assimiler une ressource logiciel, les oprations permettant d'acqurir ou de librer cette ressource. verrouiller (v) permet au processus d'acqurir le verrou v s'il est disponible. S'il n'est pas disponible, le processus est bloqu en attente de la ressource. dverrouiller (v) permet au processus de librer le verrou v qu'il possdait. Si un ou plusieurs processus taient en attente de ce verrou, un seul de ces processus est ractiv et reoit le verrou. En tant qu'oprations systmes, ces oprations sont indivisibles, c'est--dire que le systme garantit l'absence d'interfrence entre leurs excutions par plusieurs processus. On dit encore que ce sont des primitives.

13.1.2. Les smaphores


Un smaphore est un mcanisme propos par E.W.Dijkstra en 1965, et qui est un peu plus gnral que le verrou. Il se prsente comme un distributeur de jetons, mais le nombre de jetons est fixe et non renouvelable: les processus doivent restituer leur jeton aprs utilisation. S'il y a un seul jeton en circulation, on retrouve le verrou. Les deux oprations sur un smaphore sont traditionnellement dnotes P(s) et V(s), mais cette notation est de peu de signification pour ceux qui parlent le Hollandais, et aucune pour les autres6! P(s) ou down(s) permet un processus d'obtenir un jeton, s'il y en a de disponibles. Si aucun n'est disponible, le processus est bloqu. V(s) ou up(s) permet un processus de restituer un jeton. Si des processus taient en attente de jeton, l'un d'entre eux est ractiv et le reoit. Notons qu'un smaphore peut tre vu comme un couple constitu d'un entier, encore appel le niveau du smaphore et d'une file d'attente de processus. Le niveau est le nombre de jetons encore disponibles. Il est vident que si le niveau est positif, la file d'attente est vide. Parfois on utilise les valeurs ngatives du niveau pour reprsenter le dficit en jetons, c'est dire le nombre de processus en attente de jeton. la cration d'un smaphore, il faut dcider du nombre de jetons dont il dispose. On voit que si une ressource est un seul point d'accs (critique), le smaphore doit avoir initialement 1 jeton, qui sera attribu successivement chacun des processus demandeurs. Si une ressource est n points d'accs, c'est--dire, peut tre utilise par au plus n processus la fois, il suffit d'un smaphore initialis avec n jetons. Dans les deux cas, un processus qui cherche utiliser la ressource, demande d'abord un jeton, puis utilise la ressource lorsqu'il a obtenu le jeton et enfin rend le jeton lorsqu'il n'a plus besoin de la ressource.

En Franais, on peut leur donner ventuellement la signification mnmonique Puis-je pour P, et Vas-y pour V. - 114 -

Synchronisation et communication

13.1.3. Les mcanismes plus labors


Les mcanismes proposs ci-dessus sont assez rudimentaires. Ils posent deux problmes: Que faire lorsqu'on dsire mettre en uvre une politique d'allocation plus labore? Que faire pour obliger les processus respecter une certaine rgle du jeu? Le premier problme peut tre rsolu en construisant un algorithme plus ou moins complexe, qui utilise une zone de mmoire commune aux processus et des smaphores pour assurer la synchronisation. La figure 13.1 donne un exemple o l'on distingue deux sortes de processus qui accdent un mme fichier, les lecteurs qui excutent une suite de lectures sur le fichier, et les rdacteurs qui excutent une suite de lectures et d'critures. Les morceaux de programme correspondants montrent une faon de garantir qu'un rdacteur accde seul au fichier, alors que les lecteurs peuvent y accder ensembles. initialisation
mutex.niveau := 1; lect_redac.niveau := 1; n_l := 0;

processus lecteurs
down(mutex); n_l := n_l + 1; si n_l = 1 alors down(lect_redac); finsi; up(mutex); ... lectures ... down(mutex); n_l := n_l - 1; si n_l = 0 alors up(lect_redac); finsi; up(mutex);

processus rdacteurs

down(lect_redac);

lectures et critures

up(lect_redac);

Fig. 13.1. Exemple de synchronisation entre des lecteurs et des rdacteurs. Deux smaphores dots chacun d'un seul jeton sont utiliss, ainsi qu'un compteur commun qui note le nombre de lecteurs en cours. Le jeton lect_redac est possd soit par un rdacteur, soit par l'ensemble des lecteurs. C'est pourquoi, seul le premier lecteur demande ce jeton, qui est restitu par le dernier lecteur qui sort. Le deuxime smaphore contrle l'accs la ressource critique n_l par les lecteurs. Le deuxime problme voqu ci-dessus est bien visible dans cet exemple: comment obliger les processus lecteurs ou rdacteurs respecter la rgle du jeu qui vient d'tre dcrite? La solution adopte par certains systmes est de dfinir plusieurs politiques de gestion de certaines ressources par le biais d'oprations spcifiques, et de contrler le respect de la rgle du jeu par les processus dans ces oprations. Ainsi certains systmes de gestion de fichiers ont un paramtre particulier de l'opration d'ouverture qui prcise si le processus dsire l'accs exclusif ou partag au fichier. Lorsque le processus demande l'accs exclusif, il sera mis en attente si un autre processus accde dj au fichier; de plus, lorsque le processus obtient l'accs, le systme empche tout autre processus d'y accder. Lorsque le processus demande l'accs partag, il ne sera mis en attente que si un processus a obtenu l'accs en exclusif sur le fichier. Notons que ceci implique que le systme excute pour le compte du processus un algorithme voisin de celui d'un lecteur ou d'un rdacteur propos plus haut. De mme, les SGBD prennent en compte les conflits d'accs aux donnes de la base, et obligent explicitement ou implicitement les processus respecter une rgle du jeu fixe par le SGBD ou par l'administrateur de la base de donnes. Du point de vue des processus, une rgle du jeu implicite
- 115 -

Environnement physique transforme la base de donnes en une ressource virtuelle au sens o nous l'avons dfini dans le chapitre prcdent, les processus pouvant y accder comme s'ils taient seuls.

13.2. La communication entre processus


Lorsque des processus ont besoin d'changer des informations, ils peuvent le faire par l'intermdiaire d'une zone de mmoire commune. Nous en avons dj vu un exemple lors de la prsentation des lecteurs et des rdacteurs ci-dessus: les lecteurs accdent au mme compteur n_l. Cette communication prsente l'inconvnient d'tre peu structure, et de ncessiter l'utilisation de l'exclusion mutuelle d'accs cette zone commune. Par ailleurs elle pose des problmes de dsignation des donnes de cette zone qui doit tre dans l'espace de chaque processus qui dsire communiquer avec les autres.

13.2.1. Le schma producteur-consommateur


On peut dfinir un mcanisme gnral de communication entre processus, o l'un est l'metteur de l'information (on lui donne le nom de producteur), et l'autre est le rcepteur de l'information (on lui donne le nom de consommateur). Il n'est souvent pas ncessaire de faire attendre le producteur jusqu' ce que le consommateur ait reu l'information. Pour cela il suffit de disposer d'un tampon entre les deux processus pour assurer la mmorisation des informations produites non encore consommes. Nous appellerons message le contenu d'une telle information. Le tampon peut recevoir un nombre limit de ces messages, not N. Les deux processus doivent se synchroniser entre eux de faon respecter certaines contraintes de bon fonctionnement. La figure 13.2 donne un schma de cette synchronisation. initialisation
n_plein.niveau := 0; n_vide.niveau := N;

producteur
down(n_vide); dpt dans le tampon; up(n_plein);

consommateur
down(n_plein); retrait du tampon; up(n_vide);

Fig. 13.2. Le schma producteur-consommateur. Le producteur ne peut dposer un message dans le tampon s'il n'y a plus de place libre. Le nombre de places libres dans le tampon peut tre symbolis par un nombre correspondant de jetons disponibles; ces jetons peuvent tre conservs par un smaphore n_vide. Le consommateur ne peut retirer un message depuis le tampon s'il n'y en a pas. Le nombre de messages dposs peut tre galement symbolis par un nombre correspondant de jetons disponibles; ces jetons peuvent tre conservs par un smaphore n_plein. Le consommateur ne doit pas retirer un message que le producteur est en train de dposer. Cette dernire contrainte est implicitement obtenue, dans le schma de la figure, si les messages sont retirs dans l'ordre o ils ont t mis. Informellement, on peut dire que le producteur prend d'abord un jeton de place libre, dpose son message et rend un jeton de message disponible. De son ct, le consommateur prend un jeton de message disponible, retire le message et rend un jeton de place libre. Pour obliger les processus respecter la rgle du jeu, les systmes proposent souvent des oprations de dpt et de retrait qui assurent elles-mmes la synchronisation entre les processus.

13.2.2. Les tubes Unix


Les tubes Unix (en anglais pipes) sont une implantation de la communication suivant le schma producteur-consommateur, avec un tampon de taille fixe, interne au systme. Pour un processus, un tube se prsente comme deux flots, l'un ouvert en criture (pour le producteur), l'autre ouvert en lecture (pour le consommateur). Lorsqu'un processus cre un tube, le systme lui retourne les deux flots. Si ce processus cre ensuite un processus fils (opration fork vue prcdemment), celui-ci obtient une copie des flots ouverts, lui permettant ainsi de lire ou d'crire dans le tube, moins que

- 116 -

Synchronisation et communication l'un de ces flots n'ait t ferm. Ne peuvent donc communiquer par un tube que les processus situs dans la sous-arborescence dont la racine est le processus qui a cr ce tube. Lors d'une criture de n octets par le producteur, celui-ci sera mis en attente s'il n'y a pas assez de place dans le tube pour y mettre les n octets. Il sera ractiv lorsque les n octets auront pu tre tous crits dans le tube. Par ailleurs, le systme interrompra l'excution normale du processus s'il n'y a plus de consommateur pour ce tube. Lors d'une lecture de p octets par le consommateur, celui-ci sera mis en attente s'il n'y a pas assez d'octets dans le tube pour satisfaire la demande. Il sera ractiv lorsque le nombre d'octets demand aura pu lui tre dlivr. Par ailleurs, s'il n'y a plus de producteur pour ce tube, le systme lui dlivrera les octets restants, charge pour le consommateur, lorsqu'il obtient un nombre d'octets nul, d'en dduire que la production est termine. La figure 13.3 donne un exemple de cette communication. Le processus pre cre le tube et le processus fils, puis envoie dans le tube la suite des entiers de 0 1000, les entiers tant supposs sur 2 octets. Le processus fils lit les octets 2 par 2 depuis le tube dans un entier et imprime celui-ci. Il s'arrte lorsque le tube est vide et que le pre a ferm le tube en criture, puisque alors il n'y a plus de producteur.
var tube: tableau [0..1] de flot; i : entier; dbut pipe(tube); { cration du tube } si fork() 0 alors { cration du processus fils } fermer (tube[0]); { le pre ne lit pas dans le tube } pour i := 0 jusqu' 1000 faire crire (tube[1], i, 2); { criture de deux octets } fait; fermer (tube[1]); { le pre a fini } wait(0); { attente de la fin du fils } sinon fermer (tube[1]); { le fils n'crit pas dans le tube } tant que lire (tube[0], i, 2) = 2 faire imprimer (i); { on suppose qu'un entier occupe 2 octets } fait; fermer (tube[0]); { le fils a fini } finsi; fin;

Fig. 13.3. Communication par tubes Unix. Les tubes Unix ne conservent pas la structuration des messages qui sont envoys par le producteur. Dans l'exemple ci-dessus, producteur et consommateur participent tous les deux cette structuration: le consommateur lit depuis le tube les octets 2 par 2 pour retrouver la structure des messages mis par le producteur. Notons que ceci est conforme la philosophie dj nonce de ce systme qui prsente tout objet externe comme une suite linaire d'octets. Cette uniformit prsente l'avantage de cacher au programme la nature de l'objet externe manipul, mme lorsqu'il s'agit d'un tube.

13.2.3. La communication par bote aux lettres


Nous appellerons bote aux lettres un objet systme qui implante le schma producteurconsommateur dfini plus haut, en conservant le dcoupage en messages tels que les a dposs le producteur. Les messages sont parfois typs, comme dans iRMX86, o les messages comportent un en-tte qui prcise, en particulier, sa longueur et son type sous la forme d'un code dfini par le programmeur. Le problme de la dsignation d'une bote aux lettres par les processus est rsolu de diffrentes faons. Il s'agit, en effet, de permettre des processus dont les espaces mmoire sont disjoints de pouvoir dsigner une mme bote aux lettres. Une solution comme celle propose par Unix pour les tubes, peut tre retenue, qui consiste mettre cette dsignation dans le contexte des processus au moment de leur cration. On prfre, en gnral, une solution semblable une dition de liens, qui consiste donner un nom symbolique aux botes aux lettres, sous forme d'une chane de caractres. Le systme maintient une table de ces noms symboliques associs aux botes aux lettres qui ont dj t cres et non encore dtruites. Lorsqu'un processus demande l'accs une telle bote aux lettres,
- 117 -

Environnement physique le systme consulte cette table, et retourne au demandeur le descripteur de la bote aux lettres (c'est, par exemple, son indice dans le table). Les oprations suivantes se feront en utilisant ce descripteur. Dans certains cas, cette demande d'accs entrane sa cration implicite si elle n'existe pas, alors que d'autres systmes sparent l'opration de cration explicite de la demande d'accs. Les oprations sur une bote aux lettres sont l'envoi et la rception de message. L'envoi avec ou sans blocage du demandeur lorsque la bote aux lettres est pleine. La rception galement avec ou sans blocage lorsque la bote aux lettres est vide. De plus, certains permettent de filtrer les messages reus, c'est--dire, qu'il est possible de prciser le messages que l'on accepte de recevoir. peut tre peut tre systmes type des

Les botes aux lettres ont souvent une capacit limite de messages, comme nous l'avons indiqu dans le schma gnral. Parfois cette capacit est nulle, l'envoi de message ne pouvant avoir lieu que lorsque le receveur est prt recevoir le message. Constatons que le schma prcdent doit tre modifi; nous en laissons le soin au lecteur. On dit alors qu'il y a communication synchrone entre le producteur et le consommateur. L'intrt essentiel est que cette fois, aprs le retour de la primitive d'envoi, le producteur a la garantie que le consommateur a effectivement reu le message, alors que dans le cas gnral, le producteur ne peut prjuger du moment o cette rception aura lieu. En contrepartie, les processus supportent une contrainte de synchronisation plus forte.

13.3. Les consquences sur les temps de rponse


Dans les premiers chapitres, nous avons dfini le temps de rponse comme le dlai qui spare l'envoi d'une commande par un utilisateur, de la fin d'excution de la commande. Nous pouvons ici dcomposer ce dlai en trois mesures diffrentes, suivant les tats du processus correspondant. Dans l'tat actif, on mesure le temps de processeur (le temps virtuel) ncessaire l'excution proprement dite de la commande. Ce temps est videmment incompressible, pour un programme donn. L'algorithme de la commande elle-mme doit tre efficace pour minimiser ce temps. Dans l'tat prt, on mesure le temps pendant lequel le processus attend le processeur, ressource possde par un autre processus. L'idal, pour l'utilisateur, est de rduire le plus possible ce temps. C'est en quelque sorte le prix qu'il doit payer pour ne pas avoir payer plus cher la machine. Sur un systme normalement charg, ce temps ne devrait pas tre important. Si ce temps est important pour tous les processus, il est probable que ce soit l'indication d'un systme surcharg, qui ncessite une augmentation de puissance. Dans l'tat bloqu, on mesure le temps pendant lequel le processus attend une ressource autre que le processeur. Cette attente peut avoir deux causes: La premire est due la lenteur de l'accs demand lors des entres-sorties. Comme pour le temps de processeur, le programmeur peut amliorer l'algorithme pour rduire le nombre de ces entres-sorties. Un choix plus judicieux du support peut galement avoir une certaine influence. L'autre cause est due au fait que la ressource est possde par un autre processus. Ceci implique un conflit entre les utilisateurs. videmment, si l'utilisateur tait seul, ce conflit n'existerait pas. C'est souvent un paramtre trs important, mais parfois nglig et difficile contrler. La rduction de ces conflits ncessite de multiplier les ressources (beaucoup de petites au lieu d'une grosse), pour diminuer la probabilit de conflit, et de minimiser la portion de programme pendant laquelle les processus rservent l'accs ces ressources (rservation le plus tard possible et libration le plus tt possible).

13.4. La notion d'interblocage


La synchronisation et la communication des processus peut conduire un autre problme. Supposons qu'un premier processus P1 demande et obtienne la ressource imprimante, seule ressource de ce type. Un second processus P2 demande ensuite et obtient la ressource drouleur de bande, galement seule de ce type. Si P1 demande ultrieurement la ressource drouleur de bande sans avoir libr la ressource imprimante, il est bloqu en attendant la libration par P2 . Si maintenant, P2 demande la ressource imprimante avant de librer la ressource drouleur de bande, il est bloqu en attendant la libration par P1 de cette ressource. On voit que chacun des processus est
- 118 -

Synchronisation et communication bloqu, en attendant que l'autre libre la ressource qu'il possde. On dit qu'il y a un interblocage entre les processus (en anglais deadlock). On peut donner une reprsentation graphique l'interblocage. Reprsentons les ressources par des rectangles, et les processus par des cercles. On met une flche d'une ressource vers un processus lorsque la ressource est alloue au processus, et une flche d'un processus vers une ressource lorsque le processus attend cette ressource. La figure 13.4 reprsente l'volution du graphe de notre exemple prcdent conduisant l'interblocage.
P1 P2 P1 P2

imprimante drouleur allocation de l'imprimante P1 P1 P2

imprimante

drouleur

allocation du drouleur P2 P1 P2

imprimante

drouleur

imprimante

drouleur

attente du drouleur par P1

attente de l'imprimante par P2 interblocage

Fig. 13.4. Allocation conduisant l'interblocage. On peut constater que dans le graphe final, il y a un cycle reprsent par:
P1 drouleur P2 imprimante

En fait, tout interblocage est signal par la prsence d'un tel cycle dans ce graphe, et inversement, ce qui explique l'intrt de cette reprsentation. Le problme de l'interblocage est rsolu de diverses faons par les systmes. La premire mthode est la politique de l'autruche: elle consiste ignorer le problme! Considrant que le cot des autres mthodes est assez lev, il peut s'avrer rentable de ne pas rsoudre le problme lorsque la probabilit d'avoir un interblocage est faible. S'il survient, il faut relancer le systme. La deuxime mthode est une mthode de dtection-gurison. Elle consiste vrifier de temps en temps la prsence de tels cycles, et tuer un ou plusieurs processus jusqu' la disparition de ces cycles. Chaque destruction d'un tel processus entrane videmment la restitution des ressources qu'il possdait. La troisime mthode est une mthode de prvention. Elle consiste imposer des contraintes sur les demandes des processus de telle sorte qu'un tel cycle ne puisse jamais se produire. Ainsi, si les deux processus ci-dessus demandaient leurs ressources dans le mme ordre (par exemple imprimante puis drouleur), le deuxime processus serait bloqu sur la demande de la premire ressource, sans avoir encore obtenu aucune ressource, et il ne pourrait y avoir de cycle. La quatrime mthode est une mthode d'vitement. Elle consiste prvoir l'avance les diffrents cas o un cycle pourrait se former, et viter l'interblocage en retardant une allocation qui serait possible, jusqu' tre certain qu'il n'y a pas de risque d'interblocage. La figure 13.5 montre sur notre exemple qu'en retardant l'allocation du drouleur P2 jusqu' ce que P1 ait libr l'imprimante, on permet celui-ci d'acqurir le drouleur avant P2 et on vite ainsi la cration du cycle. Il faut videmment savoir l'avance quels seront les besoins des processus dans ce cas.

- 119 -

Environnement physique

P1

P2

P1

P2

imprimante drouleur allocation de l'imprimante P1 P1 P2

imprimante drouleur attente du drouleur par P2 P1 P2

imprimante drouleur allocation du drouleur P1

imprimante drouleur libration des ressources par P1 et allocation du drouleur P2 P1 P2

P1

P2

imprimante drouleur allocation de l'imprimante P2

imprimante drouleur libration des ressources par P2

Fig. 13.5. vitement de l'interblocage. La mthode utilise dpend des applications qui sont les plus courantes sur le systme. Par exemple, les systmes d'IBM, mais aussi ceux de bien d'autres constructeurs, ont utilis successivement plusieurs de ces mthodes. Aprs avoir appliqu la politique de l'autruche justifie par le fait que les plantages du systme taient bien plus frquents que les interblocages, la politique de prvention a t utilise pour le traitement par lot. La politique d'vitement est galement souvent utilise pour le traitement par lot. Par contre, la plupart des systmes transactionnels prfrent la politique de dtection-gurison, en dtruisant une transaction qui demande une ressource si son blocage entrane un cycle. Le noyau d'Unix utilise la politique de l'autruche, considrant que l'utilisateur qui constate un interblocage entre ses processus, peut toujours les tuer lui-mme depuis sa console.

13.5. La notion de famine


Un processus qui est en attente d'une ressource peut rester bloqu indfiniment sans tre pour autant en situation d'interblocage. On dit que l'on a une situation de famine (en anglais starvation), lorsque un ou plusieurs processus n'obtiennent pas les ressources dont ils ont besoin par suite du comportement de l'ensemble des processus, sans tre en situation d'interblocage. La diffrence essentielle rside dans le fait qu'il est possible de sortir de la situation de famine par suite du changement du comportement des processus, alors qu'il n'est pas possible de sortir d'un interblocage sans retirer autoritairement une ressource un des processus en interblocage. Reprenons l'exemple des lecteurs-rdacteurs que nous avons prsent plus haut. Supposons qu'aucun processus n'accde initialement au fichier. Lorsque le premier lecteur obtient le jeton lect_redac, il interdit tous les crivains de l'obtenir tant que le dernier lecteur ne l'a pas t libr. Par contre les lecteurs peuvent toujours obtenir l'accs en lecture qu'ils dsirent. Il peut s'en suivre une coalition des lecteurs de telle sorte qu'il y ait toujours un lecteur en permanence sur le fichier. Les rdacteurs n'obtiendront alors jamais satisfaction. Cependant, il ne s'agit pas d'un interblocage, puisque si les lecteurs s'arrtent de travailler, le dernier librera le jeton lect_redac permettant ainsi aux rdacteurs d'obtenir l'un aprs l'autre satisfaction.

- 120 -

Synchronisation et communication initialisation


quit.niveau := 1; mutex.niveau := 1; lect_redac.niveau := 1; n_l := 0;

processus lecteurs
down(quit); down(mutex); n_l := n_l + 1; si n_l = 1 alors down(lect_redac); finsi; up(mutex); up(quit); ... lectures ... down(mutex); n_l := n_l - 1; si n_l = 0 alors up(lect_redac); finsi; up(mutex);

processus rdacteurs
down(quit);

down(lect_redac);

up(quit); lectures et critures

up(lect_redac);

Fig. 13.6. Synchronisation quitable des lecteurs et des rdacteurs. La famine est souvent une consquence de la politique d'allocation qui est suivie. Si elle est quitable, elle sera vite. Sur notre exemple (figure 13.6), l'introduction d'un smaphore supplmentaire quit vite la famine, pourvu que le dblocage des processus en attente sur un smaphore soit effectu dans l'ordre o ils sont arrivs. En effet, tous les processus doivent maintenant acqurir un jeton quit pour savoir s'ils peuvent entrer, et le librent lorsqu'ils ont obtenu l'autorisation. Comme l'attribution du jeton quit est faite dans l'ordre o les processus sont demandeurs, un processus lecteur n'obtiendra le sien que lorsque tous les rdacteurs arrivs avant lui auront obtenu satisfaction. Par contre, si plusieurs lecteurs se suivent, le premier obtiendra le jeton quit puis le jeton lect_redac, et librera le jeton quit permettant aux lecteurs qui le suivent immdiatement d'entrer dans leur phase de lecture.

13.6. Conclusion
Le mcanisme de verrouillage permet de faire en sorte qu'au plus un seul processus possde le verrou un instant donn. Les oprations sur les verrous sont des primitives systmes. Un smaphore est une gnralisation du verrou. Il s'apparente un distributeur de jetons non renouvelables qui sont rendus aprs utilisation. Lorsqu'un processus dsire un jeton et qu'aucun n'est disponible, il est mis en attente jusqu' ce qu'un autre processus rende son jeton. Des mcanismes plus labors peuvent tre construits l'aide des smaphores et de variables communes aux processus. Le respect d'une rgle du jeu est souvent impos par le systme en fournissant directement ces mcanismes, comme par exemple l'accs exclusif ou partag un fichier. Le schma producteur-consommateur est un mcanisme gnral de communication entre processus, dont les tubes Unix sont une implantation fournie par le systme. Les botes aux lettres sont aussi une implantation de ce schma qui tient compte de la structure des messages changs. Le blocage des processus en attente de ressources a des consquences videntes sur les temps de rponse, et ceci ne doit pas tre nglig. La consquence du blocage des processus est le risque d'interblocage. Ceci se prsente lorsqu'on a un ensemble de processus qui attendent des ressources qui sont toutes possdes par des processus de l'ensemble. Lorsqu'il survient, il est ncessaire de tuer des processus de l'ensemble.

- 121 -

Environnement physique Un processus peut galement tre en famine, lorsqu'il attend une ressource qu'il n'obtient pas parce que les autres processus se coalisent pour l'en empcher. On l'vite par une allocation quitable. La diffrence entre la famine et l'interblocage est qu'un changement de comportement des processus permettrait de satisfaire le processus en famine, alors que l'on ne peut sortir de l'interblocage qu'en retirant autoritairement une ressource l'un des processus.

- 122 -

14

La gestion de la mmoire centrale

A l'origine, la mmoire centrale tait une ressource chre et de taille limite. Elle devait tre gre avec soin. Sa taille a considrablement augment depuis, puisqu'un compatible PC a souvent aujourd'hui la mme taille de mmoire que les plus gros ordinateurs de la fin des annes 60. Nanmoins, le problme de la gestion reste important du fait des besoins croissants des utilisateurs.

14.1. La notion de multiprogrammation


La multiprogrammation a t prsente dans le premier chapitre comme un moyen pour amliorer l'efficacit de l'utilisation du processeur. Un processus est alternativement dans des phases actives, pendant lesquelles il volue, et dans des phases d'attente d'une ressource, pendant lesquelles il n'a pas besoin du processeur. Dans un systme monoprogramm, la mmoire centrale est dcoupe en deux parties: une partie est rserve au systme et le reste est attribu au processus. Lorsque le processus est en attente de ressource, le processeur n'a rien faire. La multiprogrammation consiste dcouper la mmoire centrale en plusieurs parties, de faon mettre plusieurs processus en mmoire au mme moment, de telle sorte avoir plusieurs processus candidats au processeur.

14.1.1. L'intrt de la multiprogrammation


Supposons que deux processus P1 et P2 soient prsents en mmoire et que leur comportement corresponde l'alternance de 100 ms de processeur et 100 ms d'attente d'entres-sorties. On voit que le processeur va pouvoir faire voluer P1 pendant 100 ms jusqu'au lancement de son entresortie, puis faire voluer P2 pendant 100 ms jusqu'au lancement de la sienne. A ce moment, l'entresortie de P1 tant termine, le processeur pourra le faire voluer pendant une nouvelle priode de 100 ms, et ainsi de suite. De la sorte, d'une part, les deux processus travaillent leur vitesse maximum, d'autre part, le processeur est utilis 100% au lieu de 50% en monoprogrammation. La situation ci-dessus est en fait idale. Les dures d'activit ou d'attente d'entres-sorties des processus ne sont pas en fait constantes. Si la situation est amliore, c'est--dire, si le processeur est mieux utilis, il faut mettre, dans cet exemple, plus de deux processus en mmoire pour approcher un taux d'activit du processeur de 100%. La figure 14.1 donne le taux d'activit du processeur que l'on obtient en fonction du nombre de processus prsents en mmoire, pour diffrents taux d'attente d'entres-sorties de ces processus. Le nombre de processus prsents en mmoire est encore appel degr de multiprogrammation. En particulier, ces courbes montrent qu'il faut 5 processus ayant un taux d'entres-sorties de 50% pour approcher 97% du taux d'activit du processeur.

- 123 -

Environnement physique
taux activit processeur 100 20% 80 50%

60 40 20


1 2

80%

taux d'attente d'entres- sorties processus 3 4 5 6 7 8 9 10

Fig. 14.1. Taux d'activit du CPU en fonction du nombre de processus. La justification de ces courbes est probabiliste. Le taux d'attente d'entres-sorties peut s'interprter comme la probabilit que le processus soit en attente d'entres-sorties un instant donn. Si le degr de multiprogrammation est n, la probabilit pour que tous les processus soient en attente d'entres-sorties est alors pn. Il s'ensuit que la probabilit pour qu'un processus au moins soit prt, et donc que le processeur soit actif est: taux_processeur = 1 - pn. Ces courbes sont le reflet de cette relation. Notons que lorsque le taux d'activit est de 20%, par exemple dans le cas d'une alternance de 10 ms de processeur et de 40 ms d'entres-sorties, il faut 10 processus pour atteindre un taux d'activit de 90%. Or les applications de gestion ont souvent un taux d'activit infrieur une telle valeur, ce qui justifie dans ce cas un degr de multiprogrammation important pour avoir une bonne utilisation du processeur.

14.1.2. Les consquences de la multiprogrammation


La multiprogrammation a des consquences sur la gestion de la mmoire centrale. On peut distinguer trois problmes que doit rsoudre le systme. Dfinir un espace d'adresses par processus. Chaque processus doit conserver son indpendance. Il doit pouvoir crer des objets dans son espace d'adresses et les dtruire, sans qu'il y ait interfrence avec les autres processus. Les caractristiques du matriel sont importantes, car elles offrent plus ou moins de souplesse pour cette dfinition. Protger les processus entre eux. Il est ncessaire que chacun reste chez soi, du moins pour les objets qui leur sont propres. Il faut donc pouvoir limiter les actions des processus sur certains objets, en particulier interdire les accs ceux qui ne leur appartiennent pas. Attribuer un espace de mmoire physique. Comme un objet n'est accessible au processeur que s'il est en mmoire physique, il faut allouer de la mmoire physique aux processus, et assurer la traduction d'une adresse d'un objet dans son espace propre en l'adresse en mmoire physique o il est situ. Il faut bien distinguer l'espace des adresses d'un processus de l'espace de mmoire physique. Si dans certains cas, il y a une certaine identit, comme dans le partitionnement, nous verrons avec la segmentation que les structures de ces deux espaces peuvent tre trs diffrentes.

14.1.3. Les difficults du partitionnement


Considrons une mmoire centrale linaire de N emplacements. L'espace des adresses physiques est dans ce cas l'ensemble des entiers compris entre 0 et N-1. La premire mthode pour rsoudre les problmes ci-dessus a t de dcouper cet espace des adresses physiques en zones disjointes, que l'on appel partitions, et de construire ainsi des espaces d'adresses disjoints pour plusieurs processus. Lors de sa cration, un processus dispose de l'un de ces espaces, par exemple la partition [A..B]. Il est libre de placer les objets comme il l'entend l'intrieur de cet espace. Si un autre processus est prsent en mmoire en mme temps que lui, celui-ci disposera d'un autre espace disjoint du prcdent, par exemple la partition [C..D], telle que l'on ait B<C ou D<A.
- 124 -

Gestion de la mmoire centrale La protection peut tre obtenue simplement en interdisant au processus de construire une adresse en dehors de sa partition. Par exemple, le processeur se droutera vers le systme si, lorsqu'il excute une instruction pour un processus dont l'espace des adresses est la partition [A..B], il gnre une adresse en dehors de cette partition. L'allocation de mmoire physique est en fait assez simple, puisqu'un processus dont l'espace des adresses est la partition [A..B] reoit la portion de mmoire physique comprise entre les adresses A et B. On peut dfinir un partitionnement fixe, par exemple au lancement du systme, les partitions n'tant pas forcment toutes de la mme taille, comme le montre la figure 14.2. Il est possible de dfinir a priori la partition dont dispose un processus donn. L'allocation de mmoire physique est alors obtenue en associant une file d'attente par partition, les processus d'une mme partition tant amens les uns aprs les autres dans la portion correspondante de mmoire physique. Cette mthode prsente l'inconvnient qu'une partition peut tre libre (pas de processus en mmoire ni dans la file d'attente), alors que d'autres sont surcharges, entranant une mauvaise utilisation de la mmoire et du processeur.
partition 4 partition 3 600 k partition 2 partition 1 systme 0 files multiples file unique 350 k 250 k partition 2 partition 1 systme 1000 k 850 k partition 3 partition 4

Fig. 14.2. Gestion mmoire par partitionnement. En utilisant un chargeur translatable, il est possible de retarder l'attribution de la partition au processus. On dispose alors d'une seule file d'attente de processus. Lorsqu'une partition est libre, le systme recherche un processus de la file qui peut se satisfaire de la taille de cette partition, et le charge en mmoire dans cette partition. La recherche peut s'arrter sur le premier trouv, ou rechercher celui qui a le plus gros besoin d'espace, tout en tant infrieur la taille de la partition; notons que ceci peut entraner la famine d'un processus qui ne demanderait qu'un tout petit espace. Un inconvnient du partitionnement fixe rside dans une mauvaise utilisation de la mmoire physique, dans la mesure o un processus reoit une portion de mmoire plus grande que ncessaire. Il est possible de rendre variables les tailles des partitions, un processus ne recevant que ses besoins stricts. L'espace allou un processus devant tre contigu, on retrouve alors les mmes inconvnients que ceux rencontrs pour l'allocation par zone des objets externes sur disque. Cette mthode est souvent utilise dans les micro-ordinateurs, pour la mise en mmoire de plusieurs programmes, tout en n'ayant toujours qu'un seul de ces programmes qui s'excute.

14.2. La notion de mmoire segmente


Un espace d'adresse linaire pour un processus est parfois une gne, car cela complique la gestion des objets dans cet espace par le processus. Cette difficult est accrue si le processus dsire partager des donnes ou du code instruction avec un autre processus. Dans ce cas, comment chacun de ces processus va-t-il dsigner ces objets partags dans son propre espace? Si l'espace est assez grand, les processus peuvent, par exemple, dcider a priori de rserver des parties de leur espace de tels objets. Pour viter ces inconvnients, on a introduit la notion de mmoire segmente, qui est une sorte d'espace deux dimensions (figure 14.3). Chaque processus dispose de son propre espace mmoire constitu d'un ensemble de segments, chaque segment tant un espace linaire de taille limite. Un
- 125 -

Environnement physique emplacement de cet espace est dsign par un couple <s, d> o s dsigne le segment, et d un dplacement l'intrieur du segment. Un segment regroupe en gnral des objets de mme nature (instructions, donnes ou constantes, partages ou propres, etc...). On retrouve ici une notion dj rencontre lors de l'dition de liens: un module est constitu de sections, et l'diteur de liens regroupe ensemble les sections de mme nature.
taille

segments

Fig. 14.3. Reprsentation d'une mmoire segmente. Cette notion de mmoire segmente peut ou non tre prise en compte par le matriel. Lorsqu'elle ne l'est pas, l'diteur de liens ou le chargeur place les segments dans un espace linaire, avant de lancer l'excution du processus. Ce placement est alors statique, et la taille des segments est souvent invariable. Certains matriels prennent en compte un tel espace, en assurant dynamiquement la traduction d'une adresse segmente en une adresse dans un espace linaire, au moyen de tables spcifiques qui contiennent les informations de localisation de chaque segment, encore appels descripteurs de segment. Un tel descripteur contient les informations suivantes: L'indicateur de validit indique si le segment existe ou non. L'adresse de dbut indique o commence le segment dans l'espace linaire. La taille du segment indique le nombre d'emplacements du segment. Le processus doit donner des dplacements dans le segment qui soient infrieurs la taille. Les droits indiquent les oprations du processus sur le segment qui sont autorises. La figure 14.4 montre le fonctionnement de l'adressage segment. Lorsque le processeur interprte une adresse segmente <s, d> pour le compte d'un processus, il compare d'abord la valeur de s avec le champs LT de son registre spcialis qui dfinit la table des descripteurs de segments du processus. Si la valeur est acceptable, il lit en mmoire ce descripteur, dont il vrifie l'indicateur de validit puis contrle que les droits sont suffisants. Il compare ensuite d avec le champs taille de ce descripteur. Si la valeur est acceptable, il ajoute d l'adresse de dbut du segment et obtient ainsi l'adresse de l'emplacement dans la mmoire linaire. En gnral, pour viter l'accs mmoire supplmentaire pour obtenir le descripteur de segment, le processeur dispose de registres spcialiss qui contiennent les descripteurs des derniers segments accds par le processus.
adresse segmente s d registre d'adresse table des segments LT adresse table + < oui + taille adr. dbut mmoire linaire table des descripteurs de segments < oui

taille

Fig. 14.4. Fonctionnement de l'adressage segment. La dfinition du contenu de la table des descripteurs de segments est la charge du systme, qui doit allouer l'espace dans la mmoire linaire lors de la cration des segments. L'allocation est une allocation par zone contigu. Mais, notons que le passage systmatique par la table des descripteurs
- 126 -

Gestion de la mmoire centrale de segments permet de dplacer un segment dans la mmoire linaire, puisqu'il suffit ensuite de modifier le champs adresse de dbut du descripteur pour permettre au processus de continuer son fonctionnement aprs ce dplacement. Voici quelques exemples de processeurs disposant de l'adressage segment: Dans Multics, un processus peut avoir 32768 segments, chacun des segments pouvant atteindre 256 Kmots de 36 bits. Dans l'intel iAPX286 (le processeur des PC-AT), la table des descripteurs de segments d'un processus est divise en deux parties, une table des segments communs tous les processus, et une table propre chaque processus. Chacune de ces tables peut avoir 8192 segments, et chaque segment peut avoir jusqu' 64 Koctets. La mmoire linaire est la mmoire physique, et peut atteindre 16 Moctets. L'intel iAPX386 (et suivants) est assez voisin de l'iAPX286, du point de vue adressage segment, si ce n'est que les segments peuvent atteindre 4 Goctets. La mmoire linaire peut atteindre 4 Goctets et peut, de plus, tre pagine (voir ci-dessous).

14.3. Le mcanisme de pagination


Le mcanisme de pagination a t imagin pour lever la contrainte de contigut de l'espace de mmoire physique alloue aux processus. Pour cela, la mmoire physique est dcoupe en blocs de taille fixe, que nous appellerons case (en anglais frame). Par ailleurs, la mmoire linaire des processus, encore appele mmoire virtuelle, est elle-mme dcoupe en blocs de taille fixe, que nous appellerons page. La taille d'une page correspond la taille d'une case. Chaque page peut alors tre place dans une case quelconque. Le mcanisme de pagination du matriel assure la traduction des adresses de mmoire virtuelle en une adresse de mmoire physique, de faon retrouver la contigut de cette mmoire virtuelle.

14.3.1. La pagination un niveau


Le mcanisme de traduction des adresses virtuelles en adresses relles doit associer chaque numro de page virtuelle le numro de case relle qui contient cette page, si elle existe. La figure 14.5 montre le fonctionnement de ce mcanisme.
adresse virtuelle n_page dplacement mmoire associative registre de la table des pages adresse table n_page n_case

1 0 1 protect. n_case prsence modifie accde

n_case dplac. adresse physique

table des pages

Fig. 14.5. Fonctionnement de la pagination un niveau. Un registre spcialis du processeur contient l'adresse de la table qui mmorise cette association; cette table est appele la table des pages du processus. En gnral, l'adresse de cette table est une adresse physique. Chaque entre de cette table contient les informations suivantes: L'indicateur de prsence indique s'il y a une case alloue cette page. Le numro de case allou cette page. Les indicateurs de protection de la page indique les oprations autorises sur cette page par le processus. L'indicateur de page accde est positionn lors d'un accs quelconque.
- 127 -

Environnement physique L'indicateur de page modifie est positionn lors d'un accs en criture. Ces deux derniers indicateurs servent la gestion de la mmoire physique que nous verrons par la suite. Lorsque le processeur traduit une adresse virtuelle, il en isole le numro de page virtuelle qu'il utilise comme dplacement dans cette table des pages pour en trouver l'entre correspondante. Si l'indicateur de prsence est positionn, il contrle la validit de l'accs vis vis des indicateurs de protection. Si l'accs est accept, il concatne le numro de case au dplacement virtuel dans la page pour obtenir l'adresse en mmoire physique de l'emplacement recherch. Pour viter l'accs mmoire supplmentaire la table des pages, une mmoire associative contient les entres de la table correspondant aux derniers accs. VAX-VMS utilise un tel mcanisme de pagination un niveau, avec des pages de 512 octets. Mais pour viter d'avoir des tailles trop importantes pour la table des pages, la mmoire virtuelle est dcoupe en trois rgions, pouvant comporter chacune jusqu' 1 Goctets. Chacune de ces rgions dispose de sa propre table, et les registres correspondants contiennent leur taille effective. La rgion systme est commune tous les processus. L'adresse de sa table de pages est une adresse de mmoire physique. Les rgions P0 et P1 sont propres au processus, et leur table des pages est dans la rgion virtuelle systme. L'adresse de leur table de pages respective est donc une adresse virtuelle. Les pages de la rgion P0 sont dans les adresses virtuelles basses, alors que celles de la rgion P1 sont dans les adresses virtuelles hautes. L'augmentation de la taille de la rgion P0 se fait donc vers les adresses virtuelles croissantes, alors que celle de la rgion P1 se fait vers les adresses dcroissantes (figure 14.6).
adresse virtuelle 0000 0000 rgion P0 3FFF FFFF 4000 0000 7FFF FFFF 8000 0000 BFFF FFFF rgion P1 rgion systme espace systme espace processus

Fig. 14.6. L'espace virtuel de VAX-VMS.

14.3.2. La pagination deux niveaux


La pagination un niveau d'un espace virtuel de grande taille peut conduire des tailles importantes de la table des pages. L'exemple prcdent de VAX-VMS montre une approche pour rduire cet encombrement, mais impose des contraintes sur la gestion des objets l'intrieur mme de cette mmoire virtuelle, puisqu'il faut qu'ils se trouvent au dbut ou la fin de l'espace du processus. La pagination deux niveaux a pour but de rduire la reprsentation de la table des pages d'un processus, sans avoir des contraintes aussi fortes. La figure 14.7 montre le fonctionnement de ce mcanisme. La mmoire virtuelle est divise en hyperpages de taille fixe, chaque hyperpage tant dcoupe en pages de mme taille qu'une case de mmoire physique. Une hyperpage contient donc un nombre limit de pages. chaque hyperpage, on associe une table de pages analogue ce qui prcde. Par ailleurs, la mmoire virtuelle d'un processus est reprsente par une table des hyperpages, qui permet de localiser la table des pages de chaque hyperpage. Le gain de la reprsentation est obtenu par l'indicateur de prsence d'hyperpage qui prcise l'existence ou non de la table des pages de cette hyperpage.

- 128 -

Gestion de la mmoire centrale


adresse virtuelle n_hyp n_page dplacement mmoire associative rg. table nhyp npag ncase

1 0 1 pr. ncase prsence modifie accde table des hyperpages

1 0 1 pr. ncase

ncase dpl. adresse physique

table des pages de l'hyperpage

Fig. 14.7. Fonctionnement de la pagination deux niveaux. Lorsque le processeur traduit une adresse virtuelle, il isole d'abord le numro d'hyperpage qu'il utilise comme index dans la table des hyperpages (dont l'adresse est dans un registre spcialis) pour obtenir l'entre associe cette hyperpage. Si l'indicateur de prsence est positionn, il vrifie que les indicateurs de protection de l'ensemble de l'hyperpage autorisent l'accs dsir. Puis le processeur isole dans l'adresse virtuelle le numro de page qu'il utilise comme index dans la table des pages de l'hyperpage pour obtenir l'entre associe cette page. Il poursuit avec cette entre comme pour la pagination un niveau. Comme prcdemment, les accs mmoires supplmentaires peuvent tre vits par l'utilisation d'une mmoire associative qui conserve les entres de pages (repres par leur numro d'hyperpage et de page) correspondant aux derniers accs. Voici quelques exemples de machines ayant la pagination deux niveaux: L'IBM 370 dispose de plusieurs configurations possibles. Sur les machines mmoire virtuelle sur 16 Moctets, on peut avoir, par exemple, 256 hypergages de 16 pages de 4096 octets. L'iAPX386 structure la mmoire virtuelle (appele aussi mmoire linaire lors de l'tude de la segmentation) en 1024 hyperpages de 1024 pages de 4096 octets.

14.3.3. La segmentation vis vis de la pagination


La segmentation et la pagination sont deux notions diffrentes qui sont utilises conjointement sur certaines machines (par exemple, Multics, iAPX386). La segmentation doit tre vue comme une structuration de l'espace des adresses d'un processus, alors que la pagination doit tre vue comme un moyen d'adaptation de la mmoire virtuelle la mmoire relle. Avec la segmentation, le processus dispose d'un espace des adresses deux dimensions que le processeur transforme en une adresse dans une mmoire linaire. Sans la segmentation, le processus dispose directement de cette mmoire linaire. Avec la pagination, on dispose d'une fonction de transformation dynamique des adresses de la mmoire linaire en adresses de la mmoire physique, qui permet de placer les pages de la mmoire linaire dans des cases quelconques de mmoire physique. Sans la pagination, les pages de la mmoire linaire doivent tre places dans les cases de la mmoire physique de mme numro. Lorsqu'on dispose de la segmentation, les segments doivent tre allous dans la mmoire linaire en utilisant les techniques d'allocation par zone (portion de mmoire contigu de taille donne). Lorsqu'on dispose de la pagination, les pages de la mmoire linaire doivent tre alloues dans la mmoire physique. Il peut sembler complexe de devoir mettre en uvre les deux notions. Cependant, elles sont complmentaires, et la pagination simplifie l'allocation par zone de la segmentation. D'une part, il peut alors y avoir des pages libres au milieu de pages occupes dans la mmoire linaire, sans perte de place en mmoire physique. D'autre part, le dplacement d'une page de la mmoire linaire dans une autre page, peut tre obtenue sans dplacement dans la mmoire physique, puisqu'il suffit de modifier les entres correspondantes de la table des pages.
- 129 -

Environnement physique Notons que le partage de donnes entre deux processus peut tre obtenu de diffrentes faons. Par exemple, il peut tre obtenu au niveau des pages de leur mmoire linaire, en allouant la mme case de mmoire physique aux deux processus, au mme instant. Il peut tre obtenu au niveau des hyperpages de leur mmoire linaire, en allouant la mme table des pages deux hyperpages de ces processus. Sans pagination, il peut tre obtenu au niveau segment en allouant la mme zone de mmoire physique deux segments de chacun des deux processus.

14.3.4. Le principe de la pagination la demande


Notons tout d'abord que la mmoire virtuelle telle qu'elle a t prsente ci-dessus, peut tre de taille trs importante, et beaucoup plus grande que ce que peut tre une taille raisonnable de mmoire physique. Dans un contexte de multiprogrammation, il peut tre ncessaire de disposer de plusieurs mmoires virtuelles. Pour rsoudre cette difficult, on a imagin de ne mettre en mmoire physique que les pages de mmoire virtuelle dont les processus ont besoin pour leur excution courante, les autres tant conserves sur mmoire secondaire (disque). Lorsqu'un processus accde une page qui n'est pas en mmoire physique (indicateur de prsence non positionn), l'instruction est interrompue, et un droutement au systme est excut. On dit qu'il y a dfaut de page. Le systme doit alors allouer une case cette page, lire la page depuis la mmoire secondaire dans cette case et relancer l'excution de l'instruction qui pourra alors se drouler jusqu' son terme. Lorsqu'un dfaut de page se produit, s'il y a une case libre, le systme peut allouer cette case. Si aucune case n'est libre, il est ncessaire de rquisitionner une case occupe par une autre page. On dit qu'il y a remplacement de page. Plusieurs algorithmes de remplacement de pages ont t proposs qui diffrent par le choix de la page remplace. Si celle-ci a t modifie, il faut auparavant la rcrire en mmoire secondaire. L'algorithme optimal consiste choisir la page qui sera accde dans un avenir le plus lointain possible. videmment un tel algorithme n'est pas ralisable pratiquement, puisqu'il n'est pas possible de prvoir les accs futurs des processus. Il a surtout l'avantage de la comparaison: c'est en fait celui qui donnerait la meilleure efficacit. L'algorithme de frquence d'utilisation (encore appel LFU pour least frequently used) consiste remplacer la page qui a t la moins frquemment utilise. Il faut maintenir une liste des numros de page ordonne par leur frquence d'utilisation. Cette liste change lors de chaque accs mmoire, et doit donc tre maintenue par le matriel. L'algorithme chronologique d'utilisation (encore appel LRU pour least recently used) consiste remplacer la page qui n'a pas t utilise depuis le plus longtemps. Il faut maintenir une liste des numros de pages ordonne par leur dernier moment d'utilisation. Cette liste change lors de chaque accs mmoire, et doit donc tre maintenue par le matriel. L'algorithme chronologique de chargement (encore appel FIFO pour first in first out) consiste remplacer la page qui est en mmoire depuis le plus longtemps. Sa mise en uvre est simple, puisqu'il suffit d'avoir une file des numros de pages dans l'ordre o elles ont t amenes en mmoire. L'algorithme alatoire (encore appel random) consiste tirer au sort la page remplacer. Sa mise en uvre est simple, puisqu'il suffit d'utiliser une fonction comme random, qui est une fonction standard de presque tous les systmes. D'autres algorithmes ont t construits qui sont des compromis entre le matriel et le logiciel. L'algorithme de la seconde chance est driv de l'algorithme FIFO et utilise l'indicateur de page accde. Lors d'un remplacement, si la dernire page de la file a son indicateur positionn, elle est mise en tte de file, et son indicateur est remis zro (on lui donne une seconde chance), et on recommence avec la nouvelle dernire, jusqu' en trouver une qui ait un indicateur nul et qui est alors remplace. Cela vite de remplacer des pages qui sont utilises pendant de trs longues priodes. L'algorithme de non rcente utilisation (encore appel NRU pour not recently used), est driv de LRU, et utilise les indicateurs de page accde et de page modifie de la table des pages, pour dfinir six catgories de pages (figure 14.8). Lorsque les pages sont dans les catgories C1 C4, elles sont prsentes dans la table des pages, et le matriel grant les indicateurs peut les faire changer de catgories (transitions marques * sur la figure). Lorsqu'elles sont dans les catgories C5 et C6, elles ne sont pas prsentes dans les tables; un accs une telle page provoquera donc un
- 130 -

Gestion de la mmoire centrale dfaut de page. Priodiquement, le systme transfre les pages des catgories C1 C4 dans la catgorie qui est situe immdiatement droite sur la figure. De plus, il lance de temps en temps la rcriture sur mmoire secondaire de celles qui sont dans C5. Lorsqu'une telle rcriture est termine, si la page est toujours dans C5, elle est transfre dans C6. Lorsqu'un dfaut de page survient, le systme recherche d'abord si la page demande n'est pas dans C5 ou C6, pour la remettre alors dans la table, et ainsi la transfrer dans C3 ou C4 suivant le cas (le matriel la mettra ensuite dans C1 ou C2). Si elle n'y est pas, il y a remplacement de la premire page trouve dans une catgorie, par numro dcroissant, c'est--dire, en commenant par C6.
C1: accde modifie * C2: accde non modifie * * * C4: non accde non modifie C6: non accde non modifie C3: non accde modifie C5: non accde modifie

Fig. 14.8. Les catgories de l'algorithme NRU. Les transitions marques * sont provoques par le matriel. On peut mesurer l'efficacit d'un algorithme de remplacement par la chance que la page soit prsente en mmoire lors d'un accs, ou encore par la probabilit d'avoir un dfaut de page lors d'un tel accs. On constate que les algorithmes se comportent presque tous assez bien et de la mme faon. videmment l'algorithme optimal est le meilleur, suivi par les algorithmes LRU et LFU, ensuite par NRU et la seconde chance, et enfin par FIFO et alatoire. Mais cette probabilit est beaucoup plus influence par le nombre de cases attribues un processus que par l'algorithme luimme.

14.4. La notion d'espace de travail


Si un processus a en mmoire toutes les pages dont il a besoin pour s'excuter pendant une priode suffisante, la probabilit d'avoir un dfaut de page est nulle. Au contraire, si toutes les pages ne sont pas prsentes, il y aura des dfauts entranant des remplacements de pages qui peuvent redevenir ncessaires par la suite. En d'autres termes, si un processus a un nombre de cases suffisant, presque toutes les pages dont il a besoin seront en mmoire, il y a peu de dfaut. Si ce nombre tombe en dessous d'un seuil dpendant du processus, la probabilit de dfaut augmente brutalement. Or chaque dfaut de page bloque le processus en attendant que la page soit prsente en mmoire. On augmente ainsi son temps global d'attente d'entres-sorties, et nous avons vu au dbut du chapitre l'influence de ce paramtre sur le taux d'utilisation du processeur. Un processus, qui fait au total N accs la mmoire, avec une probabilit de dfaut de pages p, sera bloqu pour dfaut de page, pendant Td=pNT, si T est le temps pour lire une page. Comme, par ailleurs, on peut valuer son temps de processeur Tuc=Nt, o t est le temps pour un accs la mmoire physique, on en dduit que Td=p(T/t)Tuc. Or T/t est environ de 104 actuellement, ce qui montre que p doit tre maintenu des valeurs trs faibles sous peine d'avoir un temps Td trs grand par rapport Tuc, entranant une augmentation du taux d'attente d'entres-sorties du processus, et par voie de consquence une diminution du taux d'utilisation du processeur. Ce phnomne, assez brutal du fait des coefficients, est appel l'croulement du systme (en anglais thrashing). On appelle espace de travail (en anglais working set) les pages dont a besoin un processus, un instant donn, pour s'excuter. Le paragraphe prcdent montre l'intrt d'valuer la taille de cet espace de travail, puisqu'elle correspond au nombre de cases ncessaires au processus. En dessous, il y aura des dfauts de pages, au-dessus la mmoire physique sera mal utilise. Si T(P) est la taille de cet espace pour le processus P, il faut alors dterminer l'ensemble E des processus que l'on peut mettre en mmoire de telle sorte que l'on ait:

T (P ) M
PE

- 131 -

Environnement physique o M est la taille totale de la mmoire disponible. VAX-VMS utilise cette notion pour dcider quels sont les processus qui sont rsidents en mmoire centrale, et ceux dont l'tat est temporairement conserv sur mmoire secondaire.

14.5. Conclusion
La multiprogrammation a pour but d'amliorer l'efficacit du processeur par la prsence de plusieurs processus en mmoire de telle sorte qu'il y en ait presque toujours un qui soit prt. Les trois problmes rsoudre sont la dfinition de l'espace d'adresses des processus, la protection de leurs objets propres et l'attribution d'une partie de la mmoire physique chacun d'eux. Dans le partitionnement, les processus reoivent une partie contigu de la mmoire physique qui constitue leur espace d'adresses. Cela conduit une mauvaise utilisation de la mmoire physique. La mmoire segmente fournit aux processus un espace d'adresses deux dimensions leur permettant de regrouper ensembles des objets de mme nature, et de conserver cette structuration l'excution lorsque le matriel supporte ce mcanisme. Cela simplifie la gestion de leur mmoire virtuelle. La pagination est un mcanisme qui permet de plaquer la mmoire virtuelle sur la mmoire relle, en les dcoupant respectivement en pages et en cases de mme taille, et en mettant les pages dans n'importe quelles cases sans devoir respecter la contigut. La pagination peut tre un niveau, une table des pages assurant la correspondance entre les pages et les cases. La table des pages peut tre rduite, par une pagination deux niveaux, en dcoupant la mmoire virtuelle en hyperpages elles-mmes dcoupes en pages, une table des hyperpages reprant la table des pages de chacune des hyperpages. La segmentation et la pagination peuvent tre utilises conjointement puisque ce sont des mcanismes qui s'adressent deux problmes diffrents. La pagination la demande consiste n'allouer une case une page que lorsqu'un processus en a besoin. Cela implique de mettre en uvre un algorithme de remplacement lorsque toutes les cases sont occupes. Ces algorithmes peuvent tre uniquement logiciels ou utiliser certains dispositifs matriels. Ils se comportent presque tous assez bien. Chaque processus a besoin d'un ensemble de pages pour s'excuter, et qui constitue son espace de travail. Le nombre de cases dont dispose un processus doit tre gal la taille de cet espace de travail. S'il est plus grand, la mmoire est mal utilise. S'il est plus petit, le nombre de dfaut de pages augmente, ce qui peut conduire l'croulement du systme.

- 132 -

15

Le langage de commandes

Le langage de commandes est la base de la communication entre un utilisateur et le systme. Son rle essentiel est de permettre un tel utilisateur de lancer l'excution de programmes. Nous avons vu qu'un programme s'excutait dans un certain environnement, et pouvait manipuler des objets externes. Le langage de commande doit donc aussi permettre de dfinir cet environnement et les liaisons avec ces objets externes. Le besoin de contrler les diffrentes oprations faites par ces programmes entrane la ncessit de pouvoir identifier l'utilisateur qui lance les commandes.

15.1. Le langage issu du traitement par lot


La forme syntaxique de ce langage varie suivant les constructeurs et le mode d'utilisation de la machine. l'origine, ce mode tant uniquement le traitement par lot partir de cartes perfores, le langage prsentait une forme trs rudimentaire. Mme si les cartes ne sont plus utilises de nos jours, le langage pour ce mode en est rest fortement imprgn. Les lignes contenant une phrase du langage de commandes commencent par un (ou plusieurs) caractre spcial, comme '$' ou '//'. Elles dfinissent la suite des tapes (step) d'un travail (job), chaque tape correspondant l'excution d'un programme particulier. La dfinition d'une tape consiste donc dfinir le programme excuter, l'environnement d'excution de ce programme, et les liaisons avec les objets externes. Les communications d'une tape la suivante sont souvent inexistantes. Les utilisateurs doivent prvoir ces communications par le biais de fichiers. Ce langage comporte souvent un nombre rduit de commandes, chacune de ces commandes comportant par contre un nombre important de paramtres. De fait, trois commandes sont essentielles: La commande d'identification du travail a pour but de prciser l'identit du demandeur, et les ressources globales ncessaires. La commande de dfinition d'une tape dfinit le programme excuter et les paramtres de son environnement. La commande de dfinition d'une liaison permet de relier un flot particulier du programme de l'tape un objet externe. Le grand nombre de paramtres d'une commande condamne, en gnral, la dfinition des paramtres par position, comme dans les langages de programmation habituels. Elle se fait plutt par le biais de mots cls, sous la forme d'une liste d'associations, o une association est un mot cl suivi de la valeur du paramtre correspondant. Chaque valeur d'un paramtre tant associe un mot cl, l'ordre des paramtres n'a plus d'importance. Par ailleurs, l'interprteur du langage peut donner des valeurs par dfaut aux paramtres que la commande ne dfinit pas. En gnral, ces valeurs par dfaut sont choisies par l'ingnieur systme de l'installation de faon correspondre aux valeurs les plus couramment demandes par les utilisateurs.
- 133 -

Environnement physique Dans certains langages, il est possible de dfinir des macrocommandes. Une macrocommande est dsigne par un nom et reprsente une suite de commandes prdfinies. Elle peut tre paramtre, ce qui permet de lui donner une certaine gnralit. Lorsqu'elle est appele, la suite de commande qu'elle reprsente est d'abord modifie en fonction de ces paramtres, puis excute. Ce mcanisme permet de simplifier l'utilisation du langage de commande lorsqu'une mme suite de commandes est frquemment utilise.

15.2. Le langage interactif


En mode interactif, l'utilisateur doit d'abord fournir au systme son identit pour tablir la connexion (login). Le systme lance ensuite l'interprteur de commandes qui va permettre l'utilisateur de faire excuter les commandes qu'il dsire durant une priode plus ou moins longue, que l'on appelle une session, et qui se terminera par une dconnexion (commande logout). La dure de cette session, et le fait de la prsence de l'utilisateur au terminal implique une forme diffrente du langage de commandes.

15.2.1. Le message d'invite


Alors que, en traitement par lot, l'utilisateur doit dfinir l'ensemble des commandes et des donnes dans un fichier de travail avant de le soumettre au systme, en mode interactif, il doit pouvoir prendre ses dcisions au vu des rsultats de chaque commande successive. En consquence, il ne doit pas tre contraint de fournir des informations l'avance, mais uniquement lorsqu'elles sont effectivement ncessaires. La notion de fichier de travail a donc moins de sens. Il n'est plus ncessaire de distinguer une ligne de commande d'une ligne contenant des donnes par des caractres spciaux comme prcdemment, mais d'indiquer l'utilisateur l'outil logiciel qui attend des informations de sa part. C'est ce que l'on appelle l'invite (en anglais le prompt), qui est constitue d'une chane de caractres qui est envoye l'utilisateur par l'outil lorsqu'il attend ces informations. Par exemple, l'interprteur de commandes de VMS, comme celui d'Unix, envoie normalement un '$' en dbut de ligne lorsqu'il attend une nouvelle commande. Souvent l'invite est une chane paramtrable, permettant ainsi l'utilisateur de personnaliser ce dialogue.

15.2.2. Un langage orient verbe


La deuxime diffrence, avec le traitement par lot, est le besoin de plus de souplesse et de convivialit du langage lui-mme. Il s'ensuit que, au lieu d'avoir peu de commandes avec un grand nombre de paramtres, l'orientation est plutt vers un grand nombre de commandes ayant chacune peu de paramtres. On dit parfois que l'on a une syntaxe oriente verbe, car la commande est constitue d'un verbe, qui est le nom de la commande, suivi des paramtres ventuels de la commande. Certaines de ces commandes sont reconnues et excutes directement par l'interprteur. Les autres commandes sont considres comme des demandes d'excution d'un programme. L'interprteur recherche alors le programme excutable de ce nom, en demande le chargement et le lancement au systme, en lui fournissant les paramtres de la commande. Ceci donne une caractristique importante au langage de commandes qui est son extensibilit, puisque au fur et mesure o de nouveaux programmes deviennent oprationnels, ils deviennent de nouvelles commandes du systme.

15.2.3. La gestion de l'environnement


La troisime caractristique du langage de commandes interactif concerne la gestion de l'environnement de l'utilisateur. Alors que, en traitement par lot, une session de travail consiste en un nombre rduit d'tapes qui s'effectuent chacune dans un environnement propre et souvent indpendant, en mode interactif, une session peut durer plusieurs heures, et donc tre constitue d'un grand nombre de commandes. Il serait fastidieux pour l'utilisateur de devoir prciser compltement l'environnement de chacune de ces commandes. On peut dfinir l'environnement comme un ensemble d'informations propres l'utilisateur dans sa session courante, qui sont gres par l'interprteur de commandes, qu'il utilise pour modifier les commandes et leurs paramtres pralablement leur excution, et qu'il peut transmettre en totalit ou en partie aux programmes correspondants. Nous avons dj eu un aperu de telles informations:

134 - -

Langage de commande Le message d'invite est en gnral dfini par une variable de l'environnement. La personnalisation de ce message est obtenue par l'utilisateur en modifiant cette variable. Le rpertoire de travail, dont nous avons parl dans le chapitre sur la dsignation des objets externes, fait partie de cet environnement. Il peut tre chang tout moment, et est communiqu aux programmes (commande cd de beaucoup de systmes). Les rgles de recherche, dont nous avons galement parl dans le chapitre 10, font aussi partie de l'environnement. En particulier, une variable de l'environnement dfinit par exemple la liste des noms absolus des rpertoires dans lesquels l'interprteur recherche les programmes excutables correspondant aux noms des commandes (variable PATH d'Unix). L'utilisateur peut galement dfinir d'autres variables de ce type, qui peuvent tre transmises aux programmes pour leurs propres besoins de recherche. Par exemple un programme d'aide en ligne (help dans Multics ou VMS, man dans Unix) peut utiliser une telle variable pour localiser les fichiers de documentation des applications manipules par l'utilisateur. Le type de terminal, utilis dans la connexion, est souvent dfini par une variable de l'environnement (variable TERM d'Unix). Elle peut tre consulte par la mthode d'accs terminal virtuel ou par les programmes spcifiques (diteurs pleine page).

15.2.4. Le traitement prliminaire de la commande


Pour simplifier la frappe des commandes par l'utilisateur, les interprteurs de commandes effectuent souvent diffrents traitements sur la commande avant son excution proprement dite. Le mcanisme de substitution permet le remplacement dans la commande des variables de l'environnement par leur valeur courante. Par exemple, dans Unix, la variable HOME de l'environnement est initialise par le nom absolu du rpertoire courant de l'utilisateur lors de l'tablissement de la connexion. ${HOME} dans une commande sera remplace par ce nom. Il peut galement tre utilis pour construire la liste des noms de fichiers vrifiant un certain profil. Par exemple, '*.c' dans une commande sera remplac par la liste des noms de fichiers du rpertoire courant qui sont suffixs par '.c'. Le mcanisme d'abrviation permet l'utilisateur de donner une forme plus simple certaines commandes ou suite de commandes dont il se sert souvent, en fixant certains paramtres et en permettant ventuellement une certaine forme de substitution. Ce mcanisme s'apparente la macrosubstitution. Par exemple, l'abrviation suivante:
alias rm 'rm -i'

est trs conseille sur Unix ou ses drivs. Elle change l'option par dfaut de la commande rm de destruction d'un fichier, de faon demander systmatiquement la confirmation l'utilisateur. Considrons, dans un deuxime exemple, la dfinition de l'abrviation suivante:
alias save 'chmod u+w \!:1.sav; cp \!:1.c \!:1.sav; chmod u-w \!:1.sav'

Lors de la frappe de la commande save truc, le systme constate l'utilisation de l'abrviation de nom save, avec le paramtre truc. Il substitue partout dans l'abrviation la chane \!:1, qui dsigne le premier paramtre, par truc et obtient la suite de commandes suivante dont il lance l'excution. Cette suite consiste forcer d'abord l'autorisation d'criture par le propritaire du fichier truc.sav puis copier le fichier truc.c dans truc.sav et enlever l'autorisation d'criture par le propritaire sur ce fichier.
chmod u+w truc.sav; cp truc.c truc.sav; chmod u-w truc.sav

L'utilisateur se protge ainsi d'une modification involontaire de ses fichiers *.sav.

15.2.5. L'excution de la commande


Nous avons dj dit que l'excution d'une commande, non reconnue par l'interprteur, consistait rechercher le fichier de mme nom par les rgles de recherche, demander au systme de charger le programme correspondant, lui transmettre les paramtres et l'environnement, et enfin lancer son excution. Dans certains systmes il y a de plus cration d'un processus pour cette excution. La plupart du temps, les paramtres sont les chanes de caractres prsentes dans la ligne de commande, et dont l'interprtation est laisse au programme. L'environnement peut comprendre
- 135 -

Environnement physique videmment certaines variables dont nous avons dj parl, mais il doit dfinir l'ensemble du contexte d'excution du programme. En particulier, le programme doit tre capable d'accder aux objets externes dont il a besoin. Si la dfinition des liaisons correspondantes ne font pas partie du programme, elles doivent lui tre transmises par l'intermdiaire de l'environnement. La plupart des systmes considrent que l'environnement doit dfinir au moins trois liaisons: - l'entre standard o le programme lira ses donnes, - la sortie standard o le programme crira ses rsultats, - la sortie des erreurs o le programme crira ses messages d'erreur. En mode interactif, il est assez naturel que les trois liaisons correspondent au terminal de l'utilisateur. Cependant, il peut arriver que l'utilisateur dsire que ce soit autrement. Par exemple, il dsire que le programme lise ses donnes dans un fichier, ou crive ses rsultats dans un fichier. Le langage de commandes doit alors fournir un mcanisme de redirection. Dans Unix ou MS-DOS et leurs drivs, ceci est obtenu non pas par une dfinition des liaisons dans l'environnement, mais en tablissant ces trois liaisons pralablement au lancement du processus. De plus, comme Unix cre un processus par commande, l'interprteur du langage de commandes permet la redirection de la sortie standard d'un processus vers un tube, et la redirection de l'entre standard d'un autre processus depuis ce tube. Par exemple, la ligne de commandes
cat *.biblio | sort | uniq > biblio.tri

lance trois processus sur chacune des trois commandes cat, sort et uniq, la sortie du premier processus, qui est la concatnation des fichiers suffixs .biblio du rpertoire courant, tant dlivre en entre du deuxime, qui trie en ordre alphabtique les lignes de cette concatnation pour les envoyer au troisime, qui limine les rptitions et envoie le rsultat dans le fichier biblio.tri. Comme les sorties d'erreurs de ces processus ne sont pas rediriges, leurs ventuels messages d'erreurs seront envoys au terminal. Signalons enfin que bien souvent les programmes peuvent transmettre un code de retour l'interprteur de commande lorsqu'ils se terminent. Il est donc possible de tenir compte de ces codes de retour pour la poursuite de l'excution d'une squence de commandes. Ceci conduit disposer, dans le langage de commandes, de structures de contrle proches de celles des langages de programmation.

15.3. Les structures de contrle du langage de commandes


Certains systmes offrent un langage de commandes qui est un vritable langage de programmation, en ce sens qu'il possde des structures de contrle complexes. Il n'est pas question videmment de remplacer les langages de programmation classiques, mais de fournir des structures de contrle qui soient appropries aux objets manipuls par le langage de commandes, c'est--dire, essentiellement les fichiers et les processus. Nous mentionnerons deux structures de ce types et montrerons leur utilisation sur des exemples. La commande conditionnelle permet, en fonction du code de retour d'un programme d'excuter l'une ou l'autre parmi deux suites de commandes. Par exemple, nous utilisons la commande test -f toto qui permet de savoir si le fichier toto existe comme fichier ordinaire dans le rpertoire courant. S'il existe, on trace une ligne de tirets de sparation aprs ce qui y est dj, et sinon on y crit une premire ligne d'indication. On y crit ensuite la date courante suivie d'une nouvelle ligne de tirets. Noter l'utilisation de > pour une redirection et criture en dbut de fichier, et >> pour une redirection en prolongement d'un fichier dj existant sans perte de son contenu.
if test -f toto then echo "-----------------------------------------------" >>toto else echo "Etats des resultats successif de test" > toto fi date >>toto echo "-----------------------------------------------" >>toto

L'itration borne permet d'excuter un ensemble de commandes, sur une suite de valeurs prises dans une liste. Par exemple:
for i in toto truc bidule; do cp /usr/moi/$i /tous; done excute la commande cp pour toutes les valeurs possibles de la liste toto truc bidule. Ces trois fichiers sont donc recopis depuis le rpertoire /usr/moi dans le rpertoire /tous. 136 - -

Langage de commande videmment la liste peut tre construite automatiquement par le mcanisme de substitution vu prcdemment. Ainsi, pour faire la compilation de tous les fichiers contenant des modules sources en langage C du rpertoire courant, il suffit d'excuter:
for i in *.c; do cc -c $i; done

Il n'est pas question de dvelopper ici un langage de commandes particulier, c'est pourquoi nous ne dcrirons pas plus ces structures de contrle. Il nous parat plus important que le lecteur comprenne leur importance, et le gain qu'il peut en obtenir. La complexit des commandes que l'on peut avoir, conduit naturellement la notion de programme de commandes, mmoris dans un fichier, et excutable en tant que tel, ce qui est un autre aspect de l'extensibilit du langage de commandes dont nous avons dj parl. Il nous semble avoir, dans ces deux exemples ci-dessus, montr la diffrence entre le langage de commandes et un langage de programmation. Le premier manipule surtout des fichiers sur lesquels il excute des commandes, le second manipule des donnes sur lesquels il effectue des calculs.

15.4. Le langage base de menus ou d'icnes


La convivialit du poste de travail est souvent grandement amlior par l'utilisation d'un langage de commandes bas soit sur des menus droulants soit sur des icnes, soit sur les deux. Par exemple, sur MacIntosh ou sur Atari, la copie de fichier peut tre obtenue en dplaant l'icne du fichier d'une fentre dans une autre au moyen de la souris. De mme sous X-window, l'utilisateur peut construire ses propres menus droulants pour ses commandes les plus courantes. Pour le moment, ce type de langage fonctionne trs bien pour un nombre rduit de commandes souvent sans paramtres. Il est agrable et doit tre systmatiquement dvelopp et utilis pour les besoins courants, mais il ne peut probablement pas satisfaire l'ensemble des besoins des utilisateurs.

15.5. Conclusion
Le langage issu du traitement par lot comporte peu de commandes, avec beaucoup de paramtres. Les commandes permettent l'identification du travail, sa dcomposition en tapes et les dfinitions des liaisons avec les objets externes. Les paramtres sont dfinis par mots cls, avec des valeurs par dfaut. En interactif, les outils logiciels se prsentent aux utilisateurs par leur message d'invite. Le langage de commandes interactif est plus convivial, avec une syntaxe oriente verbe, dfinissant de nombreuses commandes ayant chacune peu de paramtres. Chaque commande tant en fait un programme, le langage est facilement extensible, par adjonction de nouveaux programmes. L'environnement est un ensemble d'informations propres l'utilisateur dans sa session courante, qui peuvent tre utilises par l'interprteur de commandes et les programmes pour adapter leur comportement aux besoins spcifiques actuels de l'usager (message d'invite, rpertoire de travail, rgles de recherche, type de terminal). Les commandes de l'utilisateur peuvent tre simplifies, l'interprteur pouvant les dvelopper par les mcanismes de substitution ou d'abrviation. L'environnement d'excution d'un programme comporte la dfinition des liaisons avec les objets externes. Au moins trois liaisons doivent tre dfinies pour l'entre, la sortie et les erreurs. Si, en gnral, ces liaisons sont avec le terminal de l'utilisateur, il faut pouvoir les rediriger vers des fichiers. Les programmes peuvent transmettre, en fin d'excution, un code de retour l'interprteur de commandes, qui peut en tenir compte lors de l'excution d'un ensemble de commandes. Les langages de commandes modernes disposent de toutes les structures de contrle des langages de programmation classiques. La diffrence essentielle rside dans les objets manipuls par ces deux types de langage.

- 137 -

Environnement physique Le langage base de menus droulants ou d'icnes offre une convivialit remarquable pour les besoins les plus courants. Il ne peut couvrir l'ensemble des besoins, o des structures de contrle labores sont ncessaires.

138 - -

Bibliographie

AHO A.; SETHI R.; ULLMAN J., Compilateurs - principes, techniques et outils, InterEditions, 1989. BEAUQUIER J.; BERARD B., Systmes d'exploitation, concepts et algorithmes, McGraw-Hill, 1990. BERSTEL J.; PERROT J.-F., Multics. Guide de l'usager, Masson, 1986. CARREZ C., Structures de donnes en Java, C++ et Ada 95, InterEditions, 1997. CORNAFION, Systmes informatiques rpartis, Dunod, 1981. CROCUS, Systmes d'exploitation des ordinateurs, Dunod, 1975. CUSTER H., Au cur du systme de fichier de Windows NT, Microsoft Press, 1994. FELDMAN S.I., Make - a program for maintaining computer programs, Bell laboratories, 1978. KERNIGHAN B.W.; RITCHIE D.M., Le langage C, Masson, 1984. KRAKOWIAK S., Principes des systmes d'exploitation des ordinateurs, Dunod, 1985. LISTER A.M., Principes fondamentaux des systmes d'exploitation, Eyrolles, 1984. MONTAGNON J.-A., Architecture des ordinateurs, tome 2, Systmes d'exploitation et extensions du matriel, Masson, 1987. RIFFLET J.-M., La programmation sous Unix, McGraw-Hill, 1986. RUSLING D.A., The Linux Kernel, [sur les sites linux, pub/linux/sunsite/docs/linux-doc-project/linux-kernel/ftk-0.8-3.ps.gz], 1999. SOLOMON D.A., Inside Windows NT, Microsoft Press, 1998. TANENBAUM A., Les systmes d'exploitation - conception et mise en uvre, InterEditions, 1989. TANENBAUM A., Systmes d'exploitation - systmes centraliss - systmes distribus, InterEditions, 1994. ZANELLA P.; LIGIER Y., Architecture et technologie des ordinateurs, Dunod, 1989. Inside MacOS, [sur les sites Apple, comme developper.apple.com, techpubs/Files/], Apple Computer Inc., 1996. Introduction to the 80386 including the 80386 data-sheet, Intel, 1986. Multics: Programmers reference manual, CII-Honeywell-Bull, 1983. VAX-VMS: Architecture handbook, Digital Equipment, 1986. VAX-VMS: System software handbook, Digital Equipment, 1989. A propos de NTFS, consulter le site: http://www.informatik.hu-berlin.de/~loewis/ntfs/ comme ftp.lip6.fr,

- 139 -

Index
chargeur 28,30,51,53,54,125,126 27 27 3,4,5,9,33,34,36,37,39,51

6
68000 15,42

CICS CMS compilateur 16,17,20,23 72,73,77

communication entre processus 113,116,121

A
accs direct la mmoire allocation par blocs de taille fixe

comportement dynamique d'un programme 55,60 compteur ordinal 14,17,19,23,108 conception assiste (mode d'utilisation) 25,26,27,29 contrle de procds 8,26,27

allocation par zone 70,71,75,77,96,99,125,127,129 amorce logicielle analyse lexicale analyse smantique analyse syntaxique appel systme 4,5 34,35,39,60 36,37,39 35,39 18,47

D
dbit des travaux dperdition descripteur d'objet externe diff diffr (mode d'utilisation) DPS-8 5,6,11 112 83,102 60 25,26,27,29 27

arborescence de rpertoire 83,84,86,87,95,97,100 archiveur arrire plan (travaux) assembleur autonome (programme) avant plan (travaux) 59 8,17 15,33,34,39,42,44,51 10 8,17

E
croulement du systme 131,132

B
bande magntique bibliothcaire bibliothque de modules objets bloc de contrle de donnes bote aux lettres 80,82 28 46,47 67 117,118

diteur de liens 28,30,34,41,42,44,45,47,48,49,50,51,52,53 ,54,59,60,67,126 diteur de texte 55 entres-sorties 5,6,7,8,9,11,15,16,17,19,20,21,22,23,26,64 ,67,68,107,118,123,124,131 entres-sorties par accs direct la mmoire 16,21,22 entres-sorties par processeur spcialis 16 entres-sorties programmes 15,19,20,21,23

C
catalogue 82,96,97,98

chane de production de programme 27,28,29,30,60,91


- 141 -

environnement 18,29,30,51,79,86,87,133,134,135,136,137 espace de travail 131,132

Index espace libre tapes (steps) exclusion mutuelle ext2fs 72,75,76,77,78,80,83,87,91 5,133 110,112,113,114,116 101,102 interprteur de commande 28,30,134,136,137 interruption invite (prompt) iRMX86 6,8,11,16,17,18,19,20,23,112 134,135,137 27,117

extension (d'un objet externe) 70,71,72,76,77,96,97,98

L
langage d'assemblage langage de commandes 33,37,38,39,51 81,133,134,136,137

F
famine FAT fichier accs alatoire fichier logique fichier physique fichier squentiel forme normale de Backus-Naur fichier spcial (priphrique Unix) 113,120,121,122,125 72,73,76,91,95,96,102 66,68 65,67,68,72,79,95 65,67,80 65,66,68,74 84 35

langage volu 33,37,38,39,54,56,60,79,114 lien 42,43,44,45,46,47,48,49,50,51,52,79,81,86 ,89,90,98,102 lien satisfaire (import, externe) 42,43,44,45,46,48,49,50,52 lien physique (fichier) lien symbolique (fichier) 86 86,102

lien utilisable (export, public) 42,43,44,45,46,47,48,49,50,52 ligne srie asynchrone 19,22 73,76,101,103 Linux

G
gnration de code 37,39

I
iAPX286 iAPX386 iAPX432 IBM370 IMS indenteur 127 127,129 41 47 27 60

M
machine virtuelle macrognrateur make masquage des interruptions mmoire segmente metteur au point module ditable 29,30,34,63 57,60 57,58,59,60 18,19,23 125,126,132 28,54,55,60 41

implantation squentielle avec extensions 71

mmoire virtuelle 9,49,127,128,129,130,132

instruction 4,14,15,17,18,19,34,37,42,45,46,47,51,54, 55,56,60,108,113,114,125,130 interactif (mode d'utilisation) 25,26,27,29,54,134,136,137 interblocage 113,118,119,120,121,122 9,10 interface homme-machine

module objet 34,37,38,41,42,43,44,45,51,53,54,58 module source 34,35,37,38,41,43,44,54,55,56,57,58,60,10 7 module translatable moniteur d'enchanement des travaux montage de volume
142 - -

41 4,5,10 81,85

interprteur 28,30,33,34,39,107,133,134,135,136,137

Index mot d'tat programme MS-DOS 23,108 programme excutable 28,37,41,49,50,51,52,54,55,58,60,67,86,13 4 protection 5,7,11,89,90,91,93,94,96,102,125,128,129, 132 protection par droits d'accs protection par mot de passe protocole de communication NTFS 72,76,99,100,101,103 69 pseudo-paralllisme numro virtuel de secteur 89 90,94 22 107

27,47,72,76,81,83,84,86,91,136 82 27

multiprogrammation7,8,9,11,123,124,130,132 multi-volumes MVS

Q O
quantum d'allocation objets externes 28,29,30,63,64,65,67,68,69,70,72,73,74,79 ,80,82,83,85,86,89,91,94,95,96,98,101,110 ,125,133,135,136,137 optimisation de code 37 75,77

R
reconnaissance automatique de volume recouvrement redondance interne rfrences croises 81 91,94 28,50,52

49,50,52

P
pagination pagination la demande paragrapheur paralllisme partage d'informations pas pas (mise au point) point d'arrt (mise au point) prprocesseur primitive 127,128,129,130,132 130,132 28,60 6,107 10 54,55,60 54,55,60 56,57,60 118

registres 14,17,23,47,108,109,110,112,126,128 rgles de production rgles de recherche 35,36 86,87,135,137

rpertoire 58,80,82,83,84,85,86,87,89,95,96,97,98,99 ,100,101,102,135,136,137 rpertoire de travail 86,87,135,137 ressource 26,96,97,99,110,111,112,113,114,115,116, 118,119,120,122,123 ressource critique RT-11 110,113,115 27

processeur 6,8,9,11,13,14,15,16,17,18,19,20,21,22,23, 25,26,27,29,46,63,100,107,108,109,110,11 1,112,113,114,118,123,124,125,126,127,1 28,129,131,132 processeur virtuel 108,112 processus 107,108,109,110,111,112,113,114,115,116 ,117,118,119,120,121,122,123,124,125,12 6,127,128,129,130,131,132,135,136 programme autonome 10

S
sauvegarde 10,17,18,19,90,91,92,94,97 17,18 92 90,91,92,94

sauvegarde du contexte sauvegarde incrmentale sauvegarde priodique

143

Index schma producteur-consommateur 116,117,121 scurit smaphore sous-programme rentrant SPART SPS-7 structures de commandes contrle du langage 89,90,91,92,94,99 114,115,116,121 18 27 27 de 136 train de travaux transaction travail (job) TSO tube (pipe) 6 10,101,120 5,133 27 116,117,121

U
UNIX 27,35,47,48,57,59,73,74,76,77,83,84,85,86 ,87,89,90,91,101,109,110,112,116,117,120 ,121,134,135,136

superviseur d'entres-sorties

5,6,7,11,23

systme d'exploitation 8,11,18,23,25,27,63,101

V T
va-et-vient table de bits temps de rponse temps de traitement temps partag temps rel temps virtuel trace d'un programme traduction croise 76,78 5,6,8,10,11,26,29,118,121 26,29 9,11,17,25,26,27,29,92 9,26,27,29,108 108,118 60 37,38,39 verrou VFAT VM VMS vol de cycle 9 114,121 95,96,99,103 27 27,51,72,86,134,135 16,23

volume 80,81,82,83,84,85,87,91,92,93,95,96,98,99 ,100,101,102

144 - -