Simulation Discrète - SIMSCRIPT et GPSS

Simulation Discrète - SIMSCRIPT et GPSS

SIMULATION DISCRETE

avec

SIMSCRIPT et GPSS

Nicolas FAGART

DESS D'Informatique appliquée aux Sciences de la Terre.

MARS 1995.

SOMMAIRE.

INTRODUCTION

I Introduction à la SIMULATION DISCRETE.

• I.1) L'exemple:
• I.2) Le Vocabulaire.
• I.3) Le Temps en Simulation Discrète.
• I.4) Arrivées dans le Système
• I.5) Files d'attentes.
• I.6) Listes Chaînées

SOMMAIRE. Simulation Discrète - SIMSCRIPT et GPSS 1

 Simulation Discrète - SIMSCRIPT et GPSS

II SIMSCRIPT

• II.1) Concepts de base.

• II.2) Eléments de Langage en SIMSCRIPT
• II.3) Un exemple de Programme SIMSCRIPT

III GPSS

• III.1) Concepts de bases de GPSS

• III.2) Elément de langage de GPSS
• III.3) Un exemple de programmation en GPSS

CONCLUSION

BIBLIOGRAPHIE

INTRODUCTION

Cette étude a pour objet, la Simulation discrète. Nous nous attacherons plus particulièrement
à deux langages, qui ont été développés spécialement pour ce type de simulation: GPSS et
SIMSCRIPT.

Nous allons dans un premier temps décrire les principes de base de la Simulation discrète,
afin de familiariser le lecteur avec les problèmes de simulation, et de présenter les fonctions
que devront remplir les langages de simulation.

Dans un deuxième temps nous présenterons deux exemples de langages de simulation

discrète, SIMSCRIPT et GPSS. Nous tenterons d'en décrire les concepts de base, puis les
éléments de langage. Enfin nous étudierons un programme d'exemple, qui sera le même
pour les deux langages, résolvant le problème de simulation présenté dans la première partie.

INTRODUCTION Simulation Discrète - SIMSCRIPT et GPSS 2

 Simulation Discrète - SIMSCRIPT et GPSS

Ces deux langages sont ceux qui ont été le plus utilisés dans des débuts de la simulation.
FORTRAN était le plus développé au départ, mais son but principal n'était pas la
Simulation, GPSS et SIMSCRIPT ont été eux développé dans ce but. D'autres langages
comme PL/I, COBOL, SIMULA et GASP ont aussi été des bons outils en matière de
simulation, mais moins répandus que GPSS ET SIMSCRIPT.

I Introduction à la SIMULATION DISCRETE.

I.1) L'exemple:

Pour bien comprendre le principe de la simulation discrète, nous nous appuierons au cours
de cette étude sur un exemple très simple: L'utilisation d'une cabine téléphonique par des
usagers. Des usagers arrivent à la cabine téléphonique, désirant téléphoner. Si la cabine est
occupée au moment de leur arrivée, ils doivent rejoindre la file d'attente. Dès que le
téléphone est libéré, la première personne de la file entre dans la cabine, elle y reste pendant
son appel qui dure un certain temps. Ensuite elle quitte la cabine libérant ainsi le téléphone
pour le suivant. La figure 1 représente la scène, et la figure 2 décrit le parcourt d'un usager.

Figure 1 : Cabine téléphonique.

I Introduction à la SIMULATION
Simulation Discrète
DISCRETE.- SIMSCRIPT et GPSS 3
 Simulation Discrète - SIMSCRIPT et GPSS

Figure 2 : Diagramme du parcourt d'un usager.

I.2) Le Vocabulaire.

• Les Entités: Ce sont les composants du système qui interagissent. Dans notre
exemple, les usager et le téléphone sont des entités.
• Les Attributs: Ce sont les caractéristiques, les propriétés des entités.
• L'Etat du Système : Il est déterminé par la valeur des attributs des entités, ainsi que
les relations entre ces entités, à un moment donné. L'évolution du système dépend
des changements d'état du système.
• Les Activités :Ce sont tous les processus qui aboutissent à un changement d'état du
système. Ce sont les entités qui entrent en activité. Par exemple, l'arrivée et le départ
d'un usager sont des activités.
• Les Evénements : Ce sont les apparitions des activités à un instant particulier. Un
événement se produit à l'instant ou le téléphone est libéré par un usager. Les
événements doivent être stockés (et étudiés), dans le " Event-Shedule ", qui est le
programme des événements à venir (cela correspond à peu près au " sequencing
set ").

I.3) Le Temps en Simulation Discrète.

Dans la plupart des simulations, l'écoulement du temps simulé doit être contrôlé. Cela est
automatique dans la plupart des langages dédiés à la simulation. Si ce n'est pas le cas, il faut
un algorithme spécifique pour la gestion du temps.

L'horloge de Simulation (" Simulation clock ") est intimement liée au déroulement des
événements dans le système. Elle permet de classer les événements à venir par ordre dans le

I.1) L'exemple: Simulation Discrète - SIMSCRIPT et GPSS 4

 Simulation Discrète - SIMSCRIPT et GPSS

temps dans l'event-schedule.

L'unité de temps doit être choisie en fonction des besoins de la simulation. Cela peut varier
de la minute à la nanno-seconde (réaction chimique...), ou encore le siècle (évolution de
rivières...).

En Simulation discrète, l'horloge de simulation est indépendante du temps réel de calcul de

l'ordinateur. On peut simuler des événements se déroulant dans un période de dix ans en
quelques secondes de calcul sur l'ordinateur. En fait l'horloge avance par bonds irréguliers,
en fonction de l'event schedule, dans le quels les événements sont rangés par date de
réalisation.

N° UtilisateurHeure d'arrivéeDurée de l'appelTemps d'attenteDurée dans le

systèmeHeure de l'appelHeure de départFile
d'attente1030303022415371361127814102021012051111212131

Figure 3 : Exemple de changements d'états du système.

Numéro événementHeure de l'événementActivité programmée10Arrivée de l'utilisateur

n°122Arrivée de l'utilisateur n°233Départ de l'utilisateur n°146Arrivée de l'utilisateur
n°357Départ de l'utilisateur n°268Départ de l'utilisateur n°3710Arrivée de l'utilisateur
n°4811Arrivée de l'utilisateur n°5912Départ de l'utilisateur n°41013Départ de l'utilisateur n°5

Fig 4 : Exemple d'" event schedule "

I.4) Arrivées dans le Système

Dans l'exemple de la cabine téléphonique, tous les changements d'états sont provoqués par
les arrivées. Dès qu'un usager arrive on peut prévoir son départ en fonction de l'état présent
du système et la distribution des durées d'appel des autres usagers déjà présents dans le
système.

Par exemple, nous pouvons étudier le cas du premier usager, à la première ligne de la figure
3. Son arrivée est programmée pour l'heure 0, et son appel doit durer 3 minutes. La cabine
est libre lors de son arrivée, donc il n'a pas à faire la queue. Comme il n'y a pas de file
d'attente, sa durée totale dans le système sera de 3 minutes.

L'arrivée du deuxième usager est prévue à l'heure de simulation 2, ceci pour effectuer un
appel de 4 minutes. Mais l'usager n°1 ne laissera la cabine qu'à l'heure 3. Celle-ci est donc

I.3) Le Temps en Simulation

Simulation
Discrète.
Discrète - SIMSCRIPT et GPSS 5
 Simulation Discrète - SIMSCRIPT et GPSS

