Système à temps partagé

1. Système à temps partagé

2. Système à temps partagé Soit un système à temps partagé où les utilisateurs composent un numéro pour accéder au système. $ K ports pour accéder au système. Si tous les ports sont occupés, un signal “occupé” est transmis. L’usager devra réessayer plus tard. Lorsqu’un usager accède au système, le port choisi n’est plus disponible tant et aussi longtemps que l’usager n’a pas raccroché le téléphone. Noeud de calcul K ports usagers Système à temps partagé

3. Système à temps partagé • Les usagers tentent d’accéder au système en des temps aléatoires à un taux moyen • de 35 appels/heure. • La longueur moyenne d’une session au terminal est de 25 minutes. • Il existe 14 ports disponibles. • Plusieurs demandes ont été faites pour améliorer les capacités de la machine • (UCT, mémoire), augmenter le nombre de ports et la vitesse de transmission • de façon à améliorer le niveau de service. • L’acquisition de nouveaux ports est dispendieux. • Ý • coût en matériel : $ 4 000 • service téléphonique : $ 25/mois • Le système peut supporter un maximum de 32 ports et la puissance du système est • limitée. Système à temps partagé

4. Système à temps partagé En augmentant le taux de transmission entre l’ordinateur et les usagers de 120 cps (caractères/sec.) à 960 cps, le temps moyen d’une session pourrait être réduit de 3 min. • Coût : $400/terminal • (100 terminaux peuvent se connecter au système). L’augmentation de la mémoire est aussi à envisager. Temps de calcul moyenCoûtMémoire suppl. 1000 8 20,000 1M 7 30,000 2M Système à temps partagé

5. Formulation du problème Nous pouvons utiliser un modèle de simulation pour prédire la performance du système lorsque ses paramètres changent: Quelle est la probabilité de se relier au système, laquelle est une fonction du nombre de ports ? ou Quel est le nombre moyen de ports occupés lequel est une fonction de la quantité de la mémoire, du nombre de ports, de la vitesse de transmission. ou Quel est le niveau de satisfaction des usagers en fonction des ressources ajoutées. ou encore, Système à temps partagé

6. Formulation du problème pour optimiser une fonction objectif sujet à certaines contraintes: • Max Satisfaction de l’utilisateur • sujet à Coût total des dépenses < Co • Min Coût total des dépenses • sujet à Satisfaction des usagers > So • Min longueur moyenne d’une session • sujet à Coût total < Co • Min Coût total (Coût des usagers + des ressources) ou ou ou Système à temps partagé

7. Formulation du problème • Plusieurs de ces objectifs et contraintes ont besoin d’être explicités davantage: • La satisfaction des usagers nécessite de considérer • la probabilité qu’un usager accède au système dès la première fois. • le temps qu’un usager reste dans le système une fois reliée. • Pour mesurer les temps d’attente des usagers, nous devons considérer • le temps d’attente avant d’avoir accès au système. • les temps d’attente avant d’avoir accès aux ressources du système. • etc. Système à temps partagé

8. Formulation du problème Pour faciliter la formulation du problème et le développement du modèle, nous considérons les paramètres et variables suivants: ko : nombre courant de ports l(t) : taux d’arrivée moyen des usagers au temps t CT : Coût mensuel pour chaque ligne téléphonique additionnelle CH : Coût en matériel par port additionnel CU : Coût permettant à tous les usagers de transmettre à 960 cps L : durée moyenne de vie du matériel kl: nombre de ports additionnels CR : investissement dans des ressources additionnelles(mémoire) K : nombre total de ports : ko + kl U : Þ CU : Þ 0 si les usagers demeurent à 120 cps. E[T] : durée moyenne d’une session d’un usager. Système à temps partagé

9. Formulation du problème n(t) : nombre d’usagers reliés au système au temps t. TC : coût total annuel CR + kl CH + U/L + 12 kl CT • ressources matériel augmentation lignes téléphoniques • additionnelles port vitesse additionnelles • transmission PK : Prob.{ un usager ne peut être relié au système immédiatement car les K ports sont occupés} PC : Prob.{ un usager peut être relié au système immédiatement}. º Niveau de service = 1-PK. Système à temps partagé

10. Formulation du problème Nous cherchons à : Min TC sujet à PK < Po Min Coût total incluant le coût associé au temps d’attente des usagers Min PK sujet à TC < TCo 1. 2. 3. • \ Le choix semble le plus judicieux. • Note : On pose Poº 0.02. 1. Système à temps partagé

11. DÉVELOPPEMENT DU MODÈLE ANALYTIQUE Un modèle analytique peut être développé si les hypothèses suivantes sont satisfaites: a) les temps de liaison et temps entre des appels au système sont des v.a. expon. (durée de service) (temps entre les arrivées de clients) • b) la présence d’un nombre initial d’usagers reliés au système au début de la • journée a un effet qui s’estompe rapidement. • c) la distribution du temps entre les appels ne change pas (substantiellement du • moins) lorsque tous les ports sont occupés. • ß • Modèle de file d’attente. Système à temps partagé

