REPUBLIQUE ALGERIENNE DEMOCRATIQUE ET POPULAIRE
MINISTERE D’ENSEIGNEMENT SUPERIEUR
ET DE RECHERCHE SCIENTIFIQUE
Faculté De...
Simulation d’un système à temps partagé 1
Sommaire ……………………………………………………………………………………………...………………...... 01
I. Introduction …...
Simulation d’un système à temps partagé 2
I. Introduction
La gestion du temps est l'un des problèmes majeurs des systèmes
...
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...
Simulation d’un système à temps partagé 4
III. Définition du Temps partagé
Technique consistant à partager le temps de cal...
Simulation d’un système à temps partagé 5
IV. Simulation d’un système à temps partagé
1. Introduction
Le système d’exploit...
Simulation d’un système à temps partagé 6
V. Gestion des processus
1. Introduction
La gestion des processus est l’un des r...
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 comp...
Simulation d’un système à temps partagé 8
4. Aperçu sur le programme
Le programme est composé de deux parties essentielles...
Simulation d’un système à temps partagé 9
FIG 6 : Authentification
1. Saisir le compte,
2. Saisir le mot de passe,
3. Entr...
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...
Simulation d’un système à temps partagé 11
5.Aperçu sur le Code Source
procedure TMainForm.ExecuteRequetesE_S;
var
i, j: i...
Simulation d’un système à temps partagé 12
// Marquer la requete currente
MettrePoint(ListReq, 9, i, ' ');
// Inc le temps...
Simulation d’un système à temps partagé 13
Result := False;
// Recuperer le n° de requete CPU et le n° de l'utilisateur
j ...
Simulation d’un système à temps partagé 14
if ListReq.Items[i].SubItems[9] <> '.' then
begin
ExistPoint := False;
Break;
e...
Simulation d’un système à temps partagé 15
VI. La gestion de la mémoire
1. Introduction
Le mécanisme de mémoire virtuelle ...
Simulation d’un système à temps partagé 16
4. Déplacement et remplacement
En cas de présence des zones libres dans la mémo...
Simulation d’un système à temps partagé 17
3. Analyse globale
 Partitions disponibles
en mémoire centrale
 Taille de pag...
Simulation d’un système à temps partagé 18
5. Aperçu sur le programme
FIG 12 : Application de l’algorithme de la seconde c...
Simulation d’un système à temps partagé 19
Tantque ref <> ‘’
debut : Si signe = ‘+’ alors { tester le signe de ancienne re...
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.Ce...
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.C...
Simulation d’un système à temps partagé 22
VII. La représentation graphique
1. Introduction
Cette interface nous permet de...
Simulation d’un système à temps partagé 23
1. Charger la table à partir d’un fichier,
2. Sauver la table dans un fichier,
...
Simulation d’un système à temps partagé 24
Christopher Strachey
(1916-1975) est l'un des premiers à avoir prôné une approc...
Simulation d’un système à temps partagé 25
 Titre : WIKIPEDIA, L'encyclopédie libre
URL : http://fr.wikipedia.org/
 Titr...
Prochain SlideShare
Chargement dans…5
×

Simulation d’un système à temps partagé

341 vues

Publié le

La gestion du temps est l'un des problèmes majeurs des systèmes d'exploitation, 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).

Code source disponible sur : https://github.com/benbac20/OSTimeShare

Publié dans : Formation
0 commentaire
0 j’aime
Statistiques
Remarques
  • Soyez le premier à commenter

  • Soyez le premier à aimer ceci

Aucun téléchargement
Vues
Nombre de vues
341
Sur SlideShare
0
Issues des intégrations
0
Intégrations
6
Actions
Partages
0
Téléchargements
4
Commentaires
0
J’aime
0
Intégrations 0
Aucune incorporation

Aucune remarque pour cette diapositive

Simulation d’un système à temps partagé

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

×