Chapitre 19
TP - Nanoprocesseur

19.1 Introduction

Au cours de ce TP vous allez :

• étudier l’architecture du microprocesseur abordé dans la leçon sur le processeur (8),
• concevoir le compteur de programme (ou compteur d’adresse ou PC) du microprocesseur,
• concevoir la machine à état qui contrôle le processeur (CTR)
• apprendre les bases de Verilog,
• configurer un circuit logique programmable Xilinx afin qu’il réalise ce microprocesseur,
• faire exécuter un programme de test puis un programme musical à votre microprocesseur sur une carte de test,
• et de manière libre : améliorer votre microprocesseur en enrichissant son jeu d’instructions...

 
Conseils :

• suivez les conseils,
• respectez scrupuleusement les noms de composants et d’entrées-sorties proposés,
• pour les machines à états, utilisez le codage d’états proposé par le sujet,
• vérifiez toujours que le fichier que vous éditez est le bon (et pas une copie dans un autre répertoire...),
• faites simple, et souvenez-vous du vieil adage : si ça a l’air compliqué, c’est que c’est compliqué !

19.2 Architecture du système à microprocesseur

Bien que le sujet du TP concerne plus le coeur d’exécution du microprocesseur que son environnement d’utilisation, nous présentons ici le système complet implanté sur la maquette de test. Le système proposé se compose :

• Du microprocesseur implanté dans un circuit logique programmable Xilinx Spartan 2E XC2S300E ;
• Dune mémoire RAM contenant le programme et les données (cette mémoire est elle aussi intégrée dans le Xilinx) ;
• D’un haut-parleur piloté par un port de sortie du microprocesseur.

Quelques autres périphériques ne sont pas représentés sur le schéma 19.1

• le générateur d’horloge sclk et la génération de la remise à zéro (reset_n)
• les afficheurs pour le debug

Remarque : il y a quelques différences par rapport à la leçon sur le microprocesseur portant sur les noms des signaux :

• le bus d’adresse de la RAM est appelé ram_addr[7:0]
• le bus d’entrée de la RAM est appelé directement accu[7:0] (car c’est la sortie de l’accumulateur du processeur)
• le bus de sortie de la RAM est appelé ram_data[7:0]

19.3 Fonctionnement et jeu d’instructions du microprocesseur

Les caractéristiques principales de notre microprocesseur sont les suivantes :

• Le jeu d’instructions du microprocesseur se limite à 16 instructions
• Chaque instruction est codée sur deux octets :
  • Le premier octet contient le code de l’opération proprement dite ;
  • Le deuxième octet contient un pointeur qui donne l’adresse en mémoire d’une éventuelle opérande.
• L’adresse de l’accès courant (à une instruction) en RAM est notée PC ("Program Counter").
• La mémoire adressable par le microprocesseur ne dépasse pas 256 octets (8 bits d’adresse)
• Les données traitées sont des entiers naturels limités à l’intervalle 0..255 (8 bits de données)
• L’opérateur de calcul du microprocesseur se limite à quelques opérations logiques et arithmétiques simples (voir tableau). Le résultat de l’opération effectué est stocké dans l’accumulateur.
• Lors d’une modification de l’accumulateur, deux signaux supplémentaires sont générés et mémorisés :
  • Z si ce résultat est nul
  • C si une retenue sortante existe (dans le cas des opérations arithmétiques et de rotation)

Le tableau 19.2 résume le jeu d’instruction du microprocesseur.

• L’expression (AD) représente le contenu de la mémoire à l’adresse AD fournie par le deuxième octet de l’instruction (AD représente cette adresse, et (AD) le contenu de cette adresse)
• L’expression PC <= PC + 2 indique que la valeur du pointeur programme, pour l’instruction suivante, sera la valeur courante incrémentée de 2.
• L’expression A[6..0] indique les 7 bits de poids faibles du registre A.
• De même, (AD)[0] correspond au bit de poids 0 du contenu de la mémoire à l’adresse AD.

Nous vous conseillons de vous familiariser avec le jeu d’instructions et les codes associés du microprocesseur en étudiant le programme verif_globale qui servira de jeu de test de simulation pour le microprocesseur.

