Le document présente une simulation d'un système à temps partagé, abordant les concepts clés des systèmes d'exploitation comme la gestion des processus et de la mémoire. Il décrit l'historique et la définition du temps partagé, ainsi que les outils et algorithmes de simulation utilisés pour gérer les requêtes des utilisateurs. Le programme développé permet aux utilisateurs de se connecter, de soumettre des requêtes et de voir les résultats de la simulation en temps réel.

1. REPUBLIQUE ALGERIENNE DEMOCRATIQUE ET POPULAIRE
MINISTERE D’ENSEIGNEMENT SUPERIEUR
ET DE RECHERCHE SCIENTIFIQUE
Faculté Des Sciences Et De L’ingénierie
Institue De Génie Informatique
Module De Système d’exploitation
Simulation du
Année universitaire 2005 - 2006
Réalisé par :
 BENYAMMI Bachir
Encadré par :
Mr. YAGOUBI

2. Simulation d’un système à temps partagé 1
Sommaire ……………………………………………………………………………………………...………………...... 01
I. Introduction ……………………………………………………………………………………………...………………... 02
II. Historique …………………………………………………………………………………………...…………….…….... 03
III. Définition ……………………………………………………………………………………………...…………….…….... 04
IV. Simulation d’un système à temps partagé ………………………………………………………....... 05
1. Introduction ……………………………………………………...…………………………………………. 05
2. Outil de réalisation………….…………….…………….…………….…………….……………...... 05
3. Schéma du l’application .…………….…………….…………….…………….………………...... 05
V. Gestion des processus …………………….…………….…………….…………….…………….…………….. 06
1. Introduction ……………………………………...…………………………………………………………. 06
2. Analyse globale …….……….…………….…………….…………….…………….………………...... 06
3. Analyse détaillé …………..…………….…………….…………….…………….………………...... 06
4. Aperçu sur le programme .………………………………………………………………………. 08
1. Comptes d’utilisateurs .……………………………………..……………………………. 08
2. Gestionnaire des taches .………………………………………………………………. 10
5. Aperçu sur le code source .……….…………….…………….…………….………………...... 11
6. Résumé …….…………….………………......…….…………….………………......…….…………….… 14
VI. Gestion de la mémoire …………………….…………….…………….…………….…………….…………….. 15
1. Introduction ……………………………………...…………………………………………………………. 15
2. Définitions …………………………..…………...…………………………………………………………. 15
1. Mémoire virtuelle paginée .………………………………………………………….…. 15
2. Chaîne de référence .……………………………………………………………………… 15
3. Défaut de page .……………………………………………………………………………….. 15
4. Déplacement et remplacement .……………………………….……………………. 15
3. Analyse globale …….……….…………….…………….…………….…………….………………...... 17
4. Analyse détaillé …………..…………….…………….…………….…………….………………...... 17
5. Aperçu sur le programme .………………………………………………………………………. 18
6. Aperçu sur le code source .……….…………….…………….…………….………………...... 19
7. Résumé …….…………….………………......…….…………….………………......…….…………….…
VII. La représentation graphique…….…………….………………......…….…………….……..………....
1. Introduction……………………………………...………………………………………….………………….
2. Aperçu sur le programme.…………………………………………………………………..……….
3. Aperçu sur le code source.……….…………….…………….…………….………………...........
4. Résumé…….…………….………………......…….…………….………………......…….………….….…….
Glossaire…….…………….………………......…….…………….………………......…….…………….….…………………….
Bibiographie…….…………….………………......…….…………….………………......…….….………….………………….
21
22
22
22
23
23
24
25
Sommaire

3. Simulation d’un système à temps partagé 2
I. Introduction
La gestion du temps est l'un des problèmes majeurs des systèmes
d'exploitation. La raison est simple : les systèmes d'exploitation modernes sont tous
multitâche, or ils utilisent du matériel basé sur des processeurs qui ne le sont pas, ce
qui oblige le système à partager le temps du processeur entre les différentes tâches
(processus). Cette notion de partage implique une gestion du passage d'une tâche à
l'autre qui est effectuée par un ensemble d'algorithmes d’ordonnancement appelé
Ordonnanceur (schedule).
L'invention du temps partagé est le fruit d'une simple constatation: l'homme
est beaucoup plus lent que la machine et prend un temps non négligeable pour
élaborer une requête ou analyser les réponses de l'ordinateur. Dans toute phase
d'interaction la machine attend.
C'est pour rendre l'utilisation de l'ordinateur plus "conviviale" qu'ont été
développés les systèmes d'exploitation "temps partagé" permettant aux utilisateurs
de se connecter à plusieurs sur un seul ordinateur tout en ayant l'impression de
disposer d'un ordinateur personnel interactif pour chacun.

