{{{
#!html
TP1 : Plate forme de simulation + Synthèse
}}}
[[PageOutline]]
= Introduction =
Le but des 4 TPs est d'effectuer la conception physique d'un Mips R3000 pipeline.
Vous devez appliquer la méthodologie vue dans les Tps de Tools.
Vous avez à disposition une [attachment:sources.tar.bz2 archive] contenant l'ensemble des fichiers nécessaires aux TPs.
Pour décompresser cette archive, utilisez la commande suivante :
{{{
> tar xjvf sources.tar.bz2
}}}
Vous obtenez un répertoire sources contenant lui même six autres répertoires :
* '''asm''' : contient les programmes assembleurs qui seront exécutés sur la carte contenant le MIPS pour vérifier son fonctionnement.
* '''design''' : contient les descriptions comportementales ou structurelles des différentes parties du MIPS, que vous devez utiliser pour écrire la description structurelle de l'ensemble du circuit (en python).
* '''mips''' : contient un fichier comportemental décrivant le mips dans lequel le découpage chemin de données / partie contrôle n'est pas effectué.
* '''misc''' : contient les fichiers utiles à la création de l'environnement de test du MIPS.
* '''ram''' : contient les fichiers décrivant le fonctionnement de la ram.
* '''test_mips''' : contient les fichiers de test.
Le répertoire test_mips contient un script shell nommé test.sh vous permettant de lancer l'intégralité des tests sur votre MIPS.
Vous pouvez tester deux mises en oeuvre du MIPS à l'aide des commandes suivantes :
{{{
> ./test.sh v1
}}}
permet de lancer tous les tests en utilisant la description comportementale du mips (fichier dans le répertoire '''mips''').
{{{
> ./test.sh v2
}}}
permet de tester le découpage des parties contrôle et chemin de données (en comportemental) instanciées par une hiérarchie structurelle du coeur et du circuit complet (avec plots) (fichiers dans le répertoire '''design''').
Vous avez également à disposition la commande :
{{{
> ./test.sh v3
}}}
qui permettra de lancer tous les tests en utilisant tous les fichiers .vst générés une fois votre MIPS terminé.
''Remarques'' :
* Avant de pouvoir utiliser le script '''test.sh''' pour la première fois, il faut aller dans le répertoire '''asm''' et lancer le script '''ASM.csh'''
* Notez bien que pour utiliser la seconde commande présentée vous devez au préalable avoir généré les fichiers mips_r3000_1m.vst et mips_r3000_1m_core.vst à l'aide du script '''gen_mips.py''' et du '''Makefile''' situés dans le répertoire '''design'''.
* Notez également vous pouvez tout à fait compléter ce script de façon à tester des versions "intermédiaires", la partie controle en ''.vst'' et le chemin de données en ''.vbe'' par exemple pour tester l'étape d'aujourd'hui : la synthèse de la partie controle.
'' /!\ ERRATUM /!\'' : Veuillez récupérer le fichier [attachment:SIM.csh] et remplacer le fichier de même nom dans les sources fournies dans le répertoire ''test_mips''.
= 1 Plate forme de simulation =
== 1.1 Les programmes assembleurs pour la plate forme de simulation ==
Lors de la conception du processeur, à chaque étape, il faut vérifier que le résultat obtenu est conforme aux spécifications du processeur.
Une des vérifications qui doit être appliquée systématiquement est la vérification fonctionnelle.
Elle consiste à s'assurer que le circuit obtenu à cette étape de conception est toujours conforme à l'architecture du Mips.
Bien évidemment, cette vérification ne peut être que partielle.
Pour vous aider dans cette tâche, un ensemble de programmes de test est fourni.
A priori, on peut imaginer qu'un programme de test consiste simplement à exécuter une instruction.
Puis, il suffit de vérifier à travers les patterns en affichant la valeur des registres visibles que l'instruction a été correctement exécutée.
Toutefois cette méthode est très pénible et nécessite l'intervention du concepteur pour valider la bonne exécution de chacune des instructions.
Nous vous proposons une autre méthode.
Les programmes assembleur fournis sont écrits de telle manière qu'ils vérifient le résultat de l'exécution de l'instruction objet du test à travers une suite d'instructions.
A l'issue de ce test, le programme se branche à deux adresses différentes en fonction du résultat du test.
Dans chacune de ces branches une valeur différente est écrite en mémoire.
Un dispositif particulier sur la plateforme de simulation surveille les valeurs écrites en mémoire.
Lorsque ce dispositif voit l'écriture de la valeur qui signale l'exécution correcte du programme, il arrête la simulation et affiche un message qui indique que l'exécution s'est déroulée correctement.
A l'inverse l'écriture de la valeur qui dénote un dysfonctionnement déclenche l'arrêt de la simulation et un message indiquant la mauvaise exécution du programme est affiché.
== 1.2 Exemple ==
{{{
###----------------------------------------------------------------###
# file : add000.u #
# date : Mar 26 1996 #
# descr. : functional test for Mips R3000 #
###----------------------------------------------------------------###
.text
###--------------------------------------------------------###
# signed addition #
###--------------------------------------------------------###
good_val .equ 0x01
bad_val .equ 0x02
sim_addr .equ user_cntl_begin
val1 .equ 0x0000000a
val2 .equ 0x00000002
init:
li r1 , val1
li r2 , val2
add r3 , r2 , r1
li r5 , (val1 + val2)
beq r5 , r3 , good
nop
j bad
nop
###--------------------------------------------------------###
# signaling good / bad #
###--------------------------------------------------------###
good:
li r1 , sim_addr
addiu r2 , r0 , good_val
j end_loop
nop
bad:
li r1 , sim_addr
addiu r2 , r0 , bad_val
j end_loop
nop
end_loop:
sb r2 , 0(r1 )
j end_loop
nop
.end
}}}
== 1.3 L'assemblage des programme ==
L'outil '''assembleur''' permet de générer une image mémoire à partir de fichiers écrits en assembleur.
Cet outil prend en entrée une liste de fichiers assembleur et le fichier '''ldscript''' et génère une image mémoire dans un fichier de sortie.
{{{
> asm -set noreorder -ld -mips1 -o …
}}}
== 1.4 La plateforme de simulation pour le processeur MIPS ==
Une plateforme de simulation construite autour d'un processeur MIPS permet de simuler l'exécution d'un programme assembleur.
Outre le processeur Mips, cette plateforme comporte des bancs mémoires pour les instructions et les données, un terminal d'affichage, un dispositif de détection de fin de simulation et un décodeur d'adresses.
Le décodeur d'adresses sélectionne, en fonction de l'adresse émise par le processeur, le banc mémoire qui doit répondre au processeur ou bien le terminal d'affichage ou encore le dispositif qui arrête la simulation.
Sur cette plateforme les bancs mémoires sont initialisés à partir de l'image mémoire obtenue par l'assemblage d'un programme assembleur.
Cette image doit se trouver dans le fichier '''ram.ini''' et ce fichier doit être placé dans le répertoire où la simulation est lancée.
Le fichier de patterns nécessaire à la simulation est très simple.
En pratique, cette plateforme n'a que deux entrées : l'horloge et le signal de reset.
Pendant le premier cycle de simulation, le signal reset est actif (ce signal est actif à l'état bas) puis, il reste inactif pendant le reste de la simulation.
L'horloge est un signal périodique qui passe successivement de 0 à 1 et de 1 à 0.
[[Image(simu.jpg, nolink)]]
= 2 Synthèse de la partie controle =
Le but est ici d'utiliser les différents outils de synthèse à votre disposition pour générer la vue structurelle de la partie controle à partir de la description comportementale fournie.
Vous testerez les options des différents outils pour avoir une netlist ''optimisée''.
Vous écrirez un '''Makefile''' qui sera à compléter au fur et à mesure des TPs.