19.4 Architecture du coeur du nanoprocesseur

Le coeur, comme illustré à la figure 19.2 est composé de quelques registres, d’une unité de calcul, d’un compteur de programme et d’une unité de contrôle. Tous les registres du microprocesseur sont pilotés par l’horloge sclk (comme horloge système, system clock en anglais) et remis à zéro par l’état bas du signal reset_n.

Le compteur de programme (PC)

Le compteur de programme (8 bits) sert à stocker l’adresse de l’instruction courante.

• Son mode "standard" de fonctionnement est de s’auto-incrémenter lors des phases IF et AF pour aller chercher en séquence les différents octets des instructions à exécuter. L’incrémentation se fait au moyen du signal inc_PC\verb.
• En cas d’instruction de saut, il n’est pas incrémenté, mais directement chargé (lors de la phase AF) avec le contenu du bus de donnée ram_data[7..0], grâce au signal load_PC.

Le signal load_PC est prioritaire par rapport au signal inc_PC.

La machine à état de contrôle (CTR)

Cette unité contient la machine à état permettant de gérer les unités du processeur. Elle est donc en charge de séquencer les différents cycles d’une instruction (chargement d’une instruction, chargement de l’opérande, puis exécution) et de générer les signaux de contrôle des différents blocs, sans oublier, bien sûr, le signal ram_write de validation d’écriture en mémoire.

Registres de mémorisation

Ce bloc regroupe en fait les quatre registres suivants :

• le registre de sortie pur le buzzer.
• le registre d’accumulation.
• le registre d’instruction
• le registre d’adresse

Tous ces registres fonctionnent de la même façon : l’entrée xxx est mémorisée sur le front montant de l’horloge si l’enable correspondant (load_xxx) est à 1.

Le multiplexeur d’adresses (MUX_ADDR, en sortie du PC)

Ce multiplexeur permet de choisir qui, de l’adresse "pointeur programme" PC ou de l’adresse de données AD, doit être envoyé sur le bus d’adresse ram_addr de la mémoire. Le choix de l’un ou de l’autre dépend de l’état courant de fonctionnement du microprocesseur. De manière générale, lorsque le microprocesseur va chercher une instruction en mémoire, PC est sélectionné, et lorsque le microprocesseur va traiter une donnée en mémoire, AD est sélectionné. Le choix est contrôlé par le signal sel_adr.

Nous représenterons ce choix par l’équation suivante : 
ram_addr[7:0] = sel_adr * AD[7:0] + !sel_adr * PC[7:0]

L’ALU, unité atithmétique et logique

Ce bloc prend comme opérandes le contenu de l’accumulateur et le bus de donnée de la RAM, et effectue dessus l’opération indiquée par I. Selon le type d’opération,

• une retenue entrante peut éventuellement être prise en compte (C)
• deux bits sont générés
  • Z qui indique si le résultat de l’opération effectuée est nul
  • C qui indique si une éventuelle retenue sortante est générée.

19.5 Séquencement des opérations

Le signal reset_n permet de réinitialiser le fonctionnement du microprocesseur. Au premier cycle d’horloge suivant le passage à 1 du signal reset_n, le microprocesseur va chercher la première instruction du programme à exécuter qui se trouve implicitement à l’adresse "0" de la mémoire.

L’exécution d’une instruction s’effectue systématiquement en trois cycles d’horloge.

Le graphe de la machine à état est rappelé dans la figure 19.3 (toutes les sorties ne sont pas indiquées).

19.5.1 Premier cycle "IF"

Pendant le premier cycle (IF pour "instruction fetch") deux opérations sont réalisées simultanément.

• Le registre d’instruction I est chargé (load_I = 1) avec le premier octet de l’instruction. Ce premier octet est lu dans la mémoire à l’adresse donnée par le pointeur PC. A cet effet, PC est positionné sur le bus d’adresse ram_addr de la mémoire (sel_adr = 0).
• La deuxième opération consiste à incrémenter le compteur de programme PC (inc_PC = 1). Cette opération permettra, pour le cycle suivant, de disposer de l’adresse du deuxième octet de l’instruction.

19.5.2 Deuxième cycle "AF"

Pendant le deuxième cycle (AF pour "address fetch") deux opérations sont réalisées simultanément.