4. Simulation d’un système à temps partagé 3
II. Historique
Le concept de temps partagé a été décrit d'abord par Bob Bemer en
1957 dans un article de la revue Automatic Control Magazine
Christopher Strachey est parfois crédité de l'invention du temps partagé.
Toutefois ce qu'il décrit est plus proche du multitâche
En Novembre 1961 : MIT ont développé le CTSS (Compatible Time Sharing
System), le premier système d'exploitation Multi-Utilisateurs, seulement 3 utilisateurs
se sont connecté simultanément sur un ordinateur pour y travailler comme si chacun
disposait de sa propre machine.
En 1961 : Le projet MAC (Multi Access Computer) du MIT est réalisé pour but
de permettre à plusieurs personnes de travailler sur un même ordinateur en même
temps pour éliminer les temps d'attente du traitement par lot.
Entre 1962 et Septembre 1964 : le
Dartmouth Collage a développé le système
d'exploitation DTSS (Dartmouth Time Sharing
System) permettant à 32 personnes de se
connecter simultanément sur un même ordinateur,
il était utilisé pour donner des cours de langage
BASIC aux étudiants.
FIG 1 : Le SE DTSS
En Avril 1970 : Lancement de la ligne de mini-ordinateurs PDP-11 par Digital
Equipment Corporation. Il s'agit d'une ligne Ade machines toutes compatibles entre
elles basées sur un processeur 16 bits

5. Simulation d’un système à temps partagé 4
III. Définition du Temps partagé
Technique consistant à partager le temps de calcul d'une machine centrale
entre plusieurs utilisateurs, qui travaillent en général sur des terminaux idiots qui
n'ont rien dans le ventre tandis que le serveur est aussi puissant que possible. Time-
sharing en anglais.
La fonction d'un système temps partagé est de donner à tous ces acteurs
humains l'impression qu'ils sont chacun seul en face de la machine. Chacun doit
avoir le sentiment que l'ordinateur est à sa disposition; la qualité du service sera
appréciée en termes de temps de réponse. Il faut donc ajouter les services adéquats
pour tenir compte du fait que l'ordinateur est utilisé simultanément par un grand
nombre de personnes. On combine donc dans un tel système les aspects évoqués
pour les ordinateurs individuels et transactionnels. Il faut ajouter un programme
gestionnaire qui partage le temps disponible entre les différents utilisateurs.

6. Simulation d’un système à temps partagé 5
IV. Simulation d’un système à temps partagé
1. Introduction
Le système d’exploitation d’un ordinateur est chargé d’assurer les fonctionnalités
de communication et d’interface entre l’utilisateur et le matériel. Un SE (OS) est un
logiciel dont les grands domaines d’intervention sont divers:
 Gestion des processus,
 Gestion de la mémoire (physique et virtuelle),
 Gestion des droits d’accès (Sécurité),
 Gestion des fichiers (Système de fichiers),
 Gestion des périphériques (Entrées-sorties),
 ...
Afin de comprendre les fonctions d’un système d’exploitation et les méthodes
utilisées pour garder la stabilité du système. En essaient de simuler la gestion des
processus dans un système à temps partagé ainsi que la gestion de la mémoire
physique et virtuelle.
2. Outil de réalisation
Le logiciel fait dans ce mini est réalisé avec l’outil Borland Delphi 07 Studio.
Delphi est un IDE (Integrated Development Environment ) (environnement de
développement intégré) de type RAD (Rapid Application Development)
(Développement rapide d’application), basé sur le Pascal Objet. Il nous permet de
réaliser rapidement et simplement des applications Windows en utilisent des
composants réutilisables.
Cette rapidité et souplesse de développement sont dues à une conception
visuelle de l’application (WYSIWYG) (What You See Is What You Get). Delphi
propose un ensemble très complet de composants visuels prêts à l’emploi incluant la
quasi-totalité des composants Windows (fenêtres, boutons, boîtes de dialogue,
menus, barres d’outils…) ainsi que des experts (Wizards) permettant de créer
facilement divers types d’applications et de librairies (Base de données, composants,
…).
3. Schéma du l’application
FIG 2 : Schéma du l’application FIG 3 : Fenêtre principale

7. Simulation d’un système à temps partagé 6
V. Gestion des processus
1. Introduction
La gestion des processus est l’un des rôles les plus importants d’un SE. Le SE
doit gérer d’une manière équitable et optimale l’ordonnancement et l’allocation des
processus ainsi que les caractéristiques de chaque processus (état,
ordonnancement, registres, mémoire, E/S, contrôle d’accès, signalisation, …).
Le système à temps partagé est un système Multi-Utilisateur ; c-à-d plusieurs
sessions sont ouvertes et plusieurs utilisateurs sont connectés au même temps. Le
système doit bien gérer les demandes de chaque requête en allouant un quantum de
temps à chaque processus.
Le programme que nous avons réalisé est une simulation d’un système à
temps partagé, par la gestion d’activité d’un ensemble d’utilisateurs. Le programme
est composé de deux parties essentielles :
 La gestion des utilisateurs,
 La gestion des processus.
Le but de ce mini projet est de comprendre les notions reliées aux systèmes à
temps partagé ainsi d’avoir les avantages et les inconvénients de ce dernier. Tous
ça ; par l’application de quelque fonctions tel que :
 La gestion des sessions et des droits accès,
 L’allocation des requête CPU et E/S,
 L’attribution du quantum du temps,
 Le contrôle de la file d’attente du CPU,
 …
2. Analyse Globale
Le déroulement de l’algorithme de simulation nous permet de gérer l’activité
d’un ensemble d’utilisateurs. Après l’authentification des utilisateurs et la définition
des requêtes (Type, Taille, Temps d’entrée) pour chaque utilisateur ; le système est
prés pour la simulation.
Pour chaque utilisateur:
Pour chaque Requête:
1. Type (CPU ou E/S)
2. Taille
3. Temps d’entrée
4. Temps d’Occupation
5. Temps d’Attente
6. Durée d’Exécution
7. Temps Total
8. Taux d’Occupation
3. Analyse détaillée
L’algorithme de déroulement est le suivant :
 Début,
 Authentification,
 Définition des requêtes,