occupée lors de l'arrivée du n°2 qui doit alors faire la queue pendant 1 minute. Son temps
total dans le système sera donc de 5 minutes. On peut dès maintenant prévoir son départ
pour l'heure 7.

En d'autres termes on peut déterminer tout le programme des événements, en connaissant

uniquement les heures d'arrivées des usagers et la durée de leur appel. Les seuls
événements, dans notre exemple, sont les arrivées et les départs. L'entrée et la sortie dans la
file d'attente, ainsi que l'appel téléphonique, peuvent être vu comme des événements
associés aux arrivées ou au départ. C'est pourquoi le programme général des événements
peut être établi dès le départ, dans les colonnes 2 et 7 du tableau (fig.3).

En général, les heures des arrivées sont calculées grâce à des règles. Par exemple, une
distribution empirique peut être utilisée pour la génération des arrivées. Dans la plupart des
cas, des distributions uniformes ou normales des arrivées rendent bien compte des
phénomènes observés dans la réalité.

Dès que la distribution est connue, il est possible de programmer les arrivées. A ce stade
deux méthodes sont généralement utilisées:

• La plus simple est d'enregistrer (dans une table, par exemple) toutes les dates
d'arrivée, avant le début de la simulation. Ces arrivées peuvent être rangées selon
leur heure de réalisation, chaque événement " arrivée " se produira lorsque l'horloge
de simulation arrivera à la date prévue.
• L'autre méthode, qui est la plus utilisée et la plus économe du point de vue du
stockage de l'information, consiste à programmer les arrivées à au fur et à mesure
que les événements se produisent. Ce n'est qu'à la date de l'arrivée du n°2 que l'on
prévoit celle du n°3. Avec cette méthode, seuls les événements dans un futur immédiat
sont programmés dans le " schedule-event ".

I.5) Files d'attentes.

Lorsque plusieurs entitésutilisent les mêmes ressources, un certain nombre de conventions

doivent être prises. Par exemple dans notre cas nous pouvons remarquer que parmi les cinq
premiers usagers voulant téléphoner, trois d'entre eux devront attendre que le précédent ait
terminé son appel. Si les intervalles de temps entre les arrivées étaient plus courts, la file
d'attente pourrait rapidement s'allonger. L'étude des files d'attentes ou" queues " et de
leurs effets est un des principaux objectifs d'un système de simulation.

I.4) Arrivées dans le Simulation

Système Discrète - SIMSCRIPT et GPSS 6
 Simulation Discrète - SIMSCRIPT et GPSS

Les files d'attentes sont en fait des Listes. Elles sont caractérisées par la manière dont les
entités y circulent. Les types de liste les plus utilisés sont :

1. FIFO (First in, First out) : Les entités y sortent dans l'ordre dans lequel elles sont
rentrées. Ce sont les files classiques, ce sont elles qui sont le plus utilisées en
simulation. C'est le cas de notre exemple de cabines téléphoniques. C'est aussi le cas
entre autres des voitures faisant la queue à une station service. (Figure 5)
2. LIFO (Last in, First out) : La dernière entité rentrée dans la liste est la première
servie. Ce ont les piles. Ce type de liste est utilisé pour le stockage de matériel en
" pile ". Des voitures embarquées sur un Ferry-boat -n'ayant qu'une rampe de
chargement/déchargement- illustrent ce type de piles: La dernière voiture embarquée
sera la première à débarquer.
3. RANDOM : Chaque entité du " tas " a une même probabilité d'être servie en
premier, indépendamment de leur date d'arrivée ou leur ordre dans la liste. C'est
l'exemple d'un tiragealéatoire des boules au LOTO en imaginant qu'elles sont
rentrées dans l'ordre de leur numéro. (Figure 7)
4. RANKED : Les entités y sont ordonnées suivant la valeur d'un attribut qui leur est
associé. Cet attribut correspond à leur priorité. Il existe divers types de rangement,
par exemple un rangement alphabétique (résultat d'examens, visite médicale...), ou
un rangement suivant l'age, le sexe... Quand deux entités ont la même priorité c'est
généralement la première arrivée qui est la première servie. (Type FIFO par défaut).

Figure 5 : Liste FIFO

I.5) Files d'attentes. Simulation Discrète - SIMSCRIPT et GPSS 7

 Simulation Discrète - SIMSCRIPT et GPSS

Figure 6 : Liste LIFO

Figure 7 : Liste RANDOM

Figure 8 : Liste RANKED

I.6) Listes Chaînées

Pour modéliser une file d'attente dans un programme de simulation, nous devons créer des

I.5) Files d'attentes. Simulation Discrète - SIMSCRIPT et GPSS 8

 Simulation Discrète - SIMSCRIPT et GPSS

relations entre les différents membres de cette file. Uneliste chaînée est une liste dont chaque
élément est associé à un ou plusieurs pointeurs sur les éléments suivants de cette liste,
comme le montre la figure 9.

Fig. 9 : Listes chaînées

Dans une liste chaînée, chaque élément possède au moins un attribut pointeur. Le pointeur
Suiv indique pour chaque élément l'adresse de l'élément suivant. Le pointeurPréc,
(indispensable),indique pour chaque élément, l'adresse de l'élément précédent. Enfin, le
pointeur Début (indispensable) permet d'accéder au premier élément de la liste et le pointeur
Fin, permet d'atteindre le dernier élément de la liste.

Uneliste simplement chaînée (Fig 9) est bien adaptée dans le cas d'une file d'attente de type
FIFO. La dernière entité à rentrer dans la file, ira se placer en queue; Avec le pointeur Fin
on accède au dernier élément, on attribue une nouvelle valeur disponible pour son pointeur
Suiv qui correspond à l'adresse du nouvel élément. Enfin on change la valeur du pointeur
Fin par l'adresse du nouvel élément pour pouvoir y accéder lors de l'arrivée du suivant sans
être obligé de reparcourir toute la file. Le pointeur Suiv du dernier élément lui reste à zéro,

I.6) Listes Chaînées Simulation Discrète - SIMSCRIPT et GPSS 9

 Simulation Discrète - SIMSCRIPT et GPSS

pour indiquer que c'est le dernier.

Pour les files LIFO, le même principe est utilisé, mais le nouvel élément est inséré en tête
de liste, pointé par Début, et avec un pointeur Suiv sur l'ancienne tête de file.

Notons que cette procédure de mise à jour des pointeurs peut très bien être utilisée pour
supprimer ou insérer un élément en milieu de la file. Par exemple les événements peuvent
être rangés dans la file suivant leur date de réalisation. Ainsi quand un nouvel élément est
prévu, il doit être inséré dans la file, après avoir trouvé sa position relative. Dans un tel
système l'événement pointé par début est toujours le prochain événement qui se réalisera,
lors de l'incrémentation du temps.

Les listes chaînées multiples simplifient la simulation de problèmes plus complexes, mais
elles prennent un peu plus de place en mémoire, à cause des nouveaux pointeurs (fig 10).
Avec ce type de liste beaucoup de pointeurs peuvent être associés à un seul élément. Les
listes doublement chaînées (figure 9) sont particulièrement pratiques, elles permettent de
modéliser des files FIFO ou LIFO, et sont très utilisées pour les listes RANKED ou
RANDOM. En effet un élément peut être atteint en partant de n'importe quel autre élément
de la file.