12. Notations • Piº Prob { i usagers sont reliés au système }, i = 0, 1, 2, ..., K • l = 1 / temps moyen entre les arrivées • m = 1 / longueur moyenne d’une session • K • Þ P0 =  (  )i / i! -1 • i=0 • Pi = P0 (  )i / i 1 <= i <= K • PK = Prob { tous les ports sont occupés } • K • = (  )K / K  (  )i / i! (*) • i=0 Système à temps partagé

13. DÉVELOPPEMENT DU MODÈLE ANALYTIQUE $ 108 choix possibles (2 vitesses de transmission, 3 tailles de la mémoire,  18 ports supplémentaires). Chacune de ces alternatives est caractérisé par le temps de liaison (1/m) et le nombre de ports K. ß le niveau de service PC peut être calculé à l’aide de (*) pour chaque alternative. En considérant une vitesse de transmission et une taille de la mémoire, le coût total annuel et le niveau de service peuvent être calculés en fonction du nombre de ports. Objectif: Min TC Approche: Générer les 6 graphiques possibles PC 0.98 et choisir la meilleure solution. Système à temps partagé

14. DÉVELOPPEMENT DU MODÈLE ANALYTIQUE NIVEAU DE SERVICE 16,000 .16 COÛT TOTAL ANNUEL 120 cps et 3M 14,000 .14 TC 12,000 .12 10,000 .10 8000 .08 6000 .06 PK 4000 .04 2000 .02 0 2 4 6 8 Nombre de ports additionnels Système à temps partagé

15. DÉVELOPPEMENT D’UN MODÈLE DE SIMULATION • Question: Les hypothèses imposées pour développer notre modèle analytique • viennent-elles entacher nos résultats? • Paramètres: - temps moyen entre 2 arrivées d’usagers • - # ports au total • - durée moyenne d’une session au terminal. • État: - # ports occupés • - temps d’arrivée d’un usager • - temps où l’usager du port I termine sa session • - Indicateur de l’état du port I (occupé ou non). • MESURES DE PERFORMANCE • (a) - accumulation des temps de liaison au système • (b) - nombre total d’appels d’usagers pour accéder au système • (c) - nombre total d’appels d’usagers qui ont accédé au système • (d) - probabilité qu’un usager puisse accéder au système º (c)/(b) Système à temps partagé

16. MODÈLE DE SIMULATION /***************************************************************** Simulation d'un système à temps partagé. Le système est initialement vide et on simule pendant une période [Duree_du_rechauffement, Duree_de_la_simulation]. L'intervalle de réchauffement du simulateur est [0, Duree_du_rechauffement]. *****************************************************************/ #include <stdio.h> #include <stdlib.h> #include <time.h> #include <math.h> #define Kmax 32 // # maximum de ports Système à temps partagé

17. MODÈLE DE SIMULATION const double Maximum_des_reels = 3.4E38; long souche; enum Bool {false, true}; float Temps; // Instant courant de la simulation float Duree_de_la_simulation; // Durée de la simulation float Duree_du_rechauffement; // Durée du réchauffement float temps_moyen_entre_2arrivees; // Temps moyen entre 2 arrivées float longueur_session_moyenne; // Durée moyenne d'une session enum Evenement {Arrivee = 0, Depart = 1, Fin_du_rechauffement = 2, Fin_de_simulation = 3}; enum Evenement Evenement_courant; // Événement que nous sommes // en train de traiter float Instant_Prochain_Evenement[3]; // Instant d'occurrence du prochain // événement prévu de chaque type Système à temps partagé

