ITI 1521. Introduction informatique II

ITI 1521. Introduction informatique II
Laboratoire 8
Hiver 2016
Objectifs d’apprentissage
• Utiliser des files afin de résoudre des problèmes
• Décrire à haut niveau les éléments d’une simulation
Introduction
Il y a plusieurs applications des files dans la vie de tous les jours. Les files d’attente en sont un bon exemple.
Afin d’améliorer le service à la clientèle, les gestionnaires cherchent des techniques permettant de réduire
le temps moyen d’attente, ou la longueur moyenne des files. Pour les compagnies aériennes, l’introduction
de files d’attente séparées pour les voyageurs adhérant à un programme de fidélité (frequent flyers), en plus
des files normales. Pour les supermarchés, l’ajout de files express, en plus des files normales. Ce sont là des
façons de réduire le temps d’attente.
Cependant, les gestionnaires ont besoin d’outils leur permettant de comparer plusieurs scénarios afin
d’améliorer les services à moindres coûts ; ils doivent connaître le temps moyen d’attente pour chaque scénario,
par exemple.
Il y a deux grandes approches permettant de déterminer ces statistiques. Une branche des mathématiques
(Queueing theory) étudie spécifiquement ces questions. L’approche alternative consiste à développer une
simulation informatique de ces systèmes, et de mesurer les valeurs de certains paramètres à l’aide de la
simulation.
Pour ce laboratoire, nous développons une simulation des files d’attente pour un supermarché ayant des
files express ainsi que des files normales. Les files d’attente seront modélisées à l’aide de files (objets réalisant
l’interface Queue).
Cashier
-queue : Queue
-currentCustomer : Customer
-totalCustomerWaitTime : int
-customersServed : int
-totalItemsServed : int
+addCustomer(c : Customer) : void
+getQueueSize() : int
+serveCustomers(currentTime : int) : void
+getTotalCustomerWaitTime() : int
+getTotalCustomersServed() : int
+getTotalItemsServed() : int
Customer
-arrivalTime : int
-initialNumberOfItems : int
-numberOfItems : int
-MAX_NUM_ITEMS : int
+getArrivalTime() : int
+getNumberOfItems() : int
+getNumberOfServedItems() : int
+serve() : void
<<interface>>
Queue
+enqueue(obj : Object) : void
+dequeue() : Object
+isEmpty() : boolean
+size() : int
<<realize>>
ArrayQueue
Le diagramme UML ci-haut présente les principales classes de cette simulation. Pour ce laboratoire, il y
a une interface, nommée Queue, ainsi qu’une implémentation simple, nommée, ArrayQueue. Voici le code
source :
1
• Queue.java
• ArrayQueue.java
Afin de faciliter l’écriture des programmes, il faut faire certaines suppositions.
• Il s’agit d’une simulation où le temps a été discrétisé. Ainsi, une simulation est constituée d’un nombre
fixe et prédéterminé de périodes. Au début, la valeur de l’horloge est mise à 0, par la suite, pour chaque
itération la valeur de temps est augmentée d’une quantité fixe (TICK) ;
• Pour chaque itération, un ou plusieurs des événements suivants peuvent survenir :
– Un nouveau client joint la file. La probabilité de l’arrivée d’un nouveau client est PROBABILITY_NEW_ARRIVAL. Le nombre de produits achetés suit une distribution uniforme dont
l’intervalle est 1 . . .MAX_NUM_ITEMS ;
– Un caissier traite exactement un item par itération (à moins que sa file ne soit vide).
Le contenu de ce laboratoire est adapté du livre Lambert et Osborne (2004) Java : A Framework for
Program Design and Data Structures. Brooks/Coles, pages 266–274. Voici la description des classes de la
simulation.
1
Customer
Vous devez concevoir une classe afin de modéliser un client. Un client mémorise le moment de son arrivée,
le nombre initial de produits (articles), ainsi que le nombre de produits qui n’ont pas encore été traités par
le caissier. Le nombre maximal d’articles est le même pour tous les clients (MAX_NUM_ITEMS).
• Quelles sont les variables d’instances ?
• Quelles sont les variables de classes ?
L’unique constructeur de cette classe n’a qu’un paramètre. Ce dernier spécifie l’heure à laquelle le client s’est
joint à la file. Le nombre initial d’articles est déterminé à l’aide de la formule suivante :
Random generator;
generator = new Random();
int numItems;
numItems = generator.nextInt(MAX_NUM_ITEMS-1)+1;
Ainsi, nous nous assurons qu’il y ait au moins un (1) item.
Il y a aussi les méthodes d’instance suivantes :
• int getArrivalTime() retourne l’heure d’arrivée ;
• int getNumberOfItems() retourne le nombre d’articles à traiter ;
• int getNumberOfServedItems() retourne le nombre total d’articles traités ;
• serve() décrémente de 1 le nombre d’articles de ce client.
2
Cashier
Un caissier traite une file de clients. Il sert un client à la fois. Puisque le but de cette simulation est d’estimer
la valeur de certains paramètres, tel que le temps moyen d’attente, le caissier doit aussi mémoriser certaines
données telles que le nombre de clients servis, le temps total passé dans la file d’attente, ainsi que le nombre
total d’articles traités.
2
• Quelles sont les variables d’instance ainsi que les variables de classe ?
Cette classe n’a qu’un constructeur. Ce dernier n’a aucun paramètre. Il sert à initialiser les variables d’instance de ce caissier.
La méthode addCustomer(Customer c) ajoute un client à l’arrière de la file. La méthode int getQueueSize() retourne le nombre de clients qui attendent présentement.
La méthode serveCustomers(int currentTime) est un élément clé de la simulation. La méthode serveCustomers de chaque caissier est appelée exactement une fois par itération. Le paramètre currentTime
servira à déterminer le temps total qui s’est écoulé depuis que le client a joint la file. Voici le comportement
du caissier.
• Si le cassier n’a pas de client courant, le prochain client en file devient le client courant, sauf si la file
est vide, auquel cas, le caissier sera inactif pour cette itération. Lorsqu’un client est retiré de la file, il
faut comptabiliser le temps total passé à attendre ;
• Le caissier traite un article (appel à la méthode serve() du client courant) ;
• Si tous les articles du client courant ont été traités, le caissier comptabilise le nombre total d’articles
traités. Il laisse son client partir (ce caissier n’a plus de client courant).
Il y aussi 3 méthodes d’instances qui donnent accès aux statistiques de ce caissier : temps total passé
en file, nombre total d’articles traités, ainsi que le nombre total de clients servis : int getTotalCustomerWaitTime(), int getTotalItemsServed(), et int getTotalCustomersServed(). Finalement, la méthode
String toString() retourne une chaîne de caractères qui présente les statistiques accumulées par ce caissier.
Simulation
• Simulation.java
La classe Simulation orchestre la simulation. Un objet Simulation à deux caissiers, l’un est responsable
de la file express, l’autre s’occupe d’une normale. Cet objet mémorise aussi la durée de la simulation. Le
constructeur crée les deux caissiers nécessaires.
La méthode run() réalise la boucle principale de la simulation. Au début, l’horloge est mise à 0, pour
chaque itération, l’horloge avance d’une quantité fixe (TICK).
À chaque itération, la méthode run() doit :
• Déterminer si un nouveau client est arrivé, et si oui, le placer la bonne file, selon le nombre d’articles
achetés ;
• S’assurer que tous les caissiers traitent un client ;
• Incrémenter la valeur de temps.
À la fin de la simulation, la méthode affiche les statistiques.
1. Exécutez la simulation plusieurs fois. Discutez vos observations avec vos voisins. Voici un exemple de
sortie.
SIMULATION ::
The duration (in seconds) of the simulation was 28800
EXPRESS LINE ::
The total number of customers served is 376
The average number of items per customer was 6
The average waiting time (in seconds) was 16
REGULAR LINE ::
The total number of customers served is 311
The average number of items per customer was 18
The average waiting time (in seconds) was 2597
3
2. Hum, comme vous pouvez le constater le temps moyen d’attente pour la file express est très court (16
secondes !). Cependant, le temps d’attente à la file normale est très long (près de 45 minutes !). Le
gérant du supermarché devra ajouter de nouvelles files, mais combien ? Afin de l’aider avec sa prise de
décision, vous devez modifier ces classes afin d’y ajouter des caisses normales ;
3. Si le temps le permet, faites plusieurs expériences où vous allez varier les paramètres de la simulation,
changer la probabilité de l’arrivée d’un client, le nombre maximal d’articles, ainsi que le nombre de
caisses, express ou normales.
3
Quiz (1 point)
Pour l’implémentation d’une file à l’aide d’éléments chaînés, laquelle des deux implémentations suivantes est
préférable ?
1. Celle où la variable d’instance front désigne le premier noeud (objet de la classe Elem) de la structure
chaînée :
q
D
C
B
A
front
rear
2. Celle où la variable d’instance rear désigne le premier noeud (objet de la classe Elem) de la structure
chaînée :
q
D
C
B
A
rear
front
• Inscrivez votre réponse à la question ci-dessus dans le champ Soumission : de la page de soumission
du devoir (voir ci-dessous) ;
• https://uottawa.blackboard.com/
Last Modified : 21 mars 2016
4