Les pointeurs peuvent aussi être utilisés pour relier certains éléments qui possèdent un
même attribut. Par exemple les éléments d'une liste chaînée peuvent avoir un attribut
" couleur ". Un pointeur coul permettrai ainsi de relier tous les éléments d'une même
couleur. On pourrait ainsi parcourir tous les éléments d'une même couleur sans passer par
tous les éléments de la liste globale. Il suffit de connaître le premier élément de cette couleur
qui peut être désigné par le pointeur " Premier vert " par exemple.

Un élément peut très bien appartenir à plusieurs liste à la fois. Il suffit qu'il possède autant
de pointeurs qu'il y a de liste (ex. figure 10). On remarque que pour un élément qui
n'appartient pas à une liste, les pointeurs prec et suiv correspondant à la liste 1,2, ou 3,
seront à zéro. Ceci est à ne pas confondre avec les extrémités de la file qui possèdent aussi
un pointeur à zéro.

I.6) Listes Chaînées Simulation Discrète - SIMSCRIPT et GPSS 10

 Simulation Discrète - SIMSCRIPT et GPSS

Figure 10 Liste chaînéemultiple

Les procédés de listes chaînées posent certains problèmes de stockage. Les listes étant
" extensibles ", la procédure d'élimination d'un élément doit être étudiée minutieusement.
Par exemple lors de la suppression de l'élément n°2 dans la liste chaînée de la figure 9, une
fois que les pointeurs des deux éléments précédent et suivant sont mis à jour, il n'y a plus
aucun moyen d'atteindre l'élément n°2: la liste court-circuite cet élément. Pourtant la place
de cet élément qui était réservé en mémoire, n'a pas été libérée. Il faut bien faire attention à
libérer cette espace. Heureusement des langages comme GPSS, PL/I, et SIMSCRIPT
s'occupe de cette libération automatiquement, ce qui n'est pas le cas de beaucoup d'autre
langages (en particulier les langages assemblés).

II SIMSCRIPT

II SIMSCRIPT Simulation Discrète - SIMSCRIPT et GPSS 11

 Simulation Discrète - SIMSCRIPT et GPSS

II.1) Concepts de base.

SIMSCRIPT est un langage de simulation discrète qui dérive du FORTRAN. Il existe

plusieurs versions de ce langage, mais nous nous attacherons plus particulièrement au
SIMCRIPT 1.5.

Les concepts de bases de SIMSCRIPT sont sensiblement les mêmes que ceux évoqués dans
le chapitre précédent. Il existe des entités auxquelles il est possible d'associer desattributs. Il
est possible de simuler différentes interactions entre les entités, telles que des files d'attente.
Les activités sont définies par des subroutines (FORTRAN), que l'on appellera des routines
d'événements.

Tous ces concepts existaient déjà avec le FORTRAN, ou le PL/I, mais SIMSCRIPT offre, en
plus des possibilités du FORTRAN, de nombreux avantages dédiés à la simulation discrète.
Par exemple le mécanisme d'horloge pour le programme des événements est automatique.
De même l'utilisation des différents types de files d'attente est beaucoup simplifiée, la
gestion des pointeurs étant transparente pour l'utilisateur.

Un programme de simulation SIMSCRIPT comporte cinq parties principales:

1. Section de définitions
2. Déclaration des routines événements
3. Routines d'événements
4. Partie d'initialisation
5. Listeévénements exogènes

1- Dans la partie de définitions les entités, attributs, et les autres variables du système sont
définies, cela correspond aux déclarations des variables dans un langage comme le
PASCAL. La figure 11 montre un exemple de code de la section de définition. SIMSCRIPT
différencie deux types d'entités: les entités permanentes, et les entitéstemporaires.

figure 11 :Partie Définition d'un programme SIMSCRIPT

Les entités temporaires représentent des éléments qui seront créés et détruits de nombreuses
fois pendant la simulation. Le code T dans la deuxième colonne du programme (fig. 11)
signifie que MAN est une entité temporaire.Cette entité peut représenter un usager qui entre
dans le système pour téléphoner, après être sorti de la cabine téléphonique, il est éliminé du
système. Plusieurs attributs sont associés à cette entité: TIBTH, TTOQ, SQUE, STEL. Ces
attributs sont porteurs d'information, par exemple TIBTH correspond au temps total
d'utilisation de la cabine.

II.1) Concepts de base.

Simulation Discrète - SIMSCRIPT et GPSS 12
 Simulation Discrète - SIMSCRIPT et GPSS

Les entités permanentes sont utilisées pour définir des entités, variables, pointeurs, tableaux
qui sont les caractéristiques permanentes du modèle global, et peuvent être référencées tout
au long de la simulation. Comme leur nom l'indique, ces entités ne peuvent être détruites.
De telles variables peuvent servir à transférer de l'information d'une partie à l'autre du
modèle, supporter de l'information concernant tout le modèle, ou définir les attributs du
système global. Par exemple la variable permanente FNUSE, peut correspondre au nombre
d'entités MAN qui sont entré dans la cabine téléphonique.

Les files d'attentes sont aussi définies dans cette section. Par exemple QUE et TEL sont
deux files FIFO (codées par F dans la colonne 57 sur la figure 11). Les entités temporaires
qui doivent rentrer dans des files d'attentes doivent avoir comme attributs des pointeurs qui
permettront de les chaîner entre elles dans ces files. MAN possède deux attributs SQUE et
STEL qui pointent sur les entités suivantes dans chacune des queues. Ces files doivent aussi
avoir des pointeurs début (FQUE et FTEL) et fin (LQUE, LTEL) qui sont des variables
permanentes.

2- La liste des routines d'événements correspond aux déclarations de ces routines. Il existe
deux types de routines d'événements en SIMSCRIPT, les routines exogènes et les routines
endogènes.

Comme leur nom l'indique les routines endogènes ne peuvent être utilisées qu'à l'intérieur
du système de simulation contrairement aux routines exogènes.

EVENTS1 EXOGENOUSCRNKUP (1)2 ENDOGENOUSARVELEAVEND

Figure 12 : Liste des événements

3-. Les routines d'événements sont des listes d'instructions exécutables

(simili-FORTRAN) qui décrivent les activités modifiant l'état du système.
L'implémentation d'une routine se fait de la manière suivante :
[ ENDOGENOUS | EXOGENOUS ] EVENT <nom de routine><Liste d'instructions
exécutables>RETURNEND

4- Section d'initialisation.

Figure 13 Section d'initialisation d'un programme SIMSCRIPT

En SIMSCRIPT, les variables permanentes doivent être initialisées avant le début de la

simulation. C'est le rôle de cette partie. La figure 13 nous montre un exemple
d'implémentation de cette section. On peut remarquer qu'il y a deux options, pour cette
initialisation. La première consiste à mettre à zéro les variables. En ligne 1 , les variables 1 à
4 (FQUE, LQUE, FTEL, LTEL) sont mises à zéro grâce au " Z " en colonne 13.

II.1) Concepts de base.

Simulation Discrète - SIMSCRIPT et GPSS 13
 Simulation Discrète - SIMSCRIPT et GPSS

La deuxième option consiste à les affecter individuellement par une valeur (en colonne
65-67), et en plaçant un " R " dans la colonne 12. (LOWT, HIT, LOWC, HIC). Dès le début
de la simulation ces variables seront ainsi affectées.