• Le registre d’adresse AD est chargé (load_AD = 1) avec le deuxième octet de l’instruction. Ce deuxième octet est lu dans la mémoire à l’adresse donnée par le pointeur PC. A cet effet, PC est positionné sur le bus d’adresse ram_addr de la mémoire (sel_adr = 0).
• La deuxième opération consiste à mettre à jour le compteur programme. Deux cas peuvent se présenter :
  • L’instruction n’est pas un saut. Il faut alors incrémenter le compteur de programme PC (inc_PC=1) de manière à disposer du pointeur du premier octet de l’instruction suivante.
  • L’instruction est un saut (instruction JMP, instruction JNZ avec Z=0, ou encore instruction JNC avec C=0). Dans ce cas, le pointeur programme PC reçoit la valeur de la donnée en mémoire à l’adresse PC (load_PC = 1).

Remarque : pour simplifier, inc_PC est systématiquement mis à 1. En cas de saut, le bloc PC considerera le signal load_PC comme étant prioritaire.

19.5.3 Troisième cycle "EX"

Le troisième cycle correspond à l’exécution proprement dite de l’instruction. L’opération réalisée dépend de l’instruction stockée dans le registre d’instruction I. Dans tous les cas, le contenu de la mémoire à l’adresse déterminée par le pointeur stocké dans AD au cycle précédent, est lu de la mémoire et placé sur le bus d’entrée ram_data (sel_adr = 1).

• Dans le cas d’une instruction "non opératoire" (NOP, STA, OUT, JMP, JNC ou JNZ), le contenu de l’accumulateur n’est pas modifié (LOAD_AZC = 0). Dans le cas contraire, le résultat de l’opération est mémorisé dans l’accumulateur (LOAD_AZC = 1). Remarque : l’instruction LDA est considérée comme une instruction opératoire (accu <= ram_data, donc LOAD_AZC = 1).
• Dans le cas de l’instruction OUT, la valeur du bit de poids faible de ram_data, ram_data[0], est stockée dans le registre BZ (LOAD_BZ = 1).
• Dans le cas de l’instruction STA, le contenu de l’accumulateur accu est stocké en mémoire (ram_write=1) à l’adresse mémoire déterminée par le pointeur stocké dans AD au cycle précédent.

Le chronograme 19.4 permet de résumer les différents cas.

19.6 Travail demandé

Vous venez de lire les spécifications d’un petit micro-processeur, appelé nanoprocesseur, destiné à synthétiser de douces mélodies. Comme tout projet bien spécifié, différentes équipes ont pu travailler de façon indépendante à la conception des différents modules. Ainsi, la carte contenant les différents composants électroniques et acoustiques est prête, un programme assembleur de test et un autre générant de doux sons sont déja écrits, le schéma global est terminé ainsi que les sous-blocs ALU, REG, MEMOIRE.

 
Hélas, lors de la phase final d’intégration, le chef de projet réalise, tardivement, il est vrai, que les équipes chargées des blocs PC et CTR ont fait un travail de tellement piètre qualité, qu’il juge préférable de les reconcevoir complètement.

A vous de jouer...

19.7 Verilog ou schéma ?

Vous avez jusqu’à présent travaillé avec des schémas. Sans renier l’utilité des schémas pour des circuits simples ou pour donner une vue d’ensemble d’un système, il faut quand même avouer qu’ils ne se prêtent pas tellement à la réalisation de circuits complexes : vous vous imaginez placer et relier entre eux les quelques 80.000 bascules D d’un Pentium, ainsi que les centaines de milliers de portes autour d’eux ? Nous non...

 
C’est pour faciliter la description de circuits complexes que les langages de description de matériel ont été inventés. Ces langages représentent les circuits sous forme textuelle.

 
Ils peuvent représenter :

• non seulement la structure des circuits ("ici je met telle porte, ici tel bloc, et je les relie de telle et telle façon"...)
• mais aussi leur comportement : plutôt que de dire que le bloc "additionneur" est composé de plein de petit additionneurs 1 bit, on dit simplement : resultat[8:0] = a[7:0] + b[7:0] + cin ! ! !

 
Vous allez réaliser ce circuit à l’aide de l’un de ces langages : Verilog. Il en existe d’autres (VHDL, SystemC, Confluence, ...), mais Verilog a quelques gros avantages :

