Mini-projet sur la simulation

Introduction :

La simulation est une technique qui sert à approcher des phénomènes  d’une manière scientifique.

Les problèmes pratiques où la simulation est utilisée, sont relatifs à tous les aspects de la vie réelle. On peut citer:

§  La stratégie ou tactique de guerre.

§  Les problèmes industriels tels que la gestion des stocks, les systèmes de distribution,  de maintenance ou de file d'attente.

§  Les problèmes économiques comme l'étude de la demande, les fluctuations du marché, les plans de développement, la gestion d'un portefeuille d'actions.

§  Les systèmes biomédicaux tels que les équilibres de fluide et la distribution électrolyte dans le corps humain, la prolifération de cellules infectées.

§  Les simulations de vols d'avion ou de fusée.

Ainsi, la simulation se voit  fournir au gestionnaire des informations quantitatives de toute nature, afin de faciliter sa prise de décision.

En effet, et à partir d'une série d'essais, on construit un modèle servant à reproduire aussi exactement que possible un système ou une partie de système à évaluer. Ce modèle doit regrouper des informations jugées pertinentes à la compréhension du fonctionnement du système existant ou à l'étude.

Outre que ces fonctionnalités, la simulation sert aussi à déterminer le comportement du système dans de diverses  conditions.

A travers  ce travail, on se propose d’utiliser cette technique pour récolter un certain nombre d’information concernant un système d’information et ce pour une période déterminée.

 I-         PROBLEMATIQUE:

Dans un système informatique, les programmes sont lancés à partir du terminal. Le temps qui sépare les émissions  des  programmes est distribué uniformément entre 5s et 40s.

La mémoire centrale disponible pour le chargement des programmes émis est de 1000 pages.

La taille d’un programme est distribuée uniformément entre 10 et 80 pages.

La durée d’exécution d’un programme est distribuée uniformément entre 13 et 50 secondes.

Les programmes en mémoire centrale se partagent le processeur avec un quantum de 3 secondes.

Le nombre de programmes en mémoire n’est limité que par la taille mémoire.

On se propose de mesurer les cinq paramètres suivants :

ü    Le nombre des programmes exécutés par le système.

ü    Le temps moyen d’attente pour le chargement en mémoire.

ü    Le temps moyen de résidence des travaux dans le système.

ü    Le taux d’utilisation du processeur central.

ü    Le taux d’utilisation (remplissage) de la mémoire.

    II-      TRAVAIL A REALISER :

 En utilisant la simulation, on doit :

1)   Estimer les 5 paramètres précédents pour une journée

2)   Calculer les intervalles de confiance à 95% relatifs aux cinq paramètres précédents pour un échantillon de 40 jours

3)   Calculer la taille qu’il faut étudier afin d’avoir une largeur de 10 secondes pour l’intervalle de confiance concernant le temps moyen de résidence des travaux dans le système.

4)   on envisage une extension de la mémoire de 500 pages et on aimerait avoir une idée de l'influence de cette opération sur les paramètres précédents, pour cela reprendre les questions 1,2 et 3.

    III-    SYSTEME ET SIMULATION :

Pour étudier un système complexe, on est le plus souvent amenés à simplifier certaines propriétés des phénomènes en mettant un certain nombre d'hypothèses sur son fonctionnement. Ces hypothèses qui revêtent le plus souvent, la forme de relations mathématiques ou logiques, constituent un modèle.

            Un modèle est donc une description d'un processus d'intérêt que on appelons généralement système et qui a pour objectif de prédire ce qui arrive si certaines conditions sont remplies. Un modèle est souvent une simplification de la réalité.

En d'autres termes, la simulation est une technique de modélisation permettant de construire une abstraction de la réalité c'est à dire, un modèle et de le faire évoluer en fonction du temps.

On peut résumer par l'organigramme suivant les différentes façons d'étudier un système:

IV-      LA SIMULATION A EVENEMENTS DISCRETS:

Dans une simulation à événements discrets, les variables qui déterminent l'état du système appelées, variables d'état du système et que l'on désire connaître à tout instant sont discrètes.

L'ensemble des valeurs que peut prendre ces variables est appelé espace d'état du système.

C'est donc, un espace dénombrable ou fini. Donc les changements d'état ou événements se produisent d'une manière discrète dans le temps. Les instants de changements d'état sont appelés dates d'événements ou dates d'occurrence.

Il s'ensuit, pour que la simulation soit possible, on devons être capables de décrire les changements d'état ou événements par des algorithmes. Les événements arrivant d'une manière discrète, doivent être ordonnés chronologiquement et donc simulés l'un après l'autre sur une machine séquentielle.

Avant de fermer ce paragraphe, on dit un mot sur la simulation continue. On désigne par simulation continue l'utilisation des ordinateurs dans la résolution des modèles ayant des états qui changent de façon continue dans le temps. De tels modèles sont généralement, composés d'équations différentielles. Et donc on doit faire appel à des méthodes mathématiques plus élaborées.

V-     MECANISME D'AVANCEMENT DU TEMPS:

 En raison de la nature dynamique des modèles de simulation à événements discrets, on devons connaître la valeur actuelle du temps de simulation et disposer d'un moyen de faire avancer ce temps de simulation d'un point à l'autre.

  On appellera horloge de simulation la variable qui nous donne la valeur courante du temps de simulation.

  Selon la façon de gérer le temps dans la simulation à événements discrets, on distingue:

§  la simulation dirigée par événements.

§  la simulation dirigée par une horloge.

§  La simulation dirigée par activités.