5- Liste des événements exogènes. C'est la dernière partie du programme. Elle consiste à
enregistrer chaque événement en correspondance avec la routine d'événements exogènes
associée (grâce à un numéro d'identification), ainsi que l'heure à laquelle la routine doit être
exécutée. En SIMSCRIPT I.5, une seule routine d'événement exogène est nécessaire, pour
lancer la simulation.

Le Mécanisme d'horloge en SIMSCRIPT suit la logique présentée au premier chapitre.

Lors de la création d'événements endogènes, au cours de la simulation, chaque événement
possède un attribut date, qui indique le moment relatif de l'exécution de la routine associée.
Cet événement est alors inséré dans la liste des événements qui contient aussi tous les
événements exogènes. Tous ces événements sont classés par ordre chronologique, dans la
file d'attente.

L'algorithme de contrôle procède de la manière suivante :

1. Examen du premier événement dans le programme des événements (event-schedule).

2. Mise à jour de l'horloge, à l'heure de l'événement, et lancement de la routine
associée à cet événement.
3. Quand la routine est terminée, l'algorithme principal reprend la main et examine le
prochain événement.

Notons qu'une routine peut tout à fait prévoir de nouveaux événements endogènes pour la
suite, et les insérer ainsi dans l'event-schedule. Cette liste des événements est constamment
remise à jour. Après l'exécution d'une routine, le premier événement est éliminé, et de
nouveaux apparaissent au fur et à mesure. La mise à jour de la file est automatique.

II. 2) Eléments de Langage en SIMSCRIPT

SIMSCRIPT est très similaire au FORTRAN. La plus grande ressemblance est la syntaxe
utilisée pour la liste des instructions exécutables des routines d'événements. Nous allons ici
commenter ces instructions, en soulignant leurs spécificités et leur utilisation en simulation.
La table (figure 14) fait l'inventaire des instructions les plus utilisées en simulation.

Les instructions de SIMSCRIPT sont codées sur des cases, exactement comme FORTRAN.

II.1) Concepts de base.

Simulation Discrète - SIMSCRIPT et GPSS 14
 Simulation Discrète - SIMSCRIPT et GPSS

Le corps des instructions est codé entre les colonnes 7 et 72. Les colonnes 2 à 5 sont
réservées pour les labels, et les colonnes 73 à 80 sont ignorées par le compilateur. Comme
en FORTRAN la lettre C apparaît dans une case pour indiquer que ce qui suit est un
commentaire.

Les instructions SIMSCRIPT peuvent être réparties en 7 classifications majeures. Dans la

classe des opérations sur les entités, on retrouve les instructions CREATE et DESTROY.
L'instruction CREATE est utilisée pour allouer de l'espace pour une nouvelle entité. Par
exemple l'instruction

CREATE MAN

réservera de la place en mémoire pour une entité de type MAN (définie dans la figure 11).
Sans ce système d'allocation dynamique, une simulation SIMSCRIPT occuperait
énormément de mémoire. L'instruction DESTROY est nécessaire pour libérer l'espace
réservé pour l'entité temporaire. Par exemple l'instruction.

DESTROY MAN

libérera l'espace alloué à l'entité MAN crée ci-dessus.

Opérations sur les entités :

CREATE <entité temporaire> [ CALLED <local variable> ]
DESTROY <entité temporaire> [ CALLED <local variable> ]
CAUSE <événement> [ CALLED <local variable>] [ AT <expression> ]
CANCEL <événement> [ CALLED <local variable>]
FILE <variable pointeur> IN <file d'attente>
REMOVE <variable pointeur> FROM <file Ranked>
REMOVE FIRST <variable pointeur> FROM <file d'attente>
Instructions arithmétiques :
LET <variable> = <expression> [, <phrase de contrôle> ]
Phrases de contrôle :
FOR <variable> = <expression> <expression> [ <expression> ]
FOR EACH <entités>
FOR EACH <variable> IN <liste ou file d'attente>
WITH <expression> <code de comparaison> <expression>
OR <expression> <code de comparaison> <expression>
AND <expression> <code de comparaison> <expression>
Instructions d'itération :
DO [TO <label>] , <phrase de contrôle> [,phrase de contrôle]
Instructions de décision :
IF <expression> <code de comparaison> <expression>,<lie>
IF <file ou liste> [ IS | IS NOT ] EMPTY , <lie>
FIND <variable> = [ MAX | MIN ] OF <expression>,<phrase de contrôle> [ WHERE <variable pointeur>] [ , IF NONE
<lie> ]
Instructionsparticulières :
ACCUMULATE <liste> = <liste> SINCE <liste horaire> [, [ POST | ADD ] phrases ]
COMPUTE <variable> = <liste statistique> OF <expression>
Instructions d'Entrée-Sortie

II. 2) Eléments de Langage

Simulation
en SIMSCRIPT
Discrète - SIMSCRIPT et GPSS 15
 Simulation Discrète - SIMSCRIPT et GPSS

SAVE [ <test optionnel> ]

READ FROM [TAPE] <expression>, <liste>
WRITE ON [TAPE] <expression>, <liste>
Figure 14 : Table des instructions le plus utilisées en Simulation en SIMSCRIPT

Quand il est nécessaire de créer deux entités MAN en même temps dans le système, il faut
utiliser une variable locale, pour pouvoir les différencier. Une variable locale n'est connue
du système qu'à l'intérieur de la routine d'événement à l'intérieur de laquelle elle a été
créee. Par exemple les instructions,

CREATE MAN CALLED JERRY

CREATE MAN CALLED LARRY

définissent deux variables locales JERRY et LARRY. De ce fait il est possible de distinguer
les attributs de ces deux entités MAN coexistant dans le système. TIBTH(JERRY)
représentera la longueur de l'appel téléphonique de JERRY. Dans ce cas, l'instruction
DESTROY devra préciser quelle entité MAN doit être détruite. L'instruction

DESTROY MAN CALLED JERRY

libérera l'espace accordé à JERRY dans le système.

Les routines d'événements contiennent souvent une séquence d'instructions qui crée et place
dans l'event-schedule un événement endogène. Comme un événement endogène est un type
d'entité temporaire, la création d'un événement est réalisée avec une instruction CREATE.
Par exemple, L'instruction

CREATE ARVE

crée un événement nommé ARVE. Le nom utilisé pour l'événement doit aussi être le nom
d'une routine d'événement endogène, défini dans la section des routines d'événements.
Quand cet événement arrivera en premier dans la liste des événements, c'est la routine
associée qui sera exécutée. L'instruction CAUSE permet de placer des événements dans
l'event-schedule:

CAUSE ARVE AT TIME + 12.5

La fonction TIME étant automatiquement définie dans le système, l'événement sera inséré
dans la liste avec un attribut de temps de 12,5 unités de temps dans le futur. L'exécution de
la routine d'événement se réalisera donc à cette date.

Des événements " arrivée ", placés dans la queue, peuvent en sortir avant leur exécution
avec une instruction CANCEL. Par exemple si la queue devant la cabine téléphonique est

II. 2) Eléments de Langage

Simulation
en SIMSCRIPT
Discrète - SIMSCRIPT et GPSS 16
 Simulation Discrète - SIMSCRIPT et GPSS

estimée trop longue on peut en faire sortir des individus grâce à l'instruction :

CANCEL ARVE