• il ressemble beaucoup au C, avec quelques extensions pour représenter des fils, des fronts montant, etc...
• il est simple
• les programmes qui comprennent les schémas (pour les tranformer en portes physiques réelles) comprennent généralement aussi Verilog.
• si on sait expliquer la fonctionnalité d’un bloc avec des mots simples (en français), on sait l’écrire en Verilog.

 
Le but n’est pas de faire de vous des gourous de Verilog (ça viendra plus tard), mais plutôt de vous en donner suffisament de bases pour que vous puissiez vous débrouiller.

 
Allez tout d’abord faire un tour sur la page Verilog en 12 minutes, pour en avoir un petit aperçu !

19.8 Conception du bloc PC

La première étape consiste bien évidemment à déterminer le fonctionnement exact de ce bloc à partir des spécifications globales.

Remarque : vous pouvez vous reporter à la leçon sur le processeur (8) pour vous aider...

 
Puis, à partir de ces spécifications, il faut en écrire le code Verilog. Vous trouverez dans le répertoire des sources (src) :

• le squelette du bloc PC dont nous avons déjà écrit l’en-tête : pc.v (le bloc PC a été appelé REGPC, parce que le nom PC était déjà pris par le bus PC, sa sortie ... )
• le squelette du bloc CTR dont nous avons déjà écrit l’en-tête : ctr.v
• le reste des fichiers (alu.v, nanoproc.v, mux_adr.v, ...)

 
Lancez votre éditeur de texte favori, par exemple : xemacs src/pc.v & , puis complétez le code du PC.

 
Lorsque vous pensez avoir quelque chose qui tient la route, simulez-le en lançant, depuis le répertoire nanoproc : make simu_pc . Après un certain temps, le simulateur doit vous afficher : "le bloc PC fonctionne", et la fenêtre de chronogrammes doit avoir la même tête que la figure 19.5.

Si le simulateur vous donne une erreur, c’est que votre code Verilog comporte une erreur de syntaxe. Fermez le simulateur, corrigez-la, et relancez la simulation. Si les chronogrammes ne sont pas assez grands, vous pouvez zoomer à l’aide des icônes . Vous pouvez aussi zoomer sur une partie précise avec l’icône .

19.9 Conception du bloc CTR

De nouveau, il faut commencer par extraire des specifications le comportement exact de la machine à états, en déduire une architecture, et la coder en Verilog.

Registre d’état courant

Cette machine à états ne comportant que 3 états qui s’enchaîne dans un ordre fixe, elle sera codée en one-hot. L’état courant sera donc stocké dans trois registres, qu’on appelera cycle[2:0], dont l’en-tête a déjà été écrite.

Vous aurez à compléter le code de ces trois registres, c’est-à-dire à déterminer ce qui leur sera affecté au front montant de l’horloge, selon l’état des entrées, et de reset_n...

Calcul des sorties

Le calcul des sorties est un bloc purement combinatoire. Vous aurez donc à déterminer ce qui est affecté aux différentes sorties en fonction des entrées et de l’état courant (cycle[2:0]). Si l’équation est simple, vous donnerez à la sortie en question un type wire (à déclarer au bon endroit), et vous l’affecterez avec un assign sortie_xxx = .... ; Si l’équation est moins simple, vous utiliserez les instructions évoluées de Verilog, en :

• donnant à la sortie en question le type reg,
• et en l’affectant au sein d’un bloc always @* begin ... end. Vous pouvez alors utiliser les if, les case, ... Pour ce style d’écriture, vous pouvez vous inspirer du code de l’ALU (alu.v)

 
La simulation du bloc CTR sera une simulation globale du microprocesseur et de sa RAM !

19.9.1 Validation

Vous pouvez vérifier le bon fonctionnement de CTR en simulant directement le système complet (nanoprocesseur + mémoire) avec un programme de test. Ce programme, nommé verif_globale permet d’exécuter toutes les instructions du nanoprocesseur.

Pour cela, vous avez deux options : la simulation (virtuelle) et l’exécution pas-à-pas sur la maquette.

