{{{
#!html
<h1>TP3 : Déploiement de l'application MJPEG sur une architecture multiprocesseur</h1>
}}}
[[PageOutline]]

TP Précédent : MjpegCourse/Monopro

= 0. Objectif =

Comme pour les précédents TP, vous aurez à fournir un certain nombre de sources
et un rapport.  Il vous est conseillé de parcourir la documentation dans le
trac, en partant de WikiStart.


La première partie de ce TP vise la description d'une architecture matérielle
multiprocesseurs générique, appelée !VgmnNoirqMulti. Cette architecture est
générique dans le sens où on peut faire varier par un simple paramètre le
nombre de processeurs et le nombre de bancs mémoire, ainsi que les
caractéristiques des caches rattachés aux processeurs.

La seconde partie de ce TP vise à déployer l'application MJPEG sur cette
plateforme générique en faisant varier les paramètres dont on dispose. Cette
''exploration architecturale'' est le but réel de l'outil DSX.

= 1. Description de l'architecture générique !VgmnNoirqMulti =

L'architecture !VgmnNoirqMono utilisée dans le TP2 était une architecture
mono-processeur non-paramètrable.

On se propose de décrire maintenant avec DSX une architecture multiprocesseur
générique (illustrée ci-contre), dont les paramètres sont :
 * Le nombre de processeurs : `proc_count`
 * Le nombre de bancs mémoire : `ram_count`
 * Le nombre de lignes des caches : `icache_lines` et `dcache_lines`
 * Le nombre de mots par ligne des caches : `icache_words` et `dcache_words`

[[Image(VgmnNoirqMulti.png, align=right)]]

Cette architecture comportera également un contrôleur de terminaux (!MultiTty).

Vous pourrez vous inspirer de l'architecture [MjpegCourse/VgmnNoirqMono
VgmnNoirqMono] définie dans le TP2, en n'hésitant pas à utiliser les
constructions du langage Python permettant d'exprimer la généricité (tableaux,
boucles, etc.)
Cette architecture générique !VgmnNoirqMulti sera décrite dans un fichier DSX
séparé, pour faciliter sa réutilisation.

Vous pouvez ajouter des paramètres à la fonction définissant l'architecture,
auxquels des valeurs par défaut peuvent être spécifiées. Par exemple :
{{{
def VgmnNoirqMulti( proc_count, ram_count, icache_lines = 16, icache_words = 8,
                    dcache_lines = 16, dcache_words = 8 )
}}}

Vous validerez cette architecture générique !VgmnNoirqMulti, en déployant
l'application MJPEG sur une instance particulière de cette architecture,
équivalente à celle utilisée dans le TP2 : c'est à dire un seul processeur et
deux bancs mémoire. Pour l'architecture matérielle, vous spécifierez des caches
processeurs de 16 lignes de 8 mots, et pour la partie logicielle, vous
utiliserez le système d'exploitation embarqué Mutek/S.


Vous instancierez l'architecture avec la ligne (les paramètres non spécifiés
prennent leurs valeurs par défaut) :
{{{
archi = VgmnNoirqMulti( proc_count = 1, ram_count = 2 )
}}}

[[Image(MjpegCourse:q.gif)]] Q1 : Combien faut-il de cycles pour décompresser 25 images?

= 2. Exploration Architecturale =

Dans cette seconde partie, on va déployer l'application MJPEG sur
l'architecture MPSoC !VgmnNoirqMulti.
Vous ferez principalement varier le nombre de processeurs et la répartition des
tâches logicielles sur les processeurs. Les deux tâches d'entrée/sortie  `tg`
et `ramdac` restent pour le moment implantées sur des coprocesseurs matériels
spécialisés : il y a donc 5 tâches "logicielles" à déployer sur un nombre de
processeurs qui reste à déterminer.

== 2.1 Profilage de l'application ==

Pour guider la répartition des tâches sur les processeurs, on commence par
effectuer un profilage de l'application sur station de travail POSIX, en
mesurant les temps passés dans les différentes tâches.

Ce profilage nous donne, comme charge relative entre les tâches, les valeurs
suivantes :

|| idct || 45% ||
|| vld || 34% ||
|| iqzz ||10% ||
|| demux || 8% ||
|| libu || 3% ||