Cette instruction n'a pas pour autant détruit l'événement. Celui-ci est toujours en mémoire,
et il ne faudra pas oublier de libérer la place qu'il occupe, avec un DESTROY.

Différentes instructions sont autorisées pour la gestion de files d'attente. L'instruction

FILE permet de faire rentrer une entité temporaire dans une file. Par exemple, la suite
d'instructions

CREATE MAN CALLED LARRY

FILE LARRY IN QUE

créera une entité temporaire LARRY et la placera dans la file QUE. Si QUE a été définie
comme une file RANKED, l'entité spécifique pourra être classée au moyen de
l'instruction:

REMOVE LARRY FROM QUE

Ce moyen spécifique de classement de files est autorisé car SIMSCRIPT utilise des listes
doublement chaînées (Figure 9). Pour les files FIFO et LIFO, qui sont simplement chaînées,
les seules instructions utilisées sont :

CREATE MAN

------

------

FILE MAN IN QUE

------

------

REMOVE FIRST MAN FROM QUE

Si la file QUE est une FIFO, MAN sera placé en queue de QUE par l'instruction FILE,
tandis que si c'est une LIFO, FILE aura pour effet de placer MAN en tête de QUE.
L'instruction REMOVEFIRST prend toujours l'entité qui est en tête de la file.

II. 2) Eléments de Langage

Simulation
en SIMSCRIPT
Discrète - SIMSCRIPT et GPSS 17
 Simulation Discrète - SIMSCRIPT et GPSS

L'instruction IF est particulièrement intéressante pour prendre des décisions au sujet des
files d'attentes. En effet il est possible de tester si une file est vide ou ne l'est pas:

6 IF QUE IS EMPTY, GO TO 7

REMOVE FIRST MAN FROM QUE

GO TO 1000

7 ------

Avec ces instructions le REMOVE sera court-circuité dans le cas d'une file d'attente vide.

Les instructions arithmétiques sont destinées à augmenter les capacités de FORTRAN.

L'instruction LET en SIMSCRIPT correspond à une affectation. Par exemple à exécution de
l'instruction

LET IX(3)=Y+1.5*Z

L'expression à droite du signe égal est évaluée, et cette valeur est placée en IX(3), avec la
conversion de Flottant en Entier si nécessaire.

Les instructions ACCUMULATE et COMPUTE sont très utiles pour effectuer des
statistiques. ACCUMULATE est généralement utilisé pour accumuler des totaux dans le
temps. Par exemple, le temps cumulé d'une file QUE peut être évaluée lors de l'exécution
des instructions

ACCUMULATE FNQUE INTO CUMQ SINCE TLAST.

Ici TLAST et l'heure du dernier changement de taille de la file, et FNQUE est le nombre
d'éléments de la file. L'instruction doit être placée à chaque fois que l'on modifie la file.
Cette instruction se résume à

CUMQ=CUMQ+FNQUE*(TIME-TLAST)

TLAST=TIME

L'instruction COMPUTE provoque exécution du calcul des statistiques. Par exemple pour
calculer la moyenne XMEAN et l'écart type XSTD des K premiers éléments du tableau X,
on peut utiliser les instructions suivantes:

COMPUTE XMEAN,XSTD = MEAN,STD-DEV OF X(I) FOR I=(1)(K)

L'exemple précédent montre aussi l'utilisation d'une phrase de contrôle. L'existence de ces

II. 2) Eléments de Langage

Simulation
en SIMSCRIPT
Discrète - SIMSCRIPT et GPSS 18
 Simulation Discrète - SIMSCRIPT et GPSS

phrases de contrôles était, en effet une des raisons principales de la supériorité de

SIMSCRIPT, sur le FORTRAN (à l'époque). On peut par exemple exécuter l'instruction:

LET X(I) = Z(I) * Y(I) FOR I = (1) (K*J) WITH (Z(I)) LT (6.3)

correspondant en FORTRAN à la suite d'instructions:

M=K*J

DO 1 I=1,M

1 IF (Z(I).LT.6.3), X(I)=Z(I)*Y(I)

Un autre exemple d'instructions SIMSCRIPT :

LET TOTME = TOTME + TIME - TTOQ ( JOE ), FOR EACH JOE IN QUE

accumulera la somme des délais des entités de la file d'attente QUE.

Les boucles en SIMSCRIPT sont assez simples d'utilisations, comme le montre l'exemple
suivant:

DO TO 13, FOR I=(1) (20)

CREATE MAN CALLED NEXT

FILE NEXT IN QUE

13 LOOP

Dans cet exemple, 20 entités MAN ont été crées et sont entré dans la file d'attente QUE.

Il existe en SIMSCRIPT encore une autre extension du FORTRAN, avec l'instruction

FIND. Par exemple, l'instruction

FIND GR8TST = MAX OF X(I), FOR I=(1) (20)

affectera GR8TST avec la valeur maximale des 20 premiers éléments du tableau X.

II.3) Un exemple de Programme SIMSCRIPT

II. 2) Eléments de Langage

Simulation
en SIMSCRIPT
Discrète - SIMSCRIPT et GPSS 19
 Simulation Discrète - SIMSCRIPT et GPSS

Dans cette partie, nous allons réaliser un programme complet SIMSCRIPT, pour la
simulation de l'utilisation de la cabine téléphonique, dont nous avions déjà exposé le
problème au début de cette étude.

Le problème étant assez simple, il est possible de le représenter sous la forme d'un
organigramme (figure 15). Ce programme contient trois routines d'événement, la routine
exogène CRNKUP, et les deux routines endogènes ARVE et LEAV.

En SIMSCRIPT I.V, un événement exogène est nécessaire pour faire démarrer l'algorithme
de simulation, car aucun événement endogène ne peut être placé dans la liste des
événements avant qu'une routine ne soit exécutée. Dans notre exemple c'est la routine
d'événement exogène CRNKUP qui sert de " starter " pour le modèle. Dès que la routine
CRNKUP est lancée, l'entité temporaire MAN est crée, et des attributs lui sont affectés.
TTOQ, qui sera plus tard utilisé pour le calcul du temps total en minutes de la durée
d'attente du MAN dans la file d'attente, est pour l'instant initialisé à zéro grâce à l'instruction

LET TTOQ(MAN)=TIME

L'attribut TIBTH est utilisé pour stoker la durée de l'appel du MAN. Ce temps est calculé
grâce à un générateur de nombres aléatoires (RANDI) dans un intervalle uniforme
[LOWT,HIT]. La valeur du nombre aléatoire est divisée par 1 440 (nombre de minutes dans
un jour), car l'unité de temps en SIMSCRIPT est le jour. La première entité MAN accédera
directement à la cabine, car il est le seul dans le système. Cependant, son départ peut être
prévu, pour TIBTH(MAN) jours dans le futur, grâce aux instructions

CREATE LEAV

CAUSE LEAV AT TIME + TIBTH(MAN)

MAN sera alors placé dans la liste TEL, qui représente la cabine téléphonique. Cette liste ne
contient qu'une seule entité à la fois, et la variable permanente du système
FNUSE comptabilisera le nombre d'entités qui seront passé par la cabine. Dès lors que
MAN est placé dans TEL, l'événement endogène ARVE est prévu, afin de créer la prochaine
arrivée. L'événement est évidemment en tête de liste puisqu'il est le seul, pour l'instant.
C'est donc lui qui sera exécuté lorsque le programme de contrôle reprendra la main, après que
l'instruction RETURN, a été rencontrée.