19.9.2 Simulation

Placez vous dans le répertoire nanoproc, et lancez la simulation de l’ensemble avec le programme verif_globale : make simu Au bout d’un certain temps, le simulateur ouvre une fenêtre de chornogrammes qui doivent avoir la même tête que ceux en figure 19.7.

Ces chronogrammes sont disponibles en version plus grande en cliquant ici.

 
Nous avons inclus dans ces chronogrammes les signaux nécessaires à la compréhension de ce qui se passe dans le processeur :

• l’horloge et le reset
• les signaux reliés à la RAM
• le signal pilotant le buzzer
• les trois registres principaux du processeur
  • I : le registre d’instructions, sous forme hexadécimale et textuelle
  • PC : le compteur de programme
  • accu : l’accumulateur
• les entrées et sorties de l’ALU
• les entrées et sorties du bloc contrôleur CTR.

 
Pour suivre les chronogrammes, il est conseillé de se rapporter à la page du programme de test verif_globale, et de suivre le déroulement du programme cycle par cycle.

 
Il est également possible de comparer vos chronogrammes à des chronogrammes de référence. Pour cela :

• Dans Tools -> Waveform Compare -> Start Comparison, choisir vsim_ref.wlf,
• Dans Tools -> Waveform Compare -> Add -> Compare by Region choisir simu (tous les ports et signaux de la simulation),
• Dans la fenêtre des chronogrammes, la liste des différences est affichée sous les signaux (avec une icône en forme de triangle jaune).
• Et cliquez sur Tools -> Waveform Compare -> Run Comparison. Les différences (si tant est qu’elles existent) apparaissent en rouge.

 
Par exemple, ces chronogrammes (visibles seulement depuis la version HTML) mettent en évidence le dysfonctionnement provoqué par le bug suivant :  
assign load_PC = cycle[2] && ( I==13 || ( I== 14 && !C ) || ( I== 15 && !Z ) ); (la logique correcte étant assign load_PC = cycle[1] ...).

19.9.3 Test réel

Lors la simulation est correcte, vous pouvez aussi suivre le déroulement du programme "en vrai", sur la maquette de test.

Pour cela, il faut tranformer le code Verilog en une liste de portes (netlist) compréhensible par le FPGA. Ceci est fait au moyen des même programmes que ceux que vous avez utilisés au dernier TP.

 
Placez-vous dans le répertoire nanoproc , et lancez la compilation des sources Verilog en une liste de portes pour le FPGA : make Si la compilation s’est terminée sans erreurs, lancez la programmation du FPGA (après avoir mis la maquette sous tension...) : make program Le FPGA doit commencer à exécuter le programme de vérification.

Il y a deux modes d’exécution de ce programme de test :

• pas-à-pas, si l’interrupteur SW1 est à 1 (en position vers le haut) C’est le bouton BTNA qui donne alors l’horloge (un appui = un coup d’horloge)
• automatique, si l’interrupteur SW1 est à 0 (en position vers le bas) L’horloge est alors générée automatiquement, et le programme s’exécute à vitesse normale (25MHz).

 
Vous pouvez suivre l’état de certain signaux du processeur :

• sur les deux afficheurs 7 segments de gauche : ram_addr[7:0]
• sur les deux afficheurs 7 segments de droite : accu[7:0]
• sur les LEDs rouge, en binaire : I[3:0]

Ici aussi, il est recommandé de suivre l’exécution du programme pas à pas, en vérifiant chaque étape à l’aide de la page du programme de test verif_globale.

19.9.4 Test musical

Pour finir le test de votre processeur, nous vous proposons de lui faire jouer un petit morceau de "musique". Pour cela, appelez un enseignant qui branchera un haut-parleur sur votre maquette. Puis lancez la compilation du processeur en lui passant en argument le programme musical : make chicken.  
Programmez le FPGA : make program

19.10 Questions subsidiaires

Pour les plus rapides, voici quelques sujets d’investigation...

1. Montrer que les instructions JNC, JNZ, JMP, ROL, ROR et OUT peuvent être exécutées en deux cycles. Modifier le contrôle en conséquence.
2. Comment augmenter de 256 à 1024 la taille de la mémoire ?