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


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.


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


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.


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


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é


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


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


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


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


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



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);


// 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




// Calculer le temps total des autres requetes CPU




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


//calculer la duree d'exe du requete currente

Duree_Exe := Temps_Occup + Temps_attente;

subItems[5] := IntToStr(Duree_Exe); // duree


//calculer le temps total du requete currente

Temps_Total := Duree_Exe + Temps_Entre;

subItems[6] := IntToStr(Temps_Total); // total


//Calculer la somme des temps d'occupation de tous les requetes

somme := 0;


if ListReq.Items[i].subItems[0] = 'CPU' then

somme := somme + StrToInt(ListReq.Items[i].subItems[3]);

if somme < 1 then somme := 1;



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);


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.


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’.


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


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



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


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


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;


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]+'<-';


{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




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]+ '+';


DP:=DP+1;


end

else

begin



end;

end

else if (st1.Cells[2,4]='') then

begin



st1.Cells[3,4]:=st1.Cells[3,1]+'+' ;

DP:=DP+1;


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;


end ;

end ;

end;

Cas6: if (st1.cells[4,1]<> '') then //5

begin


if (copy(st1.Cells[3,3], 0, 1)=st1.Cells[4,1]) then

begin


st1.Cells[4,3]:=copy(st1.Cells[3,3], 0, 1)+'+';

st1.Cells[4,4]:=st1.Cells[3,4]+'<-';

goto Cas6;

end;


begin




end;


begin




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,3]:=st1.Cells[4,1]+'+';

st1.Cells[4,4]:=copy(st1.Cells[3,4], 0, 1)+ '-' + '<-';

DP:=DP+1;


end;





st1.Cells[6,3]:=st1.Cells[4,3]+'<-';





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.


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.


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


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.


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


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

Simulation d’un système à temps partagé

Education

Transcript of Simulation d’un système à temps partagé