II.3) Un exemple de Programme

Simulation Discrète
SIMSCRIPT
- SIMSCRIPT et GPSS 20
 Simulation Discrète - SIMSCRIPT et GPSS

Figure 15 : Organigramme du programme de Simulation des cabines téléphoniques en SIMSCRIPT

Figure 16 : Programme SIMSCRIPT: Simulation de la cabine Téléphonique

La routine d'événement CRNKUP ne sera plus jamais exécutée, durant toute la simulation,
car aucun autre événement exogène n'est prévu dans le modèle.

A chaque fois qu'une instruction RETURN est rencontrée, l'algorithme général recherche le
prochain événement, et il lance la routine qui lui est associée. Cet événement c'est celui qui
est en tête de la liste des événements, dans l'event-schedule. Si c'est un ARVE, l'horloge
est mise à l'heure de cet événement, et la routine ARVE est exécutée. Cette routine a quatre

II.3) Un exemple de Programme

Simulation Discrète
SIMSCRIPT
- SIMSCRIPT et GPSS 21
 Simulation Discrète - SIMSCRIPT et GPSS

buts:

1. Détruire l'événement ARVE.

2. Réinitialiser le système si la cabine est vide.
3. Créer l'arrivée suivante et la placer dans la file des événements à venir.
4. Rendre la main.

Si l'algorithme global trouve un LEAV comme prochain événement, il met à jour l'horloge,
puis exécute la routine LEAV. Celle-ci a cinq buts:

1. Détruire l'événement LEAV, dont on n'a plus besoin.

2. Prévoir le départ de l'entité MAN se servant du téléphone.
3. Placer l'entité MAN suivante de la queue dans la cabine.
4. Terminer la simulation et effectuer les statistiques, si 1 000 usagers sont passée dans
la cabine.
5. Rendre la main.

Ce programme produit trois résumés statistiques, à la fin de la simulation:

1. L'utilisation de TEL (CTEL/TIME).

2. La taille moyenne de la queue QUE (CUMQ/TIME)
3. Le temps moyen d'un usager MAN dans la queue QUE (CINT/FNUSE).

III GPSS

III.1) Concepts de bases de GPSS

Le Général Purpose Simulation Système, ou GPSS, est un de plus vieux systèmes de

simulation discrète. C'est aussi celui qui a sans doute été le plus largement utilisé. De la
même façon que SIMSCRIPT, il existe de nombreuses versions de GPSS.

Le seul but de GPSS est de faire de la simulation. Il a été conçu avec le principe que tous les
systèmes peuvent être simulés correctement, avec uniquement quelques types d'entités:

III GPSS Simulation Discrète - SIMSCRIPT et GPSS 22

 Simulation Discrète - SIMSCRIPT et GPSS

Des entités dynamiques, des entités d'équipement, des entités statistiques, et des entités
opérationnelles.

Les entités dynamiques de GPSS sont appelées des transactions. Les transactions sont
créées et détruites en cours de simulation, à l'image des entités temporaires de SIMSCRIPT.
Par exemple, les utilisateurs de la cabine téléphonique, dans notre exemple déjà étudié, se
résumeraient à des transactions en GPSS. Les activités résultent de l'interaction des
transactions avec les autres entités; Lors du passage de transactions dans le système, Les
attributs de transactions sont définis grâce à des listes de paramètres associées à chaque
transaction.

Les entités d'équipement sont utilisées pour modéliser les équipements utilisés pour les
transactions (Téléphones, photocopieuses,...). Les facilities, par exemple, correspondent à un
équipement qui ne sert qu'à un utilisateur à la fois. S'il n'y a qu'un téléphone, on peut le
modéliser grâce au concept de facilities. Mais GPSS autorise l'utilisation multiple d'un
même équipement. Celui-ci est alors appelé storage. Dans notre cas par exemple il pourrait
y avoir une cabine avec trois téléphones, GPSS est capable de les gérer comme une seule
entité storage.

De plus, GPSS dresse automatiquement des statistiques sur l'utilisation des équipements, les
contenances moyennes des files d'attentes, les entrées et les sorties... Les résultats finaux
sont délivrés automatiquement en fin de simulation, ce qui simplifie beaucoup le travail de
synthèse des résultats et allège l'implémentation. Les informations statistiques sont traitées
comme des attributs des différentes entités, et on peut y avoir accès à n'importe quel
moment du programme. Il est ainsi possible d'afficher au fur et à mesure les informations
statistiques, sans interrompre la simulation.

GPSS propose de nombreuses entités statistiques pour analyser la simulation, Les " Queues
entities " et les " chain entitie " sont utilisées pour simuler et mesurer les rapports
d'utilisation entres les différentes entités d'équipement. Les " chain entities " ou entités
chaînées sont aussi utilisées pour modéliser des files d'attentes complexes. Les différentes
fréquences de distributions sont collectées dans des tables, au cours du processus de
simulation.

Les entités opérationnelles de GPSS sont appelées des blocks. Ils correspondent à des
instructions. En GPSS, les blocks déterminent la logique du système, en contrôlant les
interactions des transactions. Par exemple, certains blocks contrôlent l'utilisation des
équipements par les transactions. D'autres blocks affectent les paramètres (ou attributs) des
transactions. Certains contrôlent les sorties... Il existe une quarantaine de blocks différents en
GPSS. L'essence de GPSS réside en les actions résultant de l'interaction des blocks et des
transactions.

III.1) Concepts de bases

Simulation
de GPSSDiscrète - SIMSCRIPT et GPSS 23
 Simulation Discrète - SIMSCRIPT et GPSS

GPSS contrôle automatiquement le flux des transactions, d'un block à l'autre. Le programme
de contrôle sait en permanence quelle est la prochaine transaction qui doit se produire, dans
un block, et le temps qu'elle prendra, grâce au système d'horloge qui range les événements
par ordre chronologique. Les transactions sont généralement stockées dans des files du type
" premier entré - premier servi " = FIFO.

Quand une opération prévue ne peut être effectuée, par exemple quand il n'y a pas
d'équipement disponible, le programme de contrôle place la transaction en attente, dans un
état d'inactivité temporaire. Une recherche est alors effectuée pour trouver la transaction
suivante. L'horloge est alors mise à jour puis la transaction est effectuée. Généralement le la
simulation s'arrête après un nombre déterminé de transactions.

Les attributs et les entités sont très utilisés en GPSS. Il est possible de définir des entités
" fonctions " pour définir des distributions empiriques complexes, ou des distributions
uniformes. GPSS met de plus à notre disposition huit générateurs de nombres aléatoires.

III.2) Elément de langage de GPSS

A l'image de SIMSCRIPT, GPSS est codé avec un système de grille. Une instruction (ou
block) de GPSS s'étale sur 80 colonnes. Les colonnes de 8 à 18 contiennent les mots clefs. A
partir de la colonne 19, ce sont les opérandes de spécification des blocks. Les commentaires
peuvent être insérés à la fin de chaque blocks, après la dernière opérande.

La création et la destruction d'une transaction sont contrôlés par les instructions

GENERATE et TERMINATE. La fonction TERMINATE détruit une transaction. Elle est
aussi utilisée pour mettre fin à la simulation, quand il n'y a plus de transaction. L'instruction

TERMINATE 1

détruira la transaction qui sera présente dans ce block. A chaque instruction de ce type, une
transaction est éliminée du block. Quand il n'y a plus aucune transaction, la simulation est
terminée.

