Download - Simulation d’un système à temps partagé
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
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
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.
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
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.
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
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é
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
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
12 1
5
1
9
1
8
3
13 1
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
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
13 1 11
0
12 1 10
1
1
2
1
3
1
4
9
8
7
6 1
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);
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
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
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.
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’.
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
victimesuivante
# de page0
# de page0
# de page0
# de page0
# de page0
# de page1
# de page1
victimechoisie
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
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 7 5
6
10
4
8
9
+ -
1
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;
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
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.
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 8 5
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.
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
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