Simulation
Temps partagé

8. Simulation d’un système à temps partagé 7
 Si la requête est de type CPU alors
Si le temps d’entrée est inférieur au compteur du système alors
Si le temps d’occupation est inférieur à la taille de la requête alors
 Incrémenter le temps d’occupation,
 Calculer la durée d’exécution et le temps total et le taux
d’occupation,
 Incrémenter le temps d’attente d’autres requêtes.
Si non terminer la requête.
Fin Si.
Si non passer à la requête suivante,
Fin Si.
Incrémenter le compteur du système.
 Si non, si la requête est de type E/S
Si le temps d’entrée est inférieur au compteur du système alors
Si la durée d’exécution est inférieure à la taille de la requête alors
 Incrémenter la durée d’exécution,
 Calculer le temps total,
 Passer à la requête suivante.
Si non terminer la requête.
Fin Si.
Si non passer à la requête suivante,
Fin Si.
Incrémenter le compteur du système.
 Fin Si.
 Fin de simulation

L’organigramme est le suivant (FIG 4)
FIG 4 : Organigramme de simulation des requêtes

9. Simulation d’un système à temps partagé 8
4. Aperçu sur le programme
Le programme est composé de deux parties essentielles :
 Comptes d’utilisateurs
 Gestionnaire des taches
1. Comptes d’utilisateurs
C’est la gestion des utilisateurs, à l’aide de cette interface (FIG 5), on peut
ajouter, modifier, supprimer des utilisateurs, seuls ces utilisateurs pouvant entrée
dans le système et définir leurs propres requêtes CPU et E/S.
FIG 5 : Gestion des comptes d’utilisateurs
1. Crée un nouvel utilisateur,
2. Ajouter l’utilisateur à la base de données,
3. Modifier l’info. d’un utilisateur,
4. Annuler les modifications des infos. d’un utilisateur,
5. Supprimer l’utilisateur,
6. Fermer la fenêtre,
7. Saisir le compte d’utilisateur,
8. Saisir le mot de passe d’utilisateur,
9. Définir l’état d’utilisateur,
10.Saisir le nom d’utilisateur,
11.Saisir le prénom d’utilisateur,
12.Saisir l’émail d’utilisateur,
13.Voir la liste des utilisateurs.
Pour q’un utilisateur veuille entrer dans une session, il doit d’abord être
enregistré, à l’authentification (FIG 5); le système demande un compte et un mot de
passe.
1
1
1
2 4 6
7
1
10
11
121
5
1
9
1
8
3
131

10. Simulation d’un système à temps partagé 9
FIG 6 : Authentification
1. Saisir le compte,
2. Saisir le mot de passe,
3. Entré dans la session,
4. Quitter la fenêtre.
Si la connexion succède ; l’utilisateur peut ensuite définir ces requêtes CPU
et E/S, (FIG 6) pour chaque requête ; l’utilisateur doit définir le type (CPU ou E/S), la
taille et le temps d’entrée de la requête. Si la connexion est échouée, un message
est apparaître.
FIG 7 : Liste de requêtes
1. Choisir le type de la requête,
2. Définir la taille de la requête,
3. Définir le temps d’entrée de la requête,
4. Ajouter la requête à la liste,
5. Voir la liste des requêtes,
6. Supprimer la requête sélectionnée,
7. Valider les données,
8. Annuler l’opération.
1
1
1
2
4
3
1
1
1
2
3
4
5
6
7
8

11. Simulation d’un système à temps partagé 10
2. Gestionnaire des taches
Après la définition des requêtes le système est prés pour lancer la simulation.
(FIG 7)
FIG 8 : La simulation est en cours
1. La liste des utilisateurs,
2. La liste des requêtes,
3. La liste des requêtes CPU,
4. La liste des requêtes E/S,
5. L’état des requêtes,
6. L’état de la simulation,
7. Connexion d’un utilisateur,
8. Déconnexion d’un utilisateur,
9. Démarrer ou annuler la simulation,
10.Suspondu ou continue la simulation,
11.Contrôler la vitesse du CPU,
12.Compteur du système,
13.Fermer la fenêtre.
A la fin du simulation, un message est apparaître (FIG 8 ) indiquant la fin du
simulation, ainsi que des informations sur les requêtes traitées et le temps total du
simulation.
FIG 9 : Fin Simulation
1
1
1
5
131
11
0
121
101
1
2
1
3
1
4
9876 1