La création de transaction se fait à l'aide de l'instruction GENERATE. Les opérandes

servent à spécifier l'intervalle de temps des générations de transactions. Par exemple
l'instruction

GENERATE 22,12

créera des transactions tout les x unités de temps, avec x = 22 +/- 12, c'est à dire un nombre

III.1) Concepts de bases

Simulation
de GPSSDiscrète - SIMSCRIPT et GPSS 24
 Simulation Discrète - SIMSCRIPT et GPSS

aléatoire compris entre 10 et 34. Des distributions plus complexes sont possibles, grâce aux
fonctions.

La simulation de l'utilisation d'une entité équipement requiert généralement trois

instructions. Deux blocks sont utilisés pour identifier l'entité, qui est à libérer ou à utiliser, le
troisième est celui qui indique combien de temps l'équipement sera utilisé. C'est le block
AVANCE. Par exemple l'instruction

ADVANCE 15,5

indique que l'équipement sera utilisé pendant 15 plus ou moins 5 minutes. Les deux autres
blocks, correspondent au type d'utilisation de l'équipement. Les instructions SEIZE et
RELEASE sont utilisés dans le cas de facilities. Pour simuler l'utilisation d'une cabine
téléphonique simple pendant 10 à 20 minutes, on utilisera la syntaxe suivante:

SEIZE PHONE

ADVANCE 15,5

RELEASE PHONE

Lorsqu'une transaction entre dans le block SEIZE, la facilityPHONE passe de l'état vacant
à l'état occupé. Elle sera de nouveau vacante lors de l'exécution de l'instruction
RELEASEPHONE. Mais entre temps, la transaction est bloquée au niveau du block
ADVANCE, durant une période variant aléatoirement entre 10 et 20 minutes dans notre
exemple. ADVANCE correspond à l'utilisation de la facility.

Dans le cas d'un équipement multiple, qui a la capacité d'accueillir plusieurs utilisateurs en
même temps, on n'utilise plus les instructions SEIZE et RELEASE (dédiées aux
facilities), mais ENTER et LEAVE qui s'appliquent à des storages. Par exemple une cabine
avec trois téléphones sera modélisée par un storageTEL, dont l'attribut capacity aura la
valeur 3, La capacity étant le nombre maximum de transactions en même temps autorisées
dans le storage. Pour les storages comme pour les facilities des statistiques sont effectuées
automatiquement au cours de la simulation, lors de chaque passage d'une dans un des
block définis ci dessus.

Il est très courant au cours d'une simulation, que les facilities soient occupées, ou que le
storage soit plein. On a donc recours aux files d'attentes. Les instructions QUEUE et
DEPART sont destinées à faire rentrer et sortir des transactions dans une file d'attente de
type FIFO. Ces deux blocks sont généralement associés à des SEIZE ou ENTER. On peut
ainsi avoir la liste d'instruction,

QUEUE LINE

III.2) Elément de langage

Simulation
de GPSS
Discrète - SIMSCRIPT et GPSS 25
 Simulation Discrète - SIMSCRIPT et GPSS

SEIZE PHONE

DEPART LINE

Dans cet exemple, l'utilisateur est inséré dans la file d'attente dans tous les cas. Puis si
PHONE est disponible, il est éjecté de la file, après avoir réservé le téléphone.
PHONE repasse donc dans un état occupé. Si PHONE était occupé au départ, l'utilisateur
patiente dans la file d'attente jusqu'à son tour. Les statistiques sur la taille, les entrées et les
sorties des files d'attentes sont aussi automatiques. (moyenne, maxi, mini, temps cumulé...).

Les Tests en GPSS sont très utilisés, ils permettent entre autres, de contrôler les mouvements
de transactions, les tailles des files. Ils peuvent s'appliquer sur les attributs des files, ou
activity. Par exemple Q$LINE est un attribut de la queue LINE, correspondant à la taille de
cette file d'attente.

TEST L Q$LINE , 10 , AWAY

QUEUE LINE

Ces deux instructions autoriseront la rentrée dans la file d'attente, uniquement si celle-ci
contient moins de dix activités. ( L correspond à LESSTHAN ). Dans le cas contraire,
l'activité est envoyée au block portant le labelAWAY.

L'instruction TRANSFER est aussi utilisée pour contrôler le transfert d'éléments dans le
système:

TRANSFER 6,BLCK1,BLCK2

Cette instruction joue le rôle d'un répartiteur: dans 40 % des cas, l'activité sera transférée
dans le blockBLCK1, et dans 60 % elle sera transférée dans le blockBLOCK2.

Le but de la simulation est de valider les données statistiques qu'elle génère. La plupart de
ces données sont stockées dans des tables automatiquement, mais il est possible de fabriquer
ces tables à la demande, avec l'instruction TABULATE.

TABULATE XTME

Cette instruction provoquera l'entrée de l'activité dans la table XTME.

GPSS utilise des definition cards définir la plupart des entités utilisées dans la simulation.
Par exemple la table XTME, pour le temps de transit, peut être définie dans les definition
cards de la manière suivante:

III.2) Elément de langage

Simulation
de GPSS
Discrète - SIMSCRIPT et GPSS 26
 Simulation Discrète - SIMSCRIPT et GPSS

XTME TABLE M1,0,20,50

Cette définition impliquera le stockage des temps de transits (codés M1), dans une table
statistique, comprenant 50 intervalles, commençant à zéro, et allant jusqu'à 20. La
capacity de storage est aussi définie dans les definition cards, ainsi que les variables
numériques et les entités calculées comme les fonctions aléatoires.

En plus des definition cards, GPSS utilise des control cards, pour le contrôle externe, sur
toute la durée de la simulation. Par exemple, l'instruction START est utilisée en conjonction
avec le blockTERMINATE, pour délimiter la longueur d'une simulation. Le compteur de
transactions est affecté au départ avec l'instruction START. Puis chaque TERMINATE a
pour effet de décrémenter ce compteur. L'instruction:

START 2500

marquera le début de la simulation. La simulation s'arrêtera après que les 2500 transactions
sont passées dans le block TERMINATE (avec un 1 en colonne 19).

Les instructions de contrôle CLEAR et RESET sont utilisées pour relancer le système
plusieurs fois. Plusieurs simulations peuvent être ainsi effectuées séquenciellement, avec
quelques modifications à chaque fois. Cette possibilité de GPSS favorise l'étude des cas
sensibles. Par exemple avec la séquence suivante,

GENERATE 15,5

------

------

BLCK1 ADVANCE 10,5

------

------

TERMINATE 1

START 1 000

CLEAR

BLCK1 ADVANCE 15,5

START 1000

III.2) Elément de langage

Simulation
de GPSS
Discrète - SIMSCRIPT et GPSS 27
 Simulation Discrète - SIMSCRIPT et GPSS

Le modèle sera executé deux fois de suite. Pour les 1 000 premières transactions, le block
ADVANCE, correspondant à la durée d'utilisation d'un service, aura une valeur entre 5 et
15. Et pour les 1 000 suivantes, la durée du service sera comprise entre 10 et 20. Ces petites
variations dans un système peuvent conduire à des énormes variations, au vu des
statistiques, avec des engorgements des files d'attente, et des réactions en chaîne. C'est
pourquoi, cette faculté de GPSS est non négligeable.