La plupart des langages de simulation utilisent la première approche. Dans une simulation dirigée par événements, les seuls temps accessibles lors de la simulation sont les dates d'événements et l'incrémentation du temps, se fait d'une date d'événement à l'autre.

 L'horloge est initialisée à zéro et le temps des prochains événements est déterminé. L'horloge est alors avancée à la date du premier événement. L'état du système est alors mis à jour, tenant compte de l'événement qui vient de se produire. La liste des dates des événements futurs est mise à jour, l'événement qui vient de se produire est supprimé de la liste des événements, tous les autres événements sont translatés d'une position dans cette liste. L'horloge est ensuite, avancée à la date de l'événement suivant et ainsi de suite, jusqu'à ce qu'une condition d'arrêt soit rencontrée.          

VI-    SIMULATION PAR UN LANGAGE DE LA POO (C#):

Cet essai consistait à formuler un code qui sera d’une part adapté à la fonctionnalité du langage c#, et d’autre part pouvoir approcher notre problème par un modèle représentant le mieux possible la réalité

Le code est basé sur les deux structures suivantes :

ü  Calendrier qui trace la succession des programmes depuis l’émission jusqu’à la fin d’exécution.

ü  Programme qui permet de compter le nombre des programmes émis.

Données à saisir :

ix, iy, iz : germes de la fonction alea.

t_miep : temps minimum inter émission de programmes (défaut : 5s)

t_mxiep : temps maximum  inter émission de programmes (défaut : 40s)

t_m : taille mémoire (défaut : 1000 pages)

t_mp : taille minimum d’un programme (défaut : 10)

t_mxp : taille maximum d’un programme (défaut : 80)

d_me : durée minimum d’exécution d’un programme (défaut : 13)

d_mxe : durée maximum d’exécution d’un programme (défaut : 50)

d_q : durée d’un quantum (défaut : 3 s)

d_s ; durée d’un scénario (défaut : 12*3600)

Données à calculer

Np : nombre de programmes exécutés dans le système (calculé à l’aide d’un compteur d’entrée des programmes)

Tma : temps moyen d’attente pour le chargement en mémoire (calculé en divisant la durée séparant le temps d’émission de chaque programme et le temps de chargement du programme)

Tmr : temps moyen de résidence dans le système (calculé en additionnant les durées séparant le temps d’émission de chaque programme à  sa fin d’exécution et en divisant par le nombre de programmes émis)

Tup : taux d’utilisation du processeur central (calculé en comptabilisant toutes les durées d’inactivité du processeur, en le détectant à chaque début de quantum, et en divisant leur total par d_s et prendre son complémentaire à 1)

Tum : taux d’utilisation de la mémoire (calculé en comptabilisant le taux de remplissage à chaque top de quantum et en divisant par d_s/3)

Variables intermédiaires

H : temps courant

Prog[tp,tep,tcp,tfe] : tableau dynamique  qui trace chaque programme en enregistrant sa taille, sa date d’entrée, sa date de chargement et sa date de fin d’exécution.

Ttp : taille totale des programmes en mémoire

FileC[num_prog] : file d’attente des programmes à charger en mémoire.

FileE[num_prog, nb_quantum, reste] : file d’attente des programmes à exécuter.

Calendrier[H,evenement,Programme ] : calendrier des événements à prévoir.

Evénements

1-      Emission_pg()

2-      Chargement_pg()

3-      Fin_execution()

4-      Top_quantum()

Emission_pg()

ü  Calcul de la prochaine émission de programme tant que H<dsàcalendrier(,« émission »,)

ü  Calcul de la taille du programme tp

ü  Enregistrer sa taille tp, sa date d’entrée tep dans Prog[]

ü  Incrémentation de Np

ü  Vérification si le premier programme dans la file peut être chargé en mémoire (tp<=(tm-Ttp) ), si oui àcalendrier(,« chargement »,) sinon  Mettre le programme dans la file d’attente

Chargement_pg()

ü  Vérification si le premier programme dans la file peut être chargé en mémoire (tp<=(tm-Ttp) ), si oui charger en mémoire (enregistrer le temps de chargement dans le tableau Prog , sinon passer au prochain dans la file jusqu’à la fin de la file.

ü  Enregistrer le temps d’exécution du programme.

ü  Calcul progressif du temps moyen d’attente Tma.

ü  Calculer sa durée d’exécution tex

ü  Calcul du nombre de quantums nécessaires à l’exécution du programme (Nq=tex/tq) ainsi que le reste (reste=Nq-tex/tq) et son enregistrement

ü  Mettre le programme dans la file d’exécution FileE[].

Fin_execution()

ü  Libération mémoire du programme. (Ttp=Ttp-tp)

ü  Enregistrement du temps de fin d’exécution tfe.

ü  Calcul progressif du temps moyen de résidence Tmr.

ü  Appeler  Chargement_pg()

Top_quantum()

ü  Se positionner sur le programme suivant (en gérant une file d’attente circulaire, chaque élément contient le N° du programme, son temps d’exécution tex)

ü  tex=tex-3

Si      tex>3--->calendrier(H+3, « top_quantum »,)

Sinon --à calendrier(H+tex, « fin_execution»,)

Algorithme :

VII- Présentation du programme de simulation:

 

Conclusion :

A travers ce travail, on déduiT clairement  que les résultats d'une simulation sont des observations statistiques sujettes à des erreurs expérimentales. Elle permet en outre de se rapprocher de la réalité par des calculs statistiques.

Categories: c#, simulation