12. Simulation d’un système à temps partagé 11
5.Aperçu sur le Code Source
procedure TMainForm.ExecuteRequetesE_S;
var
i, j: integer;
begin
for i:= 0 to ListReq.Items.Count -1 do
with ListReq.Items[i] do
if (subItems[0] = 'E/S') then
if (StrToInt(subItems[2]) <= Compteur) then
begin
// Recuperer le n° de la requete
j := i; FindKey(ListReq, ListE_S, j);
if (StrToInt(subItems[5]) < StrToInt(subItems[1])) then
begin
// Marquer la requete
MettreUnPoint(ListReq, 9, i, '°');
//inc la duree d'exe des requetes E/S
subItems[5] := IntToStr(StrToInt(subItems[5]) + 1);
ListE_S.Items[j].subItems[2] := subItems[5];
//calculer le temps total des requetes E/S
subItems[6] := IntToStr(StrToInt(subItems[5]) +
StrToInt(subItems[2]));
ListE_S.Items[j].subItems[3] := subItems[6];
end
else
begin
// Marquer la fin de la requete
MettreUnPoint(ListReq, 9, i, '.');
MettreUnPoint(ListE_S, 5, j, '.');
end;
end
end;
function TMainForm.ExecuteRequeteCPU: boolean;
var
Taille, Temps_Occup, Temps_attente, Temps_Entre, Temps_Total,
Duree_Exe, i, j, k, somme :integer;
Taux : real;
begin
Result := True;
with ListReq.Items[Req_acc] do
begin
Taille := StrToInt(subItems[1]);
Temps_Entre := StrToInt(subItems[2]);
Temps_Occup := StrToInt(subItems[3]);
Temps_attente := StrToInt(subItems[4]);
if Temps_Entre <= Compteur then
if Temps_Occup < Taille then
begin
for i:= 0 to ListReq.Items.Count -1 do
with ListReq.Items[i] do
if (Caption <> ListReq.Items[Req_acc].Caption)
and (subItems[0] = 'CPU')
and (StrToInt(subItems[2]) <= Compteur)
and (StrToInt(subItems[3]) < StrToInt(subItems[1])) then
begin
// Recuperer le n° de requete CPU
j := i; FindKey(ListReq, ListCPU, j);

13. Simulation d’un système à temps partagé 12
// Marquer la requete currente
MettrePoint(ListReq, 9, i, ' ');
// Inc le temps d'attente des autres requetes CPU
subItems[4] := IntToStr(StrToInt(subItems[4])+ 1);
ListCPU.Items[j].subItems[3] := subItems[4];
// Calculer la durée d'exe des autres requetes CPU
subItems[5] := IntToStr(StrToInt(subItems[3]) +
StrToInt(subItems[4]));
ListCPU.Items[j].subItems[4] := subItems[5];
// Calculer le temps total des autres requetes CPU
subItems[6] := IntToStr(StrToInt(subItems[5]) +
StrToInt(subItems[2]));
ListCPU.Items[j].subItems[5] := subItems[6];
end;
// Recuperer le n° de requete CPU et le n° de l'utilisateur
j := Req_acc; FindKey(ListReq, ListCPU, j);
k := Req_acc; FindUser(ListReq, ListUsers, k);
// Marquer la requete currente
MettreUnPoint(ListReq, 9, Req_acc, '*');
//Inc le temps d'occupation du requete currente
Inc(Temps_Occup);
subItems[3] := IntToStr(Temps_Occup); // occup
ListCPU.Items[j].subItems[2] := subItems[3];
//calculer la duree d'exe du requete currente
Duree_Exe := Temps_Occup + Temps_attente;
subItems[5] := IntToStr(Duree_Exe); // duree
ListCPU.Items[j].subItems[4] := subItems[5];
//calculer le temps total du requete currente
Temps_Total := Duree_Exe + Temps_Entre;
subItems[6] := IntToStr(Temps_Total); // total
ListCPU.Items[j].subItems[5] := subItems[6];
//Calculer la somme des temps d'occupation de tous les requetes
somme := 0;
for i:= 0 to ListReq.Items.Count -1 do
if ListReq.Items[i].subItems[0] = 'CPU' then
somme := somme + StrToInt(ListReq.Items[i].subItems[3]);
if somme < 1 then somme := 1;
for i:= 0 to ListReq.Items.Count -1 do
with ListReq.Items[i] do
if (subItems[0] = 'CPU')
and (StrToInt(subItems[2]) <= Compteur) then
begin
// Recuperer le n° de requete CPU
j := i; FindKey(ListReq, ListCPU, j);
//Calculer le taux d'occupation du requete currente
Taux := StrToInt(subItems[3]) * 100 / somme;
subItems[7] := FormatFloat('#.##', Taux);
ListCPU.Items[j].subItems[6] := subItems[7];
end
end
else
begin

14. Simulation d’un système à temps partagé 13
Result := False;
// Recuperer le n° de requete CPU et le n° de l'utilisateur
j := Req_acc; FindKey(ListReq, ListCPU, j);
k := Req_acc; FindUser(ListReq, ListUsers, k);
// Marquer la fin le la requete
MettreUnPoint(ListReq, 9, Req_acc, '.');
end
else
Result := False;
end;
end;
function TMainForm.ExistReqCPU: Boolean;
var
i: integer;
begin
result := False;
if ListCPU.Items.Count < -1 then exit;
for i:= 0 to ListCPU.Items.Count -1 do
if (ListCPU.Items[i].subItems[8]) = '*' then
begin
result := True;
Exit;
end;
end;
procedure TMainForm.ExecutionRequete;
var
CPU: boolean;
TypeReq, Point: String;
begin
CPU := False;
// Execution de la requete
Repeat
TypeReq := ListReq.Items[Req_acc].SubItems[0];
Point := ListReq.Items[Req_acc].SubItems[9];
if Point <> '.' then
if TypeReq = 'CPU' then
CPU := ExecuteRequeteCPU;
ExecuteRequetesE_S;
// Passer à la requete suivante
if Req_acc < ListReq.Items.Count -1 then
Inc(Req_acc)
else
Req_acc := 0;
Until Not ExistReqCPU or CPU = True
end;
procedure TMainForm.Timer_SumTimer(Sender: TObject);
var
Temps_Occp, Temps_Attente, Duree_Exe, Temps_Total, i, j: integer;
ExistPoint: boolean;
Compte: String;
Taux: real;
begin
Timer_Sum.Enabled := false;
// A ce que la sumilation est terminée ? => existence des ponts
ExistPoint := True;
for i:= 0 to ListReq.Items.Count - 1 do