L'instruction de contrôle SIMULATE est indispensable. C'est elle qui lance véritablement la
simulation. Sans elle, le compilateur analysera tout le programme, mais aucune simulation
ne sera exécutée. De même l'instruction END est nécessaire pour le compilateur. Ce doit
être la dernière instruction du programme.

III.3) Un exemple de programmation en GPSS

La figure 17 contient l'organigramme et les symboles GPSS, correspondant au programme

de simulation de la cabine téléphonique.

Les utilisateurs sont représentés par des transactions. Ils arrivent dans le système avec un
blockGENERATE, Avec un intervalle de temps entre chaque arrivée suivant une
distribution de densité exponentielle négative, de moyenne 15 minutes. Cette distribution est
spécifiée grâce à la fonction NEXP, définie au début du programme (figure 17 et 18).

III.2) Elément de langage

Simulation
de GPSS
Discrète - SIMSCRIPT et GPSS 28
 Simulation Discrète - SIMSCRIPT et GPSS

Figure 17 : Organigramme et symbolisme GPSS : Simulation de la cabine téléphonique.

Une transaction entrant dans le système est immédiatement placée dans la file d'attente
LINE, ou elle restera, jusqu'à ce que la facilityPHONE soit disponible. Elle sera alors
autorisée à s'en servir et quitter la file LINE. Une fois que la transaction arrive dans le
blockADVANCE, elle y reste durant une période aléatoire tirée entre 5 et 15 minutes.Ensuite
la transaction entre dans le blockRELEASE, elle libère alors la facility pour la
transaction suivante dans la file d'attente. Notre transaction passe alors dans le
blockTABULATE, ou elle marque le temps qu'elle a passé dans le système, en vue des
statistiques.

Figure 18 : Programme GPSS : Simulation de la cabine téléphonique.

Les instructions de contrôle en fin de programme spécifient que le modèle doit être relancé
une seconde fois, après avoir nettoyé le système (avec un CLEAR). La figure 19 montre les
résultats statistiques, des deux simulations.

III.3) Un exemple de Simulation

programmation
Discrète
en GPSS
- SIMSCRIPT et GPSS 29
 Simulation Discrète - SIMSCRIPT et GPSS

Figure 19 : Statistiques des files d'attentes, pour les deux simulations.

CONCLUSION

Deux autres langages de simulation discrète, SIMULA et GASP, méritent d'être

mentionnés.

SIMULA est un langage de simulation qui a été bien plus utilisé en Europe qu'aux
Etats-Unis. De même que SIMSCRIPT était une extension du FORTRAN, SIMULA est
une extension du langage ALGOL. En SIMULA, le système de simulation est vu comme
une liste de processus. La simulation est réalisée par des blocs de programme, correspondant
aux processus.

SIMULA 67 a le mérite d'être un langage de programmation très propre, tout en étant un

outil très puissant en matière de simulation discrète. Cependant SIMULA n'a pas connu le
développement qu'il méritait, en raison du faible développement d'ALGOL.

GASP II est un autre langage, avec la même philosophie que SIMSCRIPT. Il consiste en
une série de subroutines FORTRAN effectuant des tâches spécifiques à la simulation.
Cependant ce langage a été proportionnellement assez développé sur les petites machines.
Mais il ne permet pas de modéliser des systèmes très complexes de simulation.

Les deux langages de simulation discrète, qui ont connu le plus grand développement,
particulièrement aux Etats Unis, sont incontestablement GPSS, et SIMSCRIPT.

GPSS est un langage relativement facile à apprendre pour un débutant, dès que la logique
des blocks est comprise. Ceux qui n'ont pas l'habitude de programmer trouveront GPSS
plus facile que SIMSCRIPT parce que:

1. La structure des blocks, est facile à comprendre.

2. Les statistiques sont faites automatiquement par GPSS
3. Toutes les sorties sont automatiques en GPSS
4. Il n'y a pas de sections de définition ou d'initialisation.

Mais pour des problèmes très compliqués, difficile à modéliser, il est plus difficile de
travailler avec GPSS. SIMSCRIPT est plus souple d'utilisation, et s'adapte plus facilement à
des structures compliquées. Cependant un programmeur expérimenté en GPSS arrivera

CONCLUSION Simulation Discrète - SIMSCRIPT et GPSS 30

 Simulation Discrète - SIMSCRIPT et GPSS

toujours à modéliser un phénomène aussi compliqué qu'un programmeur SIMSCRIPT. En

fait le problème de programmation dépend en grande partie du programmeur.

Un problème de la plupart des versions de GPSS ets que les variables sont gardées avec
toutes les valeurs: les flottants n'existent pas vraiment. Cela pause des problèmes d'échelle
et de précision dans les opérations arithmétiques, surtout la division. Par exemple même si
beaucoup de problèmes peuvent être modélisés avec une unité de temps d'une heure, il est
souvent pratique de disposer des secondes. Cela oblige souvent à faire des reconversions
avec des facteurs d'échelle. Alors que SIMSCRIPT dispose des notations à virgule flottante,
qui nous affranchissent de cette difficulté.

SIMSCRIPT possède un compilateur intégré, les instructions sont traduites en

langage-machine, ce qui permet d'obtenir une vitesse raisonnable. A l'inverse, GPSS ne
dispose pas d'un compilateur, il utilise des subroutines pour traiter les instructions. C'est une
des raisons pour lesquelles, il n'est pas très rapide. De plus il a besoin de beaucoup de place
en mémoire, pour travailler. Cependant le compilateur de SIMSCRIPT est aussi très
gourmand en place pour stoker l'information.

Le compilateur de SIMSCRIPT malgré sa taille comporte une grave défaillance: Il n'aide

pas du tout le programmeur, à débugger un programme. Il ne donne quasiment aucune
information, sur les erreurs de syntaxes. Par contre, il refuse évidemment de tourner. GPSS
est lui beaucoup plus convivial de ce coté. Et des programmes écrits en GPSS sont très
faciles à corriger.

GPSS est de toute façon le langage de simulation qui a été le plus développé, et implémenté
sur le plus grand nombre de machines. Une des raisons de son développement est qu'il était
très facilement disponible gratuitement sur les machines IBM. SIMSCRIPT n'a pas eu ce
support pour se développer.

Pour résumer SIMSCRIPT est plus rapide, et un peu plus puissant, mais plus compliqué,
tandis que GPSS est plus facile à apprendre, plus léger, et a été plus développé.

BIBLIOGRAPHIE

" SIMULATION of Discrete Stochastic Systems "

de Herbert MAISEL et Giuliano GNUGNOLI

BIBLIOGRAPHIE Simulation Discrète - SIMSCRIPT et GPSS 31

 Simulation Discrète - SIMSCRIPT et GPSS

S.R.A (Science Research Associate, Inc.)

" SIMSCRIPT II.5 PROGRAMMING LANGUAGE "

de P.J. KIVIAT,R. VILLANUEVA, H.M. MARKOWITZ

C.A.C.I., édited by E.C. RUSSEL

" GETTING STRTED IN GPSS "

De Kenneth A. DUNNING (University of Akron)

Engineering Press, Inc.

" DISCRETE EVENT SIMULATION LANGUAGES "

deO.J.DAHL, 1968

Ed. F. GENUYS

Copyright Nicolas Fagart

dernière mise à jour le : 11/6/96

BIBLIOGRAPHIE Simulation Discrète - SIMSCRIPT et GPSS 32