Système à temps partagé. 2 Soit un système à temps partagé où les utilisateurs composent un...

Système à temps partagé

Système à temps partagé 2

Système à temps partagéSystème à temps partagéSoit un système à temps partagé où les utilisateurs composent un numéro pour accéderau 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 aussilongtemps que l’usager n’a pas raccroché le téléphone.

Kportsusagers

Noeud de calcul


Système à temps partagéSystème à temps partagéLes usagers tentent d’accéder au système en des temps aléatoires à un taux moyende 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 transmissionde façon à améliorer le niveau de service.L’acquisition de nouveaux ports est dispendieux.

coût en matériel : $ 4 000service téléphonique : $ 25/mois

Le système peut supporter un maximum de 32 ports et la puissance du système estlimitée.


Système à temps partagéSystème à temps partagé

Temps de calcul moyen Coût Mémoire suppl.

10 0 08 20,000 1M7 30,000 2M

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.


Formulation du problèmeFormulation du problèmeNous pouvons utiliser un modèle de simulation pour prédire la performance dusystème lorsque ses paramètres changent:

Quelle est la probabilité de se relier au système, laquelle est une fonction dunombre de ports ?

ouQuel est le nombre moyen de ports occupés lequel est une fonction de laquantité de la mémoire, du nombre de ports, de la vitesse de transmission.

ouQuel est le niveau de satisfaction des usagers en fonction des ressourcesajoutées.

ou encore,


Formulation du problèmeFormulation du problème

Max Satisfaction de l’utilisateursujet à Coût total des dépenses < Co

Min Coût total des dépensessujet à Satisfaction des usagers > So

Min longueur moyenne d’une sessionsujet à Coût total < Co

Min Coût total (Coût des usagers + des ressources)

pour optimiser une fonction objectif sujet à certaines contraintes:

ou

ou

ou


Formulation du problèmeFormulation du problèmePlusieurs 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.


Formulation du problèmeFormulation du problèmePour 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(t) : taux d’arrivée moyen des usagers au temps tCT : Coût mensuel pour chaque ligne téléphonique additionnelleCH : Coût en matériel par port additionnelCU : Coût permettant à tous les usagers de transmettre à 960 cpsL : durée moyenne de vie du matérielkl : nombre de ports additionnelsCR : investissement dans des ressources additionnelles(mémoire)K : nombre total de ports : ko + klU : CU

: 0 si les usagers demeurent à 120 cps.E[T] : durée moyenne d’une session d’un usager.



ressources matériel augmentation lignes téléphoniquesadditionnelles port vitesse additionnelles

transmission

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

PK : Prob. un usager ne peut être relié au système immédiatement car les K

ports sont occupésPC : Prob. un usager peut être relié au système immédiatement.

Niveau de service = 1-PK.



Le choix semble le plus judicieux.

Note : On pose Po 0.02.

Nous cherchons à :

Min TCsujet à PK < Po

1. 2. Min PK

sujet à TC < TCo

3. Min Coût total incluant le coûtassocié au temps d’attentedes usagers

1.


DÉVELOPPEMENT DU DÉVELOPPEMENT DU MODÈLE ANALYTIQUEMODÈ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 lajournée a un effet qui s’estompe rapidement.

c) la distribution du temps entre les appels ne change pas (substantiellement dumoins) lorsque tous les ports sont occupés.

Modèle de file d’attente.


NotationsNotationsPi Prob i usagers sont reliés au système , i = 0, 1, 2, ..., K = 1 / temps moyen entre les arrivées = 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 ( )i / i! (*)

i=0



Objectif:Min TC Approche: Générer les 6 graphiques possiblesPC 0.98 et choisir la meilleure solution.

108 choix possibles (2 vitesses de transmission, 3 tailles de la mémoire, 18 portssupplémentaires).

Chacune de ces alternatives est caractérisé par le temps de liaison (1/) et le nombrede 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 totalannuel et le niveau de service peuvent être calculés en fonction du nombre de ports.



2000

4000

6000

8000

10,000

12,000

14,000

16,000

.02

.04

.06

.08

.10

.12

.14

.16

0 2 4 6 8

120 cps et 3MTC

PK

NIVEAU DE SERVICE

COÛT TOTAL

ANNUEL

Nombre de ports additionnels


DÉVELOPPEMENT D’UN DÉVELOPPEMENT D’UN MODÈLE DE SIMULATIONMODÈLE DE SIMULATION

Question: Les hypothèses imposées pour développer notre modèle analytiqueviennent-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)


MODÈLE DE SIMULATIONMODÈ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 deré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



const double Maximum_des_reels = 3.4E38;long souche;enum Bool {false, true};float Temps; // Instant courant de la simulationfloat Duree_de_la_simulation; // Durée de la simulationfloat Duree_du_rechauffement; // Durée du réchauffementfloat temps_moyen_entre_2arrivees; // Temps moyen entre 2 arrivéesfloat longueur_session_moyenne; // Durée moyenne d'une sessionenum 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 traiterfloat Instant_Prochain_Evenement[3]; // Instant d'occurrence du prochain

// événement prévu de chaque type



typedef struct Port{

float Debut_session; // Début d'une sessionfloat Longueur_session; // Durée d'une session

};

int Port_courant; // Prochain port libéré.int K; // # ports disponiblesenum Bool Ports_utilises[Kmax]; // Information sur les sessions en coursstruct Port Information_sur_les_ports[Kmax];

int Nombre_d_appels; // Nombre total d'appels au systèmeint Nombre_d_appels_reussis;



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



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



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

}


MODÈLE DE SIMULATIONMODÈLE DE SIMULATIONvoid Lire_Donnees(){

/* Lecture de la durée de la simulation, du temps moyen entre deux arrivéessuccessives, de la longueur moyenne d'une session et du nombre de portsdisponibles. 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");

}


MODÈLE DE SIMULATIONMODÈLE DE SIMULATIONvoid 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;

}


MODÈLE DE SIMULATIONMODÈLE DE SIMULATIONvoid 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();

}


MODÈLE DE SIMULATIONMODÈLE DE SIMULATIONvoid 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;}


MODÈLE DE SIMULATIONMODÈLE DE SIMULATIONvoid 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);

}


MODÈLE ÉTENDU DE MODÈLE ÉTENDU DE SIMULATIONSIMULATION

À l’aide de notre modèle de simulation, nous pouvons relâcher les hypothèsesimposé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é. 2 Soit un système à temps partagé où les utilisateurs composent un...

Documents

Transcript of Système à temps partagé. 2 Soit un système à temps partagé où les utilisateurs composent un...