15. Simulation d’un système à temps partagé 14
if ListReq.Items[i].SubItems[9] <> '.' then
begin
ExistPoint := False;
Break;
end;
if ExistPoint then
begin
for i := 0 to ListUsers.Items.Count - 1 do
with ListUsers.Items[i] do
begin
Temps_Occp := 0;
Temps_Attente := 0;
Duree_Exe := 0;
Temps_Total := 0;
Taux := 0;
Compte := SubItems[0];
for j := 0 to ListReq.Items.Count - 1 do
with ListReq.Items[j] do
if SubItems[8] = Compte then
begin
Inc(Temps_Occp, StrToInt(SubItems[3]));
Inc(Temps_Attente, StrToInt(SubItems[4]));
Inc(Duree_Exe, StrToInt(SubItems[5]));
Inc(Temps_Total, StrToInt(SubItems[6]));
Taux := Taux + StrToFloat(SubItems[7]);
end;
SubItems[3] := IntToStr(Temps_Occp);
SubItems[4] := IntToStr(Temps_Attente);
SubItems[5] := IntToStr(Duree_Exe);
SubItems[6] := IntToStr(Temps_Total);
SubItems[7] := FloatToStr(Taux);
end;
StatusBar1.Panels[0].Text := 'Simulation Terminée';
MessageDlg('Simulation Terminée' + #13 +
' Nbr d''utilisateurs : ' + IntToStr(ListUsers.Items.Count) + #13 +
' Nbr de requêtes : ' + IntToStr(ListReq.Items.Count) + #13 +
' Nbr de req. CPU : ' + IntToStr(ListCPU.Items.Count) + #13 +
' Nbr de req. E/S : ' + IntToStr(ListE_S.Items.Count) + #13 +
' Temps Total : ' + Lab_Temp_Total.Caption + ' seconde(s)',
mtInformation, [MbOk], 0);
Exit;
end;
// Inc et afficher le compteur
Inc(Compteur);
Lab_Temp_Total.Caption := IntToStr(Compteur);
// Executer la requete
ExecutionRequete;
Timer_Sum.Enabled := true;
end;
6. Résumé
C'est pour rendre l'utilisation de l'ordinateur plus "conviviale" qu'ont été
développés les systèmes temps partagé permettant aux utilisateurs de se connecter
sur un seul ordinateur tout en ayant l'impression de disposer d'un ordinateur
personnel interactif pour chacun.
A l’aide du notre simulation, on a arrivé à comprendre et a imaginer la complexité
de ces systèmes ; c’est la réunion des deux mondes : le PC personnel et les
systèmes transactionnels.

16. Simulation d’un système à temps partagé 15
VI. La gestion de la mémoire
1. Introduction
Le mécanisme de mémoire virtuelle a été mis au point dans les années 1960.
Il est basé sur l'utilisation d'une mémoire de masse (type disque dur ou
anciennement un tambour), dans le but, entre autres, de permettre à des
programmes de pouvoir s'exécuter dans un environnement matériel possédant moins
de mémoire centrale que nécessaire.
La mémoire virtuelle permet :
 d'augmenter le taux de multiprogrammation.
 de mettre en place des mécanismes de protection de la mémoire.
 de partager la mémoire entre processus.
Le terme ‘mémoire virtuelle’ est apparue en 1962 dans un article de
référence de James Kilburn, il décrit le premier ordinateur doté d'un système de
gestion de mémoire virtuelle paginée et utilisant un tambour comme extension de la
mémoire centrale.
Aujourd'hui, tous les systèmes d’exploitation ont un mécanisme de gestion de la
mémoire virtuelle, sauf certains supercalculateurs ou systèmes embarqués temps
réel.
2. Définitions
1. Mémoire virtuelle paginée
Le principe est le suivant : par un mécanisme de translation, les adresses
virtuelles, émises par le processeur, seront traduites en adresses physiques. De
plus :
 la mémoire virtuelle sera considérée comme une suite de zones de même
taille appelée ‘page’.
 la mémoire physique va être considérée comme une suite de zones de même
taille appelée ‘cadre’.
 les adresses mémoires issues par l’unité centrale sont des adresses virtuelles.
 Une adresse virtuelle sera traduite en adresse physique par un mécanisme de
translation.
2. Chaîne de référence
Le comportement de programme au niveau de détail choisi est définit par
séquence des numéros des pages ayant l’objet de références successif aux cours de
son exécution. Cette séquence est appelle ‘chaîne de référence’ Pour le
programme concéder et la taille de page choisit.
3. Défaut de page
Le programme est initialement rangé en mémoire secondaire à un instant de
donnée, seul un sous ensemble de ses pages est présent en mémoire principal.
Si la prochaine référence est faite à une page absente de la mémoire principal, alors
il y a un ‘défaut de page’.