18. MODÈLE DE SIMULATION typedef struct Port { float Debut_session; // Début d'une session float Longueur_session; // Durée d'une session }; int Port_courant; // Prochain port libéré. int K; // # ports disponibles enum Bool Ports_utilises[Kmax]; // Information sur les sessions en cours struct Port Information_sur_les_ports[Kmax]; int Nombre_d_appels; // Nombre total d'appels au système int Nombre_d_appels_reussis; Système à temps partagé

19. MODÈLE DE SIMULATION float Duree_entre_deux_arrivees(); float Duree_du_service(); void Lire_Donnees(); void Initialisation_Simulation(); void Arrivee_d_un_client(); void Fin_d_une_session(); void Rechauffement(); void Rapport(); Système à temps partagé

20. MODÈLE DE SIMULATION void main() { Lire_Donnees(); Initialisation_Simulation(); do { if(Instant_Prochain_Evenement[Arrivee] < Instant_Prochain_Evenement[Depart]) Evenement_courant = Arrivee; else Evenement_courant = Depart; Temps = Instant_Prochain_Evenement[Evenement_courant]; if(Temps >= Duree_de_la_simulation) { Temps = Duree_de_la_simulation; Evenement_courant = Fin_de_simulation; }; if(Temps > Instant_Prochain_Evenement[Fin_du_rechauffement]) { Temps = Duree_du_rechauffement; Evenement_courant = Fin_du_rechauffement; }; switch (Evenement_courant) { case Arrivee : Arrivee_d_un_client(); break; case Depart : Fin_d_une_session(); break; case Fin_du_rechauffement : Rechauffement(); break; case Fin_de_simulation : Rapport(); break; }; } while (Evenement_courant != Fin_de_simulation); } Système à temps partagé

21. MODÈLE DE SIMULATION float Duree_entre_deux_arrivees() { // Génère la durée entre deux arrivées successives. return (float) (-log(1.0 - (float)((rand() % 10000) / 10000.0)) * temps_moyen_entre_2arrivees); } float Duree_du_service() { // Génère une durée de service. return (float) (-log(1.0 - (float)((rand() % 10000) / 10000.0)) * longueur_session_moyenne); } Système à temps partagé

22. MODÈLE DE SIMULATION void Lire_Donnees() { /* Lecture de la durée de la simulation, du temps moyen entre deux arrivées successives, de la longueur moyenne d'une session et du nombre de ports disponibles. Impression des données d'entrée. */ printf(" Veuillez fournir les renseignements suivants : \n\n"); printf(" Duree du rechauffement = "); scanf("%f", &Duree_du_rechauffement); printf(" Duree de la simulation = "); scanf("%f", &Duree_de_la_simulation); printf(" Temps moyen entre deux arrivees successives = "); scanf("%f", &temps_moyen_entre_2arrivees); printf(" Longueur moyenne d'une session = "); scanf("%f", &longueur_session_moyenne); printf(" Nombre de ports disponibles = "); scanf("%d", &K); printf(" ---------------------------------\n"); } Système à temps partagé

23. MODÈLE DE SIMULATION void Initialisation_Simulation() { int i; /* Initialise le système à vide, initialise l'horloge et tous les compteurs à 0, le prochain événement est une arrivée et on prévoit son instant d'occurrence.*/ Temps = 0.0f; souche = time(NULL); srand((int)souche); for (i = 0; i < K; i++) Ports_utilises[i] = false; Instant_Prochain_Evenement[Arrivee] = Duree_entre_deux_arrivees(); Instant_Prochain_Evenement[Depart] = (float) Maximum_des_reels; Instant_Prochain_Evenement[Fin_du_rechauffement]=Duree_du_rechauffement; Nombre_d_appels = 0; Nombre_d_appels_reussis = 0; } Système à temps partagé

24. MODÈLE DE SIMULATION void Arrivee_d_un_client() { int i = 0; enum bool Port_trouve = false; Nombre_d_appels += 1; do { if (Ports_utilises[i] == false) { Ports_utilises[i] = true; Information_sur_les_ports[i].Debut_session = Temps; Information_sur_les_ports[i].Longueur_session = Duree_du_service(); if(Instant_Prochain_Evenement[Depart] > Temps + Information_sur_les_ports[i].Longueur_session) { Port_courant = i; Instant_Prochain_Evenement[Depart] = Temps + Information_sur_les_ports[i].Longueur_session; }; Nombre_d_appels_reussis += 1; Port_trouve = true; }; i += 1; } while ((Port_trouve == false) && (i < K)); Instant_Prochain_Evenement[Arrivee] = Temps + Duree_entre_deux_arrivees(); } Système à temps partagé

25. MODÈLE DE SIMULATION void Fin_d_une_session() { float T = (float) Maximum_des_reels; int i; Ports_utilises[Port_courant] = false; for (i = 0; i < K; i++) if(Ports_utilises[i] == true) { if (Information_sur_les_ports[i].Debut_session + Information_sur_les_ports[i].Longueur_session < T) { T = Information_sur_les_ports[i].Debut_session + Information_sur_les_ports[i].Longueur_session; Port_courant = i; }; }; if(T < Maximum_des_reels) Instant_Prochain_Evenement[Depart] = Information_sur_les_ports[Port_courant].Debut_session + Information_sur_les_ports[Port_courant].Longueur_session; else Instant_Prochain_Evenement[Depart] = (float) Maximum_des_reels; } Système à temps partagé

26. MODÈLE DE SIMULATION void Rechauffement() { Instant_Prochain_Evenement[Fin_du_rechauffement] = (float) Maximum_des_reels; Nombre_d_appels = 0; Nombre_d_appels_reussis = 0; } void Rapport() { // Imprime la probabilité qu'un usager puisse accéder au système. printf("Probabilite qu'un usager puisse acceder au systeme : %.3f", ((float) Nombre_d_appels_reussis) / (float) Nombre_d_appels); } Système à temps partagé

27. MODÈLE ÉTENDU DE SIMULATION À l’aide de notre modèle de simulation, nous pouvons relâcher les hypothèses imposées sur la distribution des temps d’arrivées et des durées de service. Grâce à la simulation, nous pouvons considérer aussi d’autres aspects du système, ce qui serait impossible avec un modèle analytique. Représenter le comportement des usagers lorsqu’ils ne réussissent pas à obtenir une ligne du premier coup. Catégories d’usagers. etc. Système à temps partagé