[[Image(MjpegCourse:q.gif)]] Q2 : Qu'en déduisez-vous sur les façons optimales
de déployer MJPEG sur 2, 3, 4 et 5 processeurs ?

== 2.2 Déploiement sur une architecture à 5 processeurs ==

Déployez l'architecture MJPEG sur une architecture !VgmnNoirqMultiPro
comportant cinq processeurs, (c'est à dire une tâche par processeur) et lancez
la simulation.

[[Image(MjpegCourse:q.gif)]] Q3 : Combien faut-il de cycles pour décompresser 25 images?

On cherche maintenant à estimer le taux d'utilisation de chacun des 5 processeurs.

[[Image(MjpegCourse:q.gif)]] Q5 : Quel est selon vous le processeur le plus chargé ?

== 2.3 Déploiement sur des architectures à 4, 3 et 2 processeurs ==

Déployez l'application MJPEG sur des architectures matérielles comportant 4,
puis 3, puis 2 processeurs, en utilisant les informations données sur les
charges de chacune des tâches. Pour cela, placez ''intelligemment'' les tâches
de façon à obtenir les temps de décompression les plus courts possibles.

[[Image(MjpegCourse:q.gif)]] Q6 : Quel est le nombre de cycles minimal pour
décompresser 25 images avec 4 processeurs ?

[[Image(MjpegCourse:q.gif)]] Q7 : Quel est le nombre de cycles minimal pour
décompresser 25 images avec 3 processeurs ?

[[Image(MjpegCourse:q.gif)]] Q8 : Quel est le nombre de cycles minimal pour
décompresser 25 images avec 2 processeurs ?

== 2.4 Influence de la taille des caches ==

On souhaite maintenant évaluer l'influence de la taille des caches processeurs
sur le temps de décompression. Utilisez la ligne de commande de votre
description pour lui passer systématiquement la taille des caches :
{{{
# debut du fichier de description
# important: importer dsx en premier
import dsx
import sys

dcache_lines = int(sys.argv[1])
icache_lines = int(sys.argv[2])
}}}
Utilisez ensuite les deux variables `dcache_lines` et `icache_lines` dans votre
description.

On se place dans l'hypothèse d'une architecture à 2 processseurs, en conservant
le placement des tâches optimal défini à la question précédente. On utilisera
des lignes de cache de 8 mots, et on se contentera de faire varier le nombre de
lignes.
 * Mesurez le temps de calcul pour décompresser 2 images, en utilisant deux
 "gros" caches de 1024 lignes, pour les instructions comme pour les données.
 * Refaites cette mesure en diminuant progressivement le nombre de lignes du
 cache de données (256, puis 64, 16, 4 et enfin, 1), en conservant une capacité
 de 1024 lignes pour le cache d'instructions.
 * Même question en diminuant progressivement le nombre de lignes du cache
 d'instructions (256, puis 64, 16, 4, et enfin 1), en conservantune capacité de
 1024 lignes pour le cache de données.

[[Image(MjpegCourse:q.gif)]]Q9 : Regroupez ces résultats dans deux tableaux de
synthèse.

[[Image(MjpegCourse:q.gif)]]Q10 : Que choisiriez-vous comme capacité pour les
caches, sachant que la surface de la mémoire embarquée est un facteur important
du coût de fabrication (vous comparerez en particulier la capacité des caches à
la capacité des bancs mémoire `ram0` et `ram1`).

= 3. Compte-Rendu =

Comme pour les TP précédents, vous rendrez une archive contenant les fichiers
suivants :
{{{
$ tar tzf binome0_binome1.tar.gz
tp3/
tp3/rapport.pdf
tp3/vgmn_noirq_multi.py
tp3/mjpeg/
tp3/mjpeg/mjpeg.py
tp3/mjpeg/src/
tp3/mjpeg/src/iqzz.c
tp3/mjpeg/src/libu.c
}}}

Le fichier `mjpeg.py` sera celui de la partie 2.4, avec la gestion de la ligne
de commande. Les deux sources C sont ceux des deux derniers TP, éventuellement
modifiés.

Cette archive devra être livrée avant le jeudi 6 janvier 2011, 18h00 (heure de
Paris) à [MailAsim:joel.porquet Joël Porquet]

= Suite =

TP Suivant : MjpegCourse/Multipipe