17. Simulation d’un système à temps partagé 16
4. Déplacement et remplacement
En cas de présence des zones libres dans la mémoire principal, la gestion de
la mémoire fait appel à des algorithmes de déplacement. Mais s’il n’ y a pas de place
disponible ; la page demandée doit prendre la place d’une page déjà présente.
Celle-ci est déterminée par des algorithmes de remplacement.
Problème :
Quand il n’y a pas de place en mémoire, quelle page doit être victime ?
Une des solutions pour résoudre ce problème est le remplacement des pages.
On utilise des algorithmes de remplacement (FIFO, OPTIMAL, LRU, SECONDE
CHANCE), dans notre mini projet, on a choisi l’algorithme de la Seconde chance.
Analyse et solution du problème
La solution est de mètre en œuvre une mémoire virtuelle par un système de
pagination à la demande pour résoudre le problème de défaut de pages.
Principe de l’algorithme « seconde chance »
Cet algorithme est basé sur le principe de remplacement ’FIFO’. Quand une
page est sélectionnée, on scrute son bit de référence : s’il est égale a 0, on procède
a son remplacement. Si le bit de référence est égale à 1, on donnera a cette page
une seconde chance et on doit sélectionner la prochaine page selon FIFO. Quand
une page a bénéficie de la seconde chance, son bit de référence est mise a 0 et son
temps d’arrivée est réajusté au temps courant. Ainsi, une page ayant bénéficié d’une
seconde chance ne sera remplacé que si toutes les autres pages ont été remplacées
ou quelles ont obtenu une seconde chance.
Exemple :
La recherche est circulaire,
Si le bit de référence égale à ‘1’, alors met son bit à ‘0’,
Si le bit de référence égale à ‘0’, alors la page est choisie comme victime.
FIG 10 : Déroulement de la seconde chance
# de page0
# de page0
# de page1
# de page1
# de page0
# de page1
# de page1
victime
suivante
# de page0
# de page0
# de page0
# de page0
# de page0
# de page1
# de page1
victime
choisie

18. Simulation d’un système à temps partagé 17
3. Analyse globale
 Partitions disponibles
en mémoire centrale
 Taille de pages.
 Les références.
Nombre de défaut
de pages
4. Analyse détaillée
Données :
 Mémoire de trois partitions de taille fixe.
 Les références.
 Taille de page.
Résultats :
 Evaluation de défaut de pages à chaque changement de la taille de Page.
 Représentation graphique des résultats.
Organigramme :
FIG 11 : Algorithme de la seconde chance
Algorithme de
La seconde chance

19. Simulation d’un système à temps partagé 18
5. Aperçu sur le programme
FIG 12 : Application de l’algorithme de la seconde chance
1. Saisir une adresse,
2. Ajouter une adresse,
3. Saisir la taille de la page,
4. Afficher la chaîne de référence,
5. Lancer la simulation,
6. Représentation de la taille du page et le nombre de défaut de page,
7. Initialisation des tables,
8. Initialisation de l’application,
9. Dessiner le graphe,
10.Fermer l’application,
(+) : si le bit de référence a 1,
(-) : si le bit de référence a 0,
() : Indique la prochaine victime (ancienne ref).
Explication :
() : La prochaine victime (ancienne ref);
1-1er-3éme colonne : chaque nouvelle référence prend une signe (+) ;
2- 4éme colonne : l’entrée d’une nouvelle référence différente ;
2
3
75
6
10
4
8
9
+-
1

20. Simulation d’un système à temps partagé 19
Tantque ref <> ‘’
debut : Si signe = ‘+’ alors { tester le signe de ancienne ref }
signe = ‘-‘ {donner une seconde chance }
Incrémenter ‘’ { passer a la ancienne ref suivante }
Aller au debut
Sinon ancienne page := nouv. Page
{la nouv. ref remplace la ancienne ref.}
Incrémenter ‘’ { passer a la ancienne ref suivante.}
Fin Si
Fin Tantque
La liste des fonctions
 Ajouter : Ajouter adresse à la liste des références,
 Fixer : Calcul les adresses des pages à partir de Liste des
références,
 Initialiser : Faire l’initialisation (Vider la mém.),
 Reprendre : Faire l’initialisation d’une nouvelle chaîne,
 Fermer : Quitter la fenêtre.
6.Aperçu sur le Code Source
procedure Tmemoire.btnSimulerClick(Sender: TObject);
label Cas1, Cas2, Cas3, Cas4, Cas5, cas6;
var DP, i:integer;
begin
cas1: DP:=1;
st1.Cells[0,5]:='DP';
st1.Cells[0,2]:=st1.Cells[0,1]+'+'+'<-' ;
cas2:if ( st1.Cells[0,1] <> st1.cells[1,1] ) then
begin
st1.Cells[1,2]:=st1.Cells[0,2];
st1.Cells[1,3]:=st1.Cells[1,1]+'+' ;
DP:=DP+1;
st1.Cells[1,5] :='DP';
end
else
st1.Cells[1,2]:=st1.Cells[0,2];
cas3:if (st1.cells[2,1]<> '') then
begin
if (st1.cells[1,1]<>st1.cells[2,1])
and (st1.cells[0,1]<>st1.cells[2,1])then
begin
st1.Cells[2,2]:=st1.Cells[1,2] ;
st1.Cells[2,3]:=st1.Cells[1,3] ;
st1.Cells[2,4]:=st1.Cells[2,1]+'+' ;
DP:=DP+1;
st1.Cells[2,5]:='DP';
end
else
begin
st1.Cells[2,2]:= copy(st1.Cells[1,2], 0, 2);
st1.Cells[2,3]:=st1.Cells[1,3]+'<-' ;
end;
end;

