Dans cette séance, nous allons nous intéresser à la manipulation des processus légers (la classe Thread) et les
problèmes d'exclusion mutuelle induits. C'est-à-dire que nous allons étudier le comportement d'un objet modifié par plusieurs
processus légers,
ainsi que la technique à mettre en oeuvre afin d'y remédier.
En ayant bien compris ce mécanisme, nous développerons ensuite un petit programme de calcul de somme partielle puis de nombre premiers
permettant d'exploiter les processus légers pour réaliser du calcul « parallèle ».
Enfin, nous verrons un mini ramasse-miettes qui permet de collecter de temps en temps des noeuds inutilisés d'un graphe.
Dans le TD précédent, nous avons commencé à manipuler les processus légers. Nous allons dans celui-ci nous intéresser au paradigme de
producteur / consommateur. L'application va ainsi présentée d'un côté les producteurs qui produisent des
messages et les stockent dans une file d'attente commune et de l'autre les consommateurs qui récupérent dans ce même
buffer les messages (dans l'ordre où ils y ont été placés). Chaque producteur et
consommateur sera exécuté par un processus léger différent.
La création d'un processus léger coûte cher à une application et, afin de limiter l'impact important de cette création, il est intéressant
de gérer un pool de processus qui permet de conserver les processus légers non utilisés par l'application. Ainsi, quand
l'application a de nouveau besoin d'un processus léger, elle demande à cette réserve s'il existe un processus disponible. Si oui, elle
l'emploi sinon différentes stratégies peuvent être mises en place (création, attente passive, ...).
Durant cette séance, nous allons écrire des programmes permettant d'afficher l'ensemble des interfaces réseaux de la machine courante
et de différentes machines distantes. Nous allons voir aussi que certaines caractéristiques du langage Java (les types primitifs
numériques entiers sont tous signés et qu'une promotion entière est systématiquement effectuée lors de toute
opération binaire sur les types primitifs entiers short et byte) sont cruciales pour la manipulation des
adresses IP.
Le principe de ce TP noté est de vous faire réaliser des exercices en les corrigeant au fur et à mesure de leur réalisation. Dès que
vous avez réalisé une partie d'un exercice (typiquement la réponse à une question indiquée par le symbole
),
vous appelez le correcteur qui viendra vérifier la validité de votre travail. Si vous faites fausse route, vous n'aurez pas les points
correspondant à cette question, mais le correcteur vous le signalera et vous pourrez continuer à traiter le sujet. Les exercices sont
indépendants les uns des autres.
Le but de ce projet est de fournir une implantation en Java du mécanisme mis en oeuvre au niveau des ponts Ethernet (IEEE 802.1D).
L'envoi de trames Ethernet sera émulé au niveau UDP par l'envoi de datagrammes multicast spécifiques. Les ponts « virtuels » devront
effectuer les travaux suivants :
Filtrage : correspondand au travail de filtrage des trames que font les ponts, en ne transmettant une trame à destination
d'une machine X que sur le domaine de collision d'où proviennent des trames émises par X, quand le pont possède cette information;
Spanning Tree Algorithm : cet algorithme et son protocole (STP) permettent, à partir de l'interconnexion de ponts (ou
commutateurs) par des liens redondants dans un réseau local Ethernet, d'obtenir un arbre couvrant minimum du graphe cyclique
correspondant à cette interconnexion. La spécificité de cet algorithme est que son calcul est réparti sur chacun des ponts, qui
n'a connaissance que de l'existence de ses voisins directs, et non de l'ensemble du graphe.
L'implantation qui vous est demandée est donc une simulation au dessus du protocole UDP de ce qui se passe en temps normal au niveau du réseau local Ethernet.