Les processus
1 LES PROCESSUS....................................................................................................................2
1.1 LES ÉTATS DES PROCESSUS ...................................................................................................3
1.2 LES PROCESSUS NOYAU ET LES PROCESSUS UTILISATEUR ..................................................4
1.3 LES INTERRUPTIONS ..............................................................................................................5
1.4 LA COMMUNICATION INTER-PROCESSUS .............................................................................6
1.5 LES SÉMAPHORES ..................................................................................................................7
1.6 L'ORDONNANCEUR ................................................................................................................8
1.7 LE COOPÉRATIF ET LE PRÉEMPTIF .......................................................................................9
1.8 LES ALGORITHMES D'ORDONNANCEMENT PRÉEMPTIF ......................................................9
2 LA GESTION DE LA MÉMOIRE EN MODE MONO-UTILISATEUR ........................10
3 LA GESTION DE LA MÉMOIRE EN MODE MULTIUTILISATEURS ......................10
3.1 L'ALLOCATION DE LA MEMOIRE ........................................................................................11
3.2 LES MÉTHODES ....................................................................................................................12
3.2.1 FIRST FIT .............................................................................................................................12
3.2.2 NEXT FIT .............................................................................................................................12
3.2.3 BEST FIT ..............................................................................................................................12
3.2.4 WORST FIT...........................................................................................................................12
3.2.5 BLOCS GIGOGNES (BUDDIES SYSTEM) ................................................................................13
3.3 LE VA-ET-VIENT ...................................................................................................................13
3.3.1 SYSTÈME SIMPLE DE VA-ET-VIENT .....................................................................................13
3.3.2 SYSTÈME COMPLEXE DE VA-ET-VIENT ...............................................................................14
3.4 LA MÉMOIRE VIRTUELLE ....................................................................................................15
3.4.1 LA MEMOIRE VIRTUELLE PAGINEE .....................................................................................15
3.4.1.1 Partage de mémoire dans un système paginé ..................................................................17
3.4.1.2 Fragmentation interne .....................................................................................................18
3.4.2 LA MEMOIRE VIRTUELLE SEGMENTEE ................................................................................18
3.4.2.1 Partage de mémoire dans un système segmenté..............................................................19
3.4.2.2 fragmentation externe......................................................................................................19
3.4.3 LA MEMOIRE VIRTUELLE MIXTE .........................................................................................19
1 Les processus
Un programme en exécution dans l'ordinateur est appelé processus ou tâche (process
ou thread en anglais).
Un système d'exploitation (S .E. ou O.S. en anglais) qui traite plusieurs processus
simultanément fait du multitâches.
Un ordinateur à un seul processeur traite une tâche à la fois, s'interrompt et passe à la
suivante. La transition est si rapide et donne l'illusion d'effectuer un traitement
simultané.
Un processus peut appeler d'autres processus que l'on appelle sous-processus. On
appelle le processus créateur, le père, et les processus créés, les fils. Les processus
peuvent donc se structurer sous la forme d'une arborescence. Au lancement du
système, il n'existe qu'un seul processus, qui est l'ancêtre de tous les autres.
Exercice : Trouvez, installez et utilisez un programme qui vous permettra de voir
l’arbre des processus de votre S.E.
Chaque S.E. crée et maintient un certain nombre d'informations sur les processus en
cours d'utilisation dans l'ordinateur. Dans cette table des processus, on y retrouve
presque toujours :
Une identification unique;
l'état du processus;
le niveau de priorité du processus;
table de pointeurs sur les ressources utilisées;
Le passage d'un processus à un autre est réalisé par un Ordonnanceur du système,
lequel est activé par des interruptions : d'horloge, de disque, de terminaux.
La différence entre un processus et un programme est mince : le processus possède le
programme mais également l'état courant de celui-ci dans la mémoire de l'ordinateur.
Le S.E. se sert d'un algorithme d'ordonnancement qui détermine à quel moment il faut
suspendre un processus et à quel moment en repartir un autre.
Pour les systèmes multitâches, l'initialisation démarre par la création du processus
père qui se trouve à la tête de l'arborescence de processus. Les commandes provenant
alors des autres programmes créent d'autres processus qui se greffent à l'arbre unique
des processus du système.
1.1 Les états des processus
Les processus sont des entités en soi mais interagissent avec le S.E. et les autres
processus en cours. Par exemple, dans une chaîne de montage, l’ouvrier qui doit
installer les sièges dans une voiture doit attendre l'arrivée de celle-ci. Advenant un
retard, l'ouvrier attendra.
Un processus en cours d'exécution peut être arrêté même s'il est en mesure de
continuer travail. Le S.E. multitâche intervient ainsi régulièrement pour donner à un
autre processus un temps d'exécution. Il doit alors suspendre le processus en cours et
donner le "témoin" à un autre processus qui attend dans la file.
En fait, il y a 3 états fondamentaux dans lesquels un processus peut se retrouver et 4
transitions possibles entre ces états.
L'état bloqué arrive lorsque le processus à l’état élu ne peut plus continuer
faute de données et l'état prêt, lorsque le système d'exploitation a donné
une tranche de temps à un autre processus.
Le va-et-vient des transitions 2 et 3 est issu de l'Ordonnanceur de
processus du S.E. qui partage le temps entre tous les processus présents
dans la mémoire.
La transition 3 survient lorsque le processus en cours a épuisé la tranche
de temps qui lui avaient été allouée; Il transite alors dans la file d'attente
des processus du système.
La transition 2 du processus survient lorsque tous les processus dans la file
ont obtenu du temps de processeur et qu'il faut relancer celui-ci.
L'Ordonnanceur suit toujours cet ordre ou choisit le processus selon un
ordre de priorité.
La transition 4 est provoquée lorsque qu'un processus bloqué en attente
d'information reçoit ce qu'il attendait. Il entre dans la file d'attente des
processus prêt et attend son tour.
1.2 Les processus noyau et les processus utilisateur
On peut séparer les processus en deux types; ceux créés par les commandes des
utilisateurs et ceux créés par le système d'exploitation pour gérer les requêtes de
fichiers, les opérations sur disque, au clavier, au port série... etc.
C'est là qu'intervient tout le jeu des interruptions du système. La tâche devient plus
complexe à gérer et le jeu des priorités vient contrecarrer à certains moments le
défilement séquentiel des processus du système.
De nombreux algorithmes tentent de répartir équitablement le temps de processeur
entre les tous les processus, tout en s'assurant de maintenir l'efficacité du système.
Chaque système d'exploitation établit donc ses propres façons de faire.
Pour établir le mécanisme de gestion des processus noyau et utilisateur dans un
ordinateur, il faut une table des processus qui contienne des données sur chaque
processus: le numéro du processus, son compteur ordinal, son pointeur de pile, son
allocation en mémoire, l'état des fichiers ouverts et le niveau de priorité.
Exercice : Démarrez le gestionnaire de programme de Windows XP et trouvez comment
trier vos processus par PID et par Priorité. Modifiez la priorité d’un processus. Terminez
le processus d’internet explorer à l’aide du gestionnaire. Toujours en utilisant le
gestionnaire, redémarrez le processus d’internet explorer.
1.3 Les interruptions
Voyons maintenant, de façon très simplifiée, comment le système d'exploitation voit à
l'ordonnancement des processus en tenant compte des interruptions.
a) Supposons qu'un processus « X » utilisateur est commandé par un usager pour
afficher le contenu d'un fichier. Le processus « X » est créé et placé par le noyau
du système dans la file d'attente des processus avec les autres et démarre lorsqu'il
obtient son temps de processeur, mais il doit faire appel au processus de la lecture
sur disque.
b) Comme les périphériques sont contrôlés dans les ordinateurs au moyen
d'interruptions matérielles, on doit recourir à ce vecteur d'interruptions situé dans
le bas de la mémoire et contenant des adresses de procédures pour lancer les
routines nécessaires aux traitements.
c) Le compteur ordinal du processus « X » ainsi que les autres variables mentionnées
plus haut sont sauvegardés dans une pile par le mécanisme matériel du traitement
des interruptions et ce processus utilisateur passe en mode bloqué en attendant des
données en provenance du disque.
d) Le traitement de l'accès au disque peut alors commencer et l'Ordonnanceur est
appelé pour gérer la file d'attente. Si la priorité du processus de l'accès au disque
est plus élevée que celle des autres processus prêt, celui-ci obtient le temps du
processeur, sinon il attend son tour.
e) Lorsque la lecture sur disque des données demandées par le processus « X » est
complétée, le mécanisme du traitement de cette interruption "disque" se termine et
les valeurs du processus « X » bloqué tout ce temps sont replacées sur la pile
d'exécution. Celui-ci passe donc à l'état prêt et retourne dans la file d'attente.
1.4 La communication inter-processus
Dans tout ordinateur multitâche, il existe une portion de mémoire partagée par
l'ensemble des processus en cours. Chacun y a accès et certains doivent selon leur
tâche vérifier régulièrement l'état de quelques valeurs communes.
Par exemple, quand un processus veut faire imprimer un fichier, il place le nom de ce fichier dans
un répertoire commun à tous; le processus qui s'occupe de l'impression vérifie régulièrement ce
répertoire pour y trouver les noms des fichiers à imprimer. S'il trouve un fichier alors il démarre
alors la procédure d'impression. Une fois terminé, il efface le fichier de la zone commune.
La gestion d'un tel espace de travail est relativement simple dans le cas présent. Mais
lorsqu'il y a plusieurs fichiers à imprimer, le gestionnaire d'impression, occupé à gérer
plusieurs clients, interrompu par l'Ordonnanceur comme tous les autres processus,
peut s'y perdre. La mise au point de programmes qui font de l'accès concurrent n'est
pas une tâche facile.
On peut interdire la modification d'une donnée partagée par plus d'un processus alors
qu'un processus prêt en fait l'usage. Ce moyen contrôle s'appelle l'exclusion mutuelle.
Si le processus A utilise la variable y, le processus B ne pourra l'utiliser à son tour
avant que A ait terminé et cela même si A est bloqué en attente de d'autres données.
L'accès à la variable y doit être réservé à au processus A pendant ce temps s’attente.
La variable y est alors en zone critique.
Le choix des primitives du système qui assurent ce genre de contrôle est un point
important des systèmes d'exploitation et nécessite l'utilisation d'algorithmes
complexes pour la gestion de ces zones critiques.
Lorsque plusieurs processus recherchent des ressources au même moment, il peut
arriver des situations de blocage si les ressources de l'un sont requises par l'autre et
vice versa. On appelle cette situation le partage des zones critiques.
Cette difficulté de contrôle des zones mémoire communes est présente depuis les tous
premiers systèmes multitâches. La solution la plus simple est le verrouillage
indivisible (atomique) d'une variable partagée. Si un processus pose ce verrou, les
autres attendent; lorsqu'il la libère un seul processus peut à son tour réserver
l'utilisation de la variable. Il n'y a pas que les S.E. qui procèdent ainsi, les logiciels
utilisateurs peuvent à l'occasion se servir de cette méthode. Microsoft Word le fait
lorsqu'il charge un fichier, il place un verrou dans le répertoire pour empêcher les
autres ressources d'écrire dans ce fichier; on peut le lire, mais pas de modifications
tant qu'il est utilisé par un autre processus.
Exercice : Placez un document Word sur une clé USB. Ouvrez ce document. Tentez
maintenant de retirez la clé USB de façon sécuritaire selon la procédure habituelle bien
connue. La procédure ne fonctionnera pas car le processus est bloqué par Word. Un autre
cas courtant survient lorsque vous tentez de déplacer un fichier déjà ouvert par Word, le
fichier sera bloqué. Par contre il ne le sera pas pour faire une copie.
1.5 Les sémaphores
Depuis 1965, c'est principalement le concept des sémaphores qui vient proposer une
solution élégante à la plupart des problèmes d'exclusion. Ils ont été inventés pour
résoudre une partie des problèmes de communication entre processus.
Le principe général demande l'initialisation d'une variable entière, appelons-la V1,
d'une file d'attente et de deux primitives atomiques associées Wait et Signal. Il existe
plusieurs types de sémaphores dont la variante binaire; en voici le fonctionnement de
base .
1. À l'initialisation, V1 reçoit la valeur 1 et la file d'attente est vide.
2. Lorsqu'un processus veut utiliser une portion de code protégée par un
sémaphore il doit engager un Wait et :
a) Si V1 est supérieur à 0, la ressource est disponible; le processus
décrémente V1 ( il devient égal à zéro) et poursuit son exécution;
b) sinon, le processus est placé dans la file d'attente du sémaphore et
attend que la ressource se libère;
3. lorsque le processus a terminé l'utilisation de la ressource commune, il
engage un Signal et:
a) si la file d'attente est vide, il incrémente V1;
b) sinon, un processus en attente est débloqué;
Appliquons maintenant ce principe à un exemple où deux processus se partagent une
zone tampon de données de taille quelconque. Le processus A produit les données et
le processus B les utilise et les détruits. Pensez au tampon qui permet l'impression des
caractères de l'ordinateur vers l'imprimante.
Au départ, le tampon est vide. Dans cet exemple, la synchronisation des deux
processus est assurée par des sémaphores car le processus " écrivain " et le processus
" lecteur " doivent accéder de manière exclusive au tampon. Les ressources du
processus " écrivain " sont donc les places vides et celles du processus lecteur les
places occupées du tampon.
En plus de la communication par fichier ou par sémaphore, deux processus peuvent
communiquer entre eux au moyen d'un tube de communication (pipeline). Le principe
de fonctionnement est basé sur la création d'un tampon commun (le tube) aux deux
processus à partir duquel ceux-ci viennent lire et écrire.
Les messages forment aussi un moyen de communications privilégié entre processus.
L'environnement Windows utilise cette forme de communication. Les opérations se
font toujours à travers deux opérations de bases : envoie (message) et reçois
(message).
1.6 L'Ordonnanceur
L'Ordonnanceur règle les états et les transitions des processus d'un ordinateur. Il a pour
objectifs principaux :
a) de maximiser l'utilisation du processeur;
b) d'être équitable entre les différents processus;
c) de présenter un temps de réponse acceptable;
d) d'avoir un bon rendement;
e) d'assurer les priorités;
L'Ordonnanceur doit prévoir que chaque processus est imprévisible; certains passent
le temps à attendre des entrées/sorties (ex: pilotes de la carte réseau), d'autres utilisent
le processus mathématiques pendant des heures. Lorsqu'il lance un processus, il ne
sait pas si celui-ci se comportera correctement, s'il se bloquera... etc.
Ce partage doit être fait non seulement entre les processus utilisateurs mais aussi entre
les différentes tâches du système, les entrées/sorties, les interruptions, etc.
Pour s'assurer qu'un processus ne s'exécute pas trop longtemps, l'ordinateur possède
un compteur de temps qui génère des interruptions. À chacune de ces interruptions, le
système d'exploitation reprend la main et décide si le processus courant continue ou
s'il passe le microprocesseur à un autre processus prêt. Ce mécanisme se traduit par
un changement de contexte entre les processus.
1.7 Le coopératif et le préemptif
Le multitâche coopératif est une forme simple de multitâche où chaque processus doit
explicitement permettre à une autre tâche de s'exécuter. (Windows 3.11 Mac OS 9).
Cette approche simplifie l'architecture du système d'exploitation mais présente
plusieurs inconvénients :
o Si un des processus ne redonne pas la main à un autre processus, par
exemple si le processus est bogué, le système entier peut s'arrêter.
o Le partage des ressources peut être inefficace. (temps CPU, mémoire,
accès disque, etc.)
Pour remédier à cette situation, les S.E. ont évolué pour utiliser une approche «
multitâche préemptif ». Dans un tel système, c’est l’Ordonnanceur qui signale au
système d'exploitation que le processus en cours d'exécution doit être mis en pause
pour permettre l'exécution d'un autre processus. Le système doit alors sauver l'état du
processus en cours; le processus est placé dans une file d'attente ; lorsqu'il est en bout
de file, son contexte d'exécution est restauré.
1.8 Les algorithmes d'ordonnancement préemptif
Il existe plusieurs algorithmes d'ordonnancement. Le plus simple, le plus ancien et le
plus fiable est celui de l'ordonnancement du tourniquet. Chaque processus possède un
laps de temps pendant lequel il dispose des ressources de l'ordinateur et du
microprocesseur. À la fin de cet intervalle de temps, s'il n'a pas complété son travail,
l'Ordonnanceur lui retire ses privilèges d'exécution et donne les ressources
d'exécution à un autre processus. Si le processus se bloque ou se termine avant la fin
de son temps, le processeur est alloué à un autre processus.
Dans ce modèle, il y a nécessairement une perte de temps pour le contrôle des
communications (E/S). L'ajustement des laps de temps entre chaque processus est
donc une question délicate. Un laps de temps trop petit provoque trop de
communications de processus et réduit l'efficacité du système alors qu'un laps de
temps trop grand augmente le temps de réponse pour les utilisateurs.
Le mode tourniquet présuppose que tous les processus sont d'égale importance. Ce
n'est jamais le cas. C'est là que devient utile l'ordonnancement avec priorité où chaque
processus a une priorité. L'Ordonnanceur lance alors le processus qui a la plus grande
priorité.
Les priorités peuvent être statiques ou dynamiques. Les processus à priorité
dynamique voient leur niveau réévalué constamment selon plusieurs critères. Par
exemple, les processus qui font beaucoup de E/S, comme ils attendent des données la
majeure partie de leur "temps de vie", disposent du processeur rapidement dès qu'ils
sont en mode prêt dans la file d'attente.
L'Ordonnanceur peut utiliser plusieurs méthodes pour
respecter les priorités des processus tout en conservant un
certain niveau d'équité. Les processus sont regroupés selon
des classes précises. C'est le point de départ qu'utilise le
système d'exploitation pour évaluer la priorité du
processus.
2 La gestion de la mémoire en mode mono-utilisateur
La mémoire principale est le lieu où se trouvent les programmes et les données quand
le processeur les exécute. On l'oppose au concept de mémoire secondaire, représentée
par les disques, de plus grande capacité, où les processus peuvent séjourner avant
d'être exécutés.
De manière encore plus vive que pour les autres ressources informatiques, le prix des
mémoires a baissé et la capacité a beaucoup augmenté. Cependant la nécessité de la
gérer de manière optimale est toujours fondamentale, car en dépit de sa grande
disponibilité, elle n'est jamais suffisante.
On trouve en mémoire, par exemple dans le cas du DOS : le système en mémoire
basse, les pilotes de périphériques en mémoire haute (dans une zone allant de 640 k à
1 Mo) et un programme utilisateur entre les deux :
Pilotes en ROM (BIOS)
Programme utilisateur
(wordPerfect)
command.com
OS (dos)
Variables système
(RAM)
3 La gestion de la mémoire en mode multiutilisateurs
La multiprogrammation permet l'exécution de plusieurs processus indépendants à la
fois. Cette technique permet d'optimiser le taux d'utilisation du processeur en
réduisant notamment les attentes sur des E/S. La multiprogrammation implique
plusieurs programmes en même temps en mémoire; d’ou la nécessité de la gérer.
Dans les systèmes multiutilisateurs on doit interdire à un utilisateur d'accéder
n'importe comment au noyau du système, ou aux autres programmes des utilisateurs.
Pour assurer une protection fondamentale, on dispose, sur la plupart des processeurs,
de deux registres délimitant le domaine d'un processus : le registre de base et le
registre de limite. La protection est alors assurée par le matériel qui compare les
adresses émises par le processus à ces deux registres.
Au chargement d’un processus, le système alloue un espace de mémoire libre et il y
place le processus. Il libérera cet emplacement une fois le processus terminé.
Dans beaucoup de cas, il n'est pas possible de faire tenir tous les programmes
ensemble en mémoire vive. Parfois même, la taille d'un seul programme est trop
importante. Le programmeur peut, dans ce cas, mettre en œuvre une stratégie de
recouvrement (overlay) consistant à découper un programme important en modules et
à charger ces modules quand ils sont nécessaires. Ceci est cependant très fastidieux et
nécessite, pour chaque nouveau programme, un redécoupage. Cette technique fut
toutefois fort répandue il y a quelques années dans la gestion des programmes DOS
volumineux alors que la mémoire disponible ne dépassait pas 640k.
Les systèmes d'exploitation modernes mettent en œuvre des stratégies qui libèrent le
programmeur de ces préoccupations. Il existe deux stratégies principales pour gérer
les chargements : le va-et-vient et la mémoire virtuelle.
3.1 L'allocation de la mémoire
Avant d'implanter une technique de gestion de la mémoire centrale par va-et-vient, il
est nécessaire de connaître son état : les zones libres et occupées; de disposer d'une
stratégie d'allocation et enfin de procédures de libération.
Le système garde la trace des emplacements occupés de la mémoire par
l'intermédiaire d'une table de bits ou bien d'une liste chaînée. La mémoire étant
découpée en unités d'allocation, en blocs. On peut conserver l'état des blocs de
mémoire grâce à une table de bits. Les unités libres étant notées par 0 et ceux
occupées par un 1 (ou l'inverse).
0 0 1 1 0 0 1 0 0 0 1 1 1 1 0
La technique des tables de bits est simple à implanter, mais elle est peu utilisée.
Car plus l'unité d'allocation est petite, moins on a de pertes lors des allocations,
mais en revanche, plus cette table occupe de place en mémoire.
On peut aussi représenter la mémoire par une liste chaînée de structures dont les
membres sont : le type (libre ou occupé), l'adresse de début, la longueur, et un
pointeur sur l'élément suivant.
On peut légèrement modifier ce schéma en prenant deux listes : l'une pour les
processus et l'autre pour les zones libres.
3.2 Les méthodes
L'allocation d'un espace libre pour un processus peut se faire suivant quelques stratégies
principales :
le " premier ajustement " (first fit) ;
le " l'ajustement suivant " (next fit) ;
le " meilleur ajustement " (best fit) ;
le " pire ajustement " (worst fit)
les " blocs gigognes " (buddies systems) ;.
3.2.1 first fit
Dans cet algorithme, la liste de blocs libres est scrutée jusqu'à ce qu'un bloc ayant au
moins la taille requise soit trouvé. Le bloc est alors alloué et l'espace excédentaire
éventuel est inséré dans la liste des blocs vides. Chaque fois qu'un nouveau bloc est
demandé, la recherche reprend au début de la liste. En conséquence, les requêtes pour des
petits blocs sont rapidement satisfaites par des éléments du début de la liste, mais il faut
scruter plus loin si la mémoire est relativement occupée ou si l'on a besoin d'une zone
plus grande.
3.2.2 next fit
Cette technique, appelée également algorithme du premier adapté modifié, fonctionne
comme la précédente, à ceci près que, lorsqu'on a besoin d'un nouveau bloc, la recherche
reprend au point atteint lors de la précédente scrutation de la mémoire libre. On a donc
une scrutation cylindrique de la liste libre, ce qui entraîne une distribution plus régulière
des blocs alloués, avec en principe des termes d'allocation plus courts. Le risque d'échec
d'allocation dû à la fragmentation est en revanche plus élevé.
3.2.3 best fit
Cette technique alloue le bloc dont la taille est la plus proche de celle demandée. Elle
implique un parcours complet de la liste (à moins qu'on trouve en chemin un bloc ayant
exactement la taille demandée). Elle est donc coûteuse en temps de traitement, mais
permet une bonne utilisation de la mémoire.
3.2.4 worst fit
On peut critiquer l'algorithme « best fit » en invoquant le fait que l'espace restant après
l'allocation d'un bloc de taille très proche de celle demandée est si réduit qu'il ne sert en
général à rien. L'algorithme "worst fit" alloue pour cette raison de l'espace à partir d'un
bloc choisi de façon à laisser un espace résiduel aussi grand que possible. On espère que
cet espace sera assez grand pour satisfaire une autre requête. L'inconvénient de cette
technique est que les plus gros blocs sont alloués les premiers et donc une requête pour
une grande zone a plus de chances d'échouer.
3.2.5 blocs gigognes (buddies system)
Un système de blocs gigognes alloue des blocs de mémoire dans une gamme limitée
de tailles, par exemple taille du bloc élémentaire multipliée par les puissances
successives de 2. On tient à jour une liste de blocs séparée pour chaque taille, et
l'allocation revient à retirer un maillon de la liste appropriée. Si la liste est vide, un
bloc de la taille immédiatement supérieure est partagé pour satisfaire la demande, et
l'espace résiduel est chaîné dans la liste appropriée. Quand un bloc est libéré, il est
chaîné dans la liste, mais si l'on constate que les blocs adjacents (en anglais, ses
"buddies", ou copains) sont libres, on peut les concaténer pour former un bloc de
taille supérieure.
L'intérêt de ce mécanisme est sa vitesse d'allocation, mais il ne permet pas forcément
une utilisation optimale de la mémoire à cause de l'allocation des blocs de taille fixe.
Des simulations ont montré que le " First fit " était meilleur que les autres.
Paradoxalement, le " Best fit ", qui est plus coûteux, n'est pas optimal car il produit une
fragmentation importante.
Pour diminuer la fragmentation, on peut compacter régulièrement la mémoire. Pour cela,
on déplace les processus, par exemple, vers la bas de la mémoire et on les range l'un
après l'autre de manière contiguë. On construit alors un seul bloc libre dans le haut de la
mémoire. Cette opération est couteuse.
3.3 Le va-et-vient
Le va-et-vient est mis en œuvre lorsque tous les processus ne peuvent tenir
simultanément en mémoire. On doit alors en déplacer temporairement certains sur
une mémoire provisoire, en général, une partie réservée du disque (swap file).
Quand un processus est déchargé de la mémoire centrale, on lui recherche une place.
Les places de va-et-vient sont gérées de la même manière que la mémoire centrale. La
zone de va-et-vient d'un processus peut aussi être allouée une fois pour toute au début
de l'exécution. Lors du déchargement, le processus est sûr d'avoir une zone d'attente
libre sur le disque.
3.3.1 système simple de va-et-vient
Le cas le plus simple est celui où la mémoire centrale est juste assez grande pour le
système d'exploitation et un processus utilisateur. Tous les processus doivent être
transférés dans cet espace lorsqu'on leur alloue un quantum de temps. Le va-et-vient
est continuel et on comprend que la performance du système dépend nettement du
comportement du processus et de la quantité de temps machine qu'il consomme lors
de son transfert en mémoire centrale pour utiliser son quantum de temps.
Le va-et-vient simple a pour inconvénient de laisser l'unité centrale inactive pendant
les transferts de processus entre la mémoire principale et la mémoire de stockage.
Même avec des traitements limités par l'unité centrale et un quantum de temps plutôt
long, le temps pris pour le va-et-vient reste le facteur prépondérant.
La façon la plus évidente de minimiser ce problème est d'essayer d'exécuter d'autres
processus pendant une partie du temps de va-et-vient. Pour cela, il faut que le système
puisse garder plus d'un processus en même temps en mémoire.
Ce système est viable dans la mesure où le processus courant s'exécute pendant un
temps suffisant pour transférer le précédent et le suivant et on devra choisir la tranche
de temps en conséquence.
3.3.2 système complexe de va-et-vient
Le problème majeur des deux mécanismes expliqués plus haut est qu'il n'y a que le
processus courant en mémoire. Si celui-ci n'utilise pas son quantum temps parce qu'il
se bloque à cause d'une E/S (ce qui est très probable dans le cas d'un système
interactif), le temps efficace de l'utilisation du processeur est inférieur au temps
consacré aux échanges avec la mémoire auxiliaire.
On peut régler ce problème en acceptant plusieurs processus simultanément en
mémoire. La technique d'ordonnancement et de va-et-vient deviennent alors beaucoup
plus complexes à gérer. De plus, la protection des zones de mémoire lorsqu'il y a plus
d'un processus en mémoire physique devient une priorité. Le système d'exploitation
doit alors protéger chacun d'eux des interférences des autres, sans oublier de se
protéger lui-même des programmes utilisateurs.
Le système exécute pendant un certain quantum de temps les processus en mémoire
puis déplace un de ces processus au profit d'un de ceux en attente dans la mémoire
provisoire. L'algorithme de remplacement peut être le tourniquet.
Le système de va-et-vient, s'il permet de pallier le manque de mémoire nécessaire à
plusieurs utilisateurs, n'autorise cependant pas l'exécution de programmes de taille
supérieure à celle de la mémoire centrale.
3.4 La mémoire virtuelle
Considérons un ensemble de programmes s'exécutant "simultanément" sur un
ordinateur quelconque. La mémoire totale requise par l'ensemble des programmes
peut être bien plus grande que la quantité de mémoire physique disponible sur la
machine, mais seule une fraction de cette mémoire est utilisée de manière active à
chaque instant donné. La mémoire principale n'a donc besoin de contenir que les
parties actives des programmes.
Une autre motivation à la mémoire virtuelle est de permettre aux programmes de
dépasser la taille de la mémoire physique, ce qui n'est pas possible dans le mécanisme
du va-et-vient. La mémoire virtuelle permet d'exécuter des programmes dont la taille
excède la taille de la mémoire réelle.
3.4.1 La mémoire virtuelle paginée
La mémoire virtuelle paginée est formée de zones de même taille, appelées pages.
La taille des pages est une puissance de deux ( 1,2,4,8,16 K …).
Les adresses mémoires émises par le processeur sont des adresses virtuelles,
indiquant la position d'un mot dans la mémoire virtuelle.
Une adresse virtuelle est donc un couple (numéro de page, déplacement dans la page).
La mémoire physique est située en mémoire vive. Elle est également composée de
zones de même taille, appelées « cadres » (frames en anglais), dans lesquelles
prennent place les pages.
Il peut y avoir plus de pages que de cadres. Ainsi la mémoire physique peut être plus
petite que la mémoire virtuelle. Les pages qui ne sont pas en mémoire physique sont
stockées sur disque, elles seront ramenées dans un cadre quand on en aura besoin.
Un mécanisme de traduction (translation, ou génération d'adresse) assure la
conversion des adresses virtuelles en adresses physiques, en consultant une table des
pages (page table en anglais) pour connaitre le numéro du cadre qui contient la page
recherchée. L'adresse physique obtenue est le couple (numéro de cadre, déplacement).
translation du couple (page, déplacement) en (frame, déplacement
Voici un exemple réel d’un ordinateur dont le processeur génère des adresses
virtuelles sur 32 bits, pouvant ainsi accéder à 4 Go de mémoire. La taille de la page
est de 4 Ko. On en déduit que le champ déplacement occupe les 12 bits de poids
faible, et le champ numéro de page les 20 bits de poids fort.
Notez que le numéro de page est sur 20 bits alors que le numéro de frame est sur 18
bits. Ou sont passés les 2 bits ? C’est le bit de validité (2 bits en fait). Il peut contenir
3 valeurs (4 en fait) lesquelles représentent 3 états possibles :
a) L'entrée est valide : elle se substitue au numéro de page pour former l'adresse
physique.
b) L'entrée dans la table des pages est invalide. Dans ce cas il faut trouver un
cadre libre en mémoire physique et mettre son numéro dans cette entrée de la
table des pages.
c) L'entrée dans la table des pages est valide mais correspond à une adresse sur le
disque rigide où se trouve le contenu du cadre. Un mécanisme devra ramener
ces données pour les placer en mémoire physique.
Il se peut qu'il n'y ait plus aucun cadre libre en mémoire centrale : celle-ci est occupée
à 100 %. Dans ce cas un algorithme de pagination a la responsabilité de choisir une
page « victime ». Cette page sera d'abord sauvegardée sur disque dur, et l'entrée de la
table des pages qui la référence sera mise à jour.
3.4.1.1 Partage de mémoire dans un système paginé
Exemple :
Lorsque vous utilisez un éditeur ( Bloc-Notes par exemple), le programme de l’éditeur (le
code) se retrouve en mémoire mais aussi le texte que vous inscrivez (les données).
Qu’arrive t-il avec la mémoire paginée si on a trois occurrences de l’éditeur ? ( il est
ouvert 3 fois ) Un système paginé permet de charger en mémoire le processus de l’éditeur
qu’une seule fois plutôt que trois.
3.4.1.2 Fragmentation interne
Un système paginé a l'inconvénient de générer une fragmentation interne : une page
entière est allouée à un processus, alors que seuls quelques octets sont occupés. Par
exemple, si l'on suppose une taille de page de 4 Ko, un processus ayant besoin de 5
Ko octets va se voir allouer 2 pages, près de 40 % est « perdu ».
3.4.2 La mémoire virtuelle segmentée
La mémoire virtuelle segmentée offre une vue de la mémoire plus proche de celle de
l'utilisateur. Celui-ci ne considère pas la mémoire comme une suite de pages mais
plutôt par régions dédiés à une utilisation particulière comme par exemple : le code
d'un programme, les données, un ensemble de sous-programmes, un tableau, etc.
Chaque objet logique sera désigné par un segment. Dans un segment l'adressage se
fera à l'aide d'un couple (segment, déplacement) et sera traduit en adresse mémoire
par le biais d'une table de segments contenant deux champs, base et limite. La base
est l'adresse de début du segment, et limite donne la longueur du même segment.
3.4.2.1 Partage de mémoire dans un système segmenté
Exemple :
Lorsque vous utilisez un éditeur ( Bloc-Notes par exemple), le programme de l’éditeur (le
code) se retrouve en mémoire mais aussi le texte que vous inscrivez (les données).
Qu’arrive t-il avec la mémoire segmentée si on a deux occurrences de l’éditeur ? ( il est
ouvert 2 fois ) Un système segmenté permet de charger en mémoire le processus de
l’éditeur qu’une seule fois plutôt que deux.
3.4.2.2 fragmentation externe
Les systèmes paginés rencontrent un problème de fragmentation interne : de la place
est perdue à la fin d'une page. Les systèmes segmentés connaissent un problème de
fragmentation externe : des espaces entre des segments sont trop petits pour loger de
nouveaux fragments, cet espace est donc perdu.
3.4.3 La mémoire virtuelle mixte
la pagination segmentée, où la table des pages sera segmentée. Autrement dit, le
numéro de page p du couple (p, d) de l'adresse virtuelle sera interprété comme un
segment (s, p’). Ce système résout le problème de taille de la table des pages.
la segmentation paginée, où chaque segment sera paginé. Autrement dit, le champ
déplacement d du couple (s, d) de l'adresse virtuelle sera interprété comme un numéro
de page et un déplacement (p, d’).