21. Simulation d’un système à temps partagé 20
cas4: if (st1.cells[3,1]<> '') then
begin
if (copy(st1.Cells[2,2], 0, 1)=st1.Cells[3,1])
or (copy(st1.Cells[2,3], 0, 1)=st1.Cells[3,1])
or (copy(st1.Cells[2,4], 0, 1)=st1.Cells[3,1]) then
begin
if(st1.Cells[3,1]= copy(st1.Cells[2,2], 0, 1))then
begin
st1.Cells[3,2]:=copy(st1.Cells[2,2], 0, 2);
st1.Cells[3,3]:=st1.Cells[2,3]+'<-';
st1.Cells[3,4]:=st1.Cells[2,4];
{goto Cas6; }
end;
if (copy(st1.Cells[2,3], 0, 1)=st1.Cells[3,1])
or (copy(st1.Cells[2,4], 0, 1)=st1.Cells[3,1]) then
begin
st1.Cells[3,2]:=st1.Cells[2,2];
st1.Cells[3,3]:=st1.Cells[2,3];
st1.Cells[3,4]:=st1.Cells[2,4];
end;
end;
if (st1.Cells[2,3]= '') then
begin
if (st1.Cells[2,1]<>st1.Cells[3,1]) then
begin
st1.Cells[3,3]:=st1.Cells[3,1]+ '+';
st1.Cells[3,2]:=st1.Cells[2,2];
DP:=DP+1;
st1.Cells[3,5]:='DP';
end
else
begin
st1.Cells[3,2]:=st1.Cells[2,2];
st1.Cells[3,3]:=st1.Cells[2,3];
end;
end
else if (st1.Cells[2,4]='') then
begin
st1.Cells[3,2]:=st1.Cells[2,2];
st1.Cells[3,3]:=st1.Cells[2,3];
st1.Cells[3,4]:=st1.Cells[3,1]+'+' ;
DP:=DP+1;
st1.Cells[3,5]:='DP';
end;
if(st1.Cells[2,3]<>'')and(st1.Cells[2,4]<>'')then
begin
if (st1.Cells[3,1]<>st1.Cells[0,1])
and (st1.Cells[3,1]<>st1.Cells[1,1])
and (st1.Cells[3,1]<>st1.Cells[2,1]) then
begin
st1.Cells[3,2]:= st1.Cells[3,1] + '+' ;
st1.Cells[3,3]:=copy(st1.Cells[2,3], 0, 1) + '-'+ '<-' ;
st1.Cells[3,4]:=copy(st1.Cells[2,4], 0, 1) + '-';
DP:=DP+1;
st1.Cells[3,5]:='DP';
end ;
end ;
end;
Cas6: if (st1.cells[4,1]<> '') then //5
begin

22. Simulation d’un système à temps partagé 21
if (copy(st1.Cells[3,3], 0, 1)=st1.Cells[4,1]) then
begin
st1.Cells[4,2]:=st1.Cells[3,2];
st1.Cells[4,3]:=copy(st1.Cells[3,3], 0, 1)+'+';
st1.Cells[4,4]:=st1.Cells[3,4]+'<-';
goto Cas6;
end;
if (copy(st1.Cells[3,2], 0, 1)=st1.Cells[4,1]) then
begin
st1.Cells[4,2]:=st1.Cells[3,2];
st1.Cells[4,3]:=st1.Cells[3,3];
st1.Cells[4,4]:=st1.Cells[3,4];
end;
if (copy(st1.Cells[3,4], 0, 1)=st1.Cells[4,1]) then
begin
st1.Cells[4,2]:=st1.Cells[3,2];
st1.Cells[4,3]:=st1.Cells[3,3];
st1.Cells[4,4]:=copy(st1.Cells[3,4], 0, 1)+'+';
end;
if (copy(st1.Cells[3,2], 0, 1)<>st1.Cells[4,1])
and (copy(st1.Cells[3,3], 0, 1)<>st1.Cells[4,1])
and (copy(st1.Cells[3,4], 0, 1)<>st1.Cells[4,1]) then
begin
st1.Cells[4,2]:=st1.Cells[3,2];
st1.Cells[4,3]:=st1.Cells[4,1]+'+';
st1.Cells[4,4]:=copy(st1.Cells[3,4], 0, 1)+ '-' + '<-';
DP:=DP+1;
st1.Cells[4,5]:='DP';
end;
st1.Cells[5,2]:=st1.Cells[4,2];
st1.Cells[5,3]:=st1.Cells[4,3];
st1.Cells[5,4]:=st1.Cells[4,4];
st1.Cells[6,2]:=st1.Cells[4,2];
st1.Cells[6,3]:=st1.Cells[4,3]+'<-';
st1.Cells[6,4]:=copy(st1.Cells[4,4], 0, 1)+'+';
st1.Cells[7,2]:=st1.Cells[4,2];
st1.Cells[7,3]:=st1.Cells[6,3];
st1.Cells[7,4]:=st1.Cells[6,4];
end;
for i:= 1 to 5 do
if SgDP.Cells[i, 0] = '' then break;
SgDP.Cells[i, 0] := IntToSTr(Taille);
SgDP.Cells[i, 1] := IntToSTr(DP);
end;
7. Résumé
L’algorithme de seconde chance est plus efficace par rapport au FIFO et LRU,
mais il est difficile a implémentée à cause à l’usage des bits de référence et la mise à
jour du temps de chargement et la recherche circulaire.

23. Simulation d’un système à temps partagé 22
VII. La représentation graphique
1. Introduction
Cette interface nous permet de visualiser les résultats obtenus dans la
simulation de la mémoire virtuelle, le graphe représente le rapport entre la taille de
page et le défaut de page.
2. Aperçu sur le programme
Le tableau est un composant (TStringGrid) nous permet de remplir des
données rangés dans des lignes et de colonnes.
Le graphe est un composant (TChart) qui nous permet de dessiner des
schémas graphique
 L'axe des x représente la taille de page
L'axe des y représente le défaut de pages.
FIG 13 : Répréhension graphique des résultats
10
12
9
1 2 3
11
4 6 7 85

24. Simulation d’un système à temps partagé 23
1. Charger la table à partir d’un fichier,
2. Sauver la table dans un fichier,
3. Effacer la table,
4. Dessiner la table,
5. Copie le graphe dans la mémoire,
6. Sauver le graphe dans un fichier,
7. Effacer le graphe,
8. Agrandir et minimiser le graphe,
9. Table d’essais,
10.Discussion des résultats.
11.Les défauts de page,
12.La représentation graphique.
3. Aperçu sur le code source
//Dessiner un point (x,y):
procedure TFrmGraphe.Dessiner_Point(x,y:integer);
begin
with graphe.SeriesList.Series[0] do
begin
ParentChart:=graphe;
AddXY(x,y,'',clRed );
end;
end;
//Dessiner le graphe
procedure TFrmGraphe.Dessiner_Graphe;
var
i:integer;
begin
for i:=1 to 5 do
Dessiner_Point (StrToInt(SG_Res.Cells[0,i]),
StrToInt(SG_Res.Cells[1,i]));
end;
4. Résumé
Il est clair que le graphe montre bien la relation entre la taille de page et le
défaut de pages. La relation entre la taille et le défaut de page est réflexive. Lorsque
la taille de page augmente ; le nombre de défaut de pages diminue.

25. Simulation d’un système à temps partagé 24
Christopher Strachey
(1916-1975) est l'un des premiers à avoir prôné une approche mathématique dans la
programmation. Il a développé des travaux sur la sémantique et la programmation
d'un petit système d'exploitation O6 6 (en 1972) en utilisant un langage de
programmation universel (pour son temps) appelé CPL puis BCPL, dont se sont
inspirés Ken Thompson pour créer B et Dennis Ritchie pour le langage C.
John McCarthy
Est le principal pionnier de l'intelligence artificielle avec Marvin Minsky, Il est
également l'inventeur en 1958 du langage Lisp. À la fin des années 50, il a créé avec
Fernando Cobarto la technique du temps partagé, qui permet à plusieurs utilisateurs
d'employer simultanément un même ordinateur.
MIT
Le MIT (Massachusetts Institute of Technology) a été fondé en 1861 par
William Barton Rogers. Le MIT est une institution de recherche et une université
américaine, leader mondiale spécialisée dans les domaines de la science et de la
technologie. Il est aussi réputé dans d'autres domaines comme le management,
l'économie, la linguistique, les sciences politiques et la philosophie.
PDP-11
Mini-ordinateur inaugure chez Digital en 1970, la première ligne de mini-
ordinateurs 16 bits, ces périphériques sont branchés sur un bus système unique ou
ils peuvent transférer des données sans intervention du processeur, 04 utilisateurs
peut utiliser la machine au même temps
Ordonnanceur
Dans les systèmes d'exploitation l’ordonnanceur désigne le module du noyau
du système d'exploitation qui choisit les processus qui vont être exécutés par les
processeurs d'un ordinateur. Le rôle de l'ordonnanceur est de permettre à tous les
processus de s'exécuter et d'utiliser le processeur de manière optimale du point de
vue de l'utilisateur.
WYSIWYG
Est un acronyme (What you see is what you get signifiant « ce que vous voyez
est ce que vous obtenez » ou plus élégamment « tel écran, tel écrit ») couramment
utilisé en informatique pour désigner les interfaces utilisateur graphiques permettant
de composer visuellement le résultat voulu, typiquement pour un logiciel de mise en
page, un traitement de texte ou d'image. Il désigne, de fait, une interface
« intuitive » : l'utilisateur voit directement à l'écran à quoi ressemblera le résultat final
(imprimé).
Glossaire

26. Simulation d’un système à temps partagé 25
 Titre : WIKIPEDIA, L'encyclopédie libre
URL : http://fr.wikipedia.org/
 Titre : Histoire de l'Informatique
Sujet : Time Sharing et Unix
URL : http://histoire.info.online.fr/
 Titre : ENSEIRB, Ecole nationale supérieure d'électronique,
informatique et de radiocommunications Bordeaux.
Sujet : Temps réel sous Linux
URL : http://www.enseirb.fr/~kadionik/glmf/lm52/linux_realtime/
 Titre : Le Jargon Français - Dictionnaire informatique
Sujet : Définition de temps partagé
URL : http://www.linux-france.org/prj/jargonf/
 Titre : Université Pierre et Marie Curie
Sujet : Systèmes d'exploitation des ordinateurs
URL : http://www.upmc.fr/
 Titre : Université LAVAL – Département d’informatique et du génie logiciel
Sujet : Cours systèmes d'exploitation
URL : http://www.ulaval.ca/
Bibliographie