Microprocesseur Conception

EN 210 : Conception d’un processeur avec jeu
d’instructions élémentaires
Contexte et projet
Camille Leroux
camille.leroux@enseirb-matmeca.fr
Camille Leroux (Bordeaux INP) EN210 - Conception processeur 1 / 73

Plan
1 Introduction
2 Architectures et technologies d’intégration
3 Architecture de base d’un processeur universel
Unité opérative
Unité de contrôle
Mémoire
4 Processeur 8 bits
Architecture
Compréhension du jeu d’instructions
Macro-instructions
Compilation d’un algorithme
5 Conception de l’architecture
6 Travaux Pratiques

Objectifs du module
+ Savoir distinguer une architecture dédiée d’une architecture

programmable
+ Comprendre les grands principes des technologies d’intégration
(full-custom, standard-cell, reconfigurable)
+ Conduire un projet de conception matériel de manière autonome et
structurée de bout en bout
+ Concevoir et assembler les fonctions élémentaires d’électronique
numérique
+ Apprendre à respecter les règles régissant un circuit numérique
synchrone (horloge, reset, enable, ...)
+ Comprendre les principes de base de fonctionnement d’un processeur
avec un jeu d’instructions

Organisation du module
Partie préliminaire (sur feuille)
Interprétation du contenu de la mémoire
Application sur un cas concret : PGCD de deux nombres entiers
Définition du schéma bloc de l’ensemble du processeur
Partie opérative
Partie mémorisation
Partie contrôle
Schéma bloc global
Partie conception (sur machine)
Description VHDL et validation fonctionnelle du :
bloc de la partie opérative,
bloc de mémorisation,
bloc de contrôle.
Description VHDL et validation fonctionnelle du top level
Partie implantation et prototypage FPGA
Ajout d’un bloc VHDL gérant le boot loader
Synthèse logique, placement/routage et génération du fichier bitstream
Chargement sur la carte et validation
Plan
1 Introduction
Unité opérative
Unité de contrôle
Mémoire
4 Processeur 8 bits
Architecture
Macro-instructions
6 Travaux Pratiques

Conception et intégration de systèmes numériques
Algorithme
???
A partir d’une spécification algorithmique, comment concevoir un circuit

qui implémente le traitement spécifié ?

Conception et intégration de systèmes numériques
ALGORITHME
CONCEPTION
La conception consiste à définir l’architecture

ARCHITECTURE qui implémente l’algorithme
L’intégration consiste à définir le circuit
numérique qui implémente l’architecture
INTEGRATION

Architectures
Pour un algorithme donné, on peut imaginer une infinité

d’architecture qui implémentent son comportement.
On peut néanmoins classifier les architectures en deux grandes
familles :
Les architectures dédiées
Les architectures programmables
Pour illustrer la notion d’architecture, prenons comme exemple la
FFT (Fast Fourier Transform). Supposons que je veuille implémenter
(conception + intégration) cet algorithme sur un circuit numérique.
Quelles sont les solutions architecturales qui s’offrent à moi ?

L’architecture dédiée
Fréquence Elevée
Débit Elevée
Complexité Faible
Puissance Faible
Energie Faible
Flexibilité Faible
Dans ce type d’architecture, on implémente uniquement les ressources

nécessaires à l’implémentation de l’algorithme :
Les ressources de calculs implémentent uniquement les fonctions utiles
à l’application (Butterfly, MAC, ...)
La mémoire est dimensionnée au plus juste par rapport au besoin de
l’algorithme
Le contrôle est conçu au cycle près pour que le traitement soit effectué
dans le temps le plus court possible
L’architecture programmable (GPP)
Fréquence Elevée
Débit Faible
Complexité Elevée
Puissance Elevée
Energie Elevée
Flexibilité Elevée
Dans ce type d’architecture, l’algorithme est traduit en une succession

d’instructions élémentaires. Chaque instruction est ensuite décodée et
éxecutée par les ressources du processeur.
On retrouve généralement les blocs suivant :
Unité de calculs (entier, flottant, ...)
Unité de mémorisation (programme, données, ...)
Unité de contrôle (fetch, decode, prediction de branchement, ...)
Unité d’interfacage (Bus, I/O, ...)
Architecture programmable semi-dédiée (ASIP)
Fréquence Elevée
Débit Elevé
Complexité Elevée
Puissance Elevée
Energie Elevée
Flexibilité Modérée
ASIP : Application Specific Instruction set Processor

Exemples d’ASIP : DSP, GPU, processeur contrôle, ...
Dans le cas du DSP, on retrouve souvent :
Unité de calculs dédiée à l’application (MAC, barrel shifter, ...)
Unités de mémorisation (programme et données souvent séparés)
Unité de contrôle qui contient souvent des générateurs d’adresses
Unité d’interfacage (Bus, I/O, ...)

Solution d’intégration en électronique numérique
N’importe qu’elle architecture de système numérique peut-être décrite sous

forme de portes logiques, de bascules D et de mémoires : netlist
Une fois l’architecture définie et transcrite en netlist, il faut choisir la
technologie d’intégration.
La technologie d’intégration définie la manière dont les transistors
implémentent les différentes fonctions combinatoires et séquentielles
de la netlist.
Pour les systèmes numériques, il existe trois principales technologies
d’intégrations :
Intégration full-custom
Intégration avec des cellules standards
Intégration sur le la logique reconfigurable
NB : En fonction de la technologie choisie, le flot d’intégration varie.

Intégration Full Custom
Chaque porte/bascule est faite "à la main" (dimensionnement des

transistors)
Utilisé quand les contraintes de conception sont très fortes (vitesse,
conso, surface)
Typiquement utilisé pour les circuits analogiques mais aussi pour les
microprocesseurs
Méthode d’intégration très coûteuse en temps

Intégration avec des cellules standards
Chaque porte/bascule est "mappée" sur une cellule pré-caractérisées

(surface, conso, vitesse, capa, ...).
Les cellules sont ainsi simplement interconnectées entre elle (par un
outil) sous forme de netlist
Le placement routage peut être effectué de manière automatique
(cellules placées en lignes)
L’automatisation du flot de conception permet d’implémenter des
circuits complexes en peu de temps.
Intégration sur de la logique reconfigurable
L’idée maitresse est de fabriquer le circuit (intégration) AVANT

d’avoir défini l’architecture.
Le principe de base est de mémoriser (dans des LUTs) les table de
vérite des fonctions logique plutôt que d’implémenter des portes
logiques
Un FPGA contient un grand nombre de ressources de calculs (LUT,
blocs DSP) et de mémorisation (Bascules D, SRAM, LUT).
L’intégration consiste à configurer le contenu des LUT et les
interconnexions pour venir implémenter l’architecture.
Quelle archi ? Quelle techno. ?
Processeur ASIP Archi. dédiée
Full custom
Cellules Standards
Reconfigurable
1 Intel Corei7
2 DSP TMS 6400
3 GPU ATI fondu par IBM
4 FFT décrite en VHDL et implantée sur FPGA
5 Bloc DSP dans un FPGA Xilinx
6 ARM implanté dans un StratixII (Altera)
7 ARM (Hard IP) implanté dans un Zynq (Xilinx)
8 DSP décrit en VHDL et implanté sur FPGA
9 Convertisseur A/D
10 Processeur ARM implantée en technologie ST 65nm
Plan
1 Introduction
Unité opérative
Unité de contrôle
Mémoire
4 Processeur 8 bits
Architecture
Macro-instructions
6 Travaux Pratiques

Architecture de base
Processeur : Unité opérative + Unité de contrôle

Unité opérative à Processeur
usage universel Unité de contrôle Unité opérative
Unité de contrôle commande

UAL
configurant les Contrôleur état
opérations de l’unité
opérative
Registres
Mémoire globale PC IR
contenant le
programme
E/S
(séquencement des
opérations) et les Mémoire
données

Plan
1 Introduction
Unité opérative
Unité de contrôle
Mémoire
4 Processeur 8 bits
Architecture
Macro-instructions
6 Travaux Pratiques

Organisation de l’unité opérative
3 phases clés
Processeur
Unité de contrôle Unité opérative
commande
UAL
+1
Contrôleur état
LOAD : charger le
Registres
registre avec la valeur
qui se trouve en
PC IR 10 11
mémoire
E/S
...
10
Mémoire
...

3 phases clés
Processeur
commande
UAL
EXECUTE : passer le +1
Contrôleur état
contenu de certains
Registres
registres à travers
l’UAL, puis stocker le
PC IR 10 11
résultat dans un
registre
E/S
...
10
Mémoire
...

3 phases clés
Processeur
commande
UAL
+1
Contrôleur état
STORE : stocker la
Registres
valeur du registre
(résultat) dans un
PC IR 10 11
emplacement mémoire
E/S
...
10
Mémoire
...

Plan
1 Introduction
Unité opérative
Unité de contrôle
Mémoire
4 Processeur 8 bits
Architecture
Macro-instructions
6 Travaux Pratiques

Organisation de l’unité de contrôle
5 cycles d’instruction
Processeur
commande
UAL
FETCH Contrôleur état
INSTRUCTION : lire
Registres
l’instruction suivante
dans la mémoire pour
PC IR
la charger dans le R0 R1
registre IR
E/S
...
100 load R0, M[500] 10
500
101 Inc R1, R0 Mémoire 501
102 store [M501], R1 ...

Processeur
commande
UAL
Contrôleur état
DECODE :
Registres
déterminer le type de
l’instruction qui a été
PC IR
chargée dans IR R0 R1
E/S
...
100 load R0, M[500] 10
500
102 store [M501], R1 ...

Processeur
commande
UAL
FETCH Contrôleur état
OPERANDS :
Registres
transférer les données
de la mémoire vers les
PC IR
registres de l’unité R0 R1
opérative
E/S
...
100 load R0, M[500] 10
500
102 store [M501], R1 ...

Processeur
commande
UAL
Contrôleur état
EXECUTE : faire
Registres
passer le contenu de
certain registres à PC IR
R0 R1
travers l’UAL
E/S
...
100 load R0, M[500] 10
500
102 store [M501], R1 ...

Processeur
commande
UAL
Contrôleur état
STORE : stocker la
valeur du Registres
registre(résultat) dans
un emplacement PC IR
R0 R1
mémoire
E/S
...
100 load R0, M[500] 10
500
102 store [M501], R1 ...

Plan
1 Introduction
Unité opérative
Unité de contrôle
Mémoire
4 Processeur 8 bits
Architecture
Macro-instructions
6 Travaux Pratiques

Organisation de la mémoire : deux types
HARVARD Processeur
4 Accès simultané aux programme et
données
Mémoire de Mémoire de
(Fetch inst. et Fetch oprd chevauchées) programme données
Harvard
Processeur
PRINCETON (Von Neumann)
4 Peu de fil de connexion
Mémoire
4 Implémentation simple (programme et données)
Princeton
(Von Neumann)
Le modèle d’architecture de Von Neumann est le modèle le plus utilisé

actuellement
Organisation de la mémoire : architecture HARVARD
Déclinaison de base Déclinaison 1 Déclinaison 2

Mémoire Mémoire Mémoire Mémoire Mémoire Mémoire
programme/ données
programme données données programme données
Déclinaison 3 Déclinaison 4
Mémoire Mémoire Mémoire Mémoire Mémoire Mémoire Mémoire Mémoire
programme données données programme données données données données

Organisation de la mémoire cache
Haute technologie (rapide et plutôt chère),

Accélérer l’accès aux mémoires généralement sur la même puce
(programme et données)
Processeur
La mémoire cache est intégrée
au processeur (au sein de la
même puce)
Petite taille (< 1MB) Cache
Accès très rapide
Retient une copie d’une petite
partie de la mémoire Mémoire
Accès réussi ou manqué ! Technologie moins rapide et moins chère,
généralement séparée sur une autre puce

Cycles d’instruction
PC100 Processeur
Fetch Decode Fetch Exec. Store Unité de contrôle Unité opérative
inst. oprends. results
clk
commande
UAL
Contrôleur état
Registres
PC IR
100 R0 R1
E/S
...
100 load R0, M[500] 10
500
102 store [M501], R1 ...

PC100 Processeur
Fetch Decode Fetch Exec. Store
clk commande
UAL
+1
PC101 Contrôleur état
Registres
clk
PC IR 10
101 R0 R1
E/S
...
100 load R0, M[500] 10
500
102 store [M501], R1 ...

PC100 Processeur
clk commande
UAL
PC101 Contrôleur état
inst. oprends. results Registres
clk
PC IR 10 11
PC102 101 R0 R1
clk
E/S
...
100 load R0, M[500] 10
500
102 store [M501], R1 ...

Bus de communication
• Le processeur est le maître du
• Le processeur est le maître du
Processeur BUS Périphérique bus
Processeur BUS Périphérique bus
• – LeIl estt le
–adresse
l seull à écrire
processeur
Il estprocesseur
Le t le
l etseul
é i sur
l à est
écrire
é iest
les
l bus
le sur
maître
leles
b du
l maître
bus
b du
contrôle
Processeur BUS Périphérique busbus
adresse et contrôle
• Le périphérique obtempère
adresses • Le– périphérique
Il estt le
l seull à écrire éobtempère
i sur les l bus
b
adresses sur le adresse
bus Ildonnées
est le seul à écrire sur les
et contrôle
données
sur le bus données
Processeur données Périphérique • – LeLecture: bus
périphérique
–demandée
adresse
il fournit et contrôle.
la donnée
Lecture: il fournitobtempère la donnée
Processeur contrôle
adresses Périphérique
contrôle surLe le périphérique
bus données obtempère sur
demandée
– Ecriture : ildonnées
récupère la donnée
Processeur
données
Périphérique
– le
–fourniebuspar
Ecriture
Lecture: : ille
il fournit
récupère la donnée
la donnée
processeur
contrôle
Adresses : sélection du périphérique fournie
demandéepar le processeur
Lecture : ilil se
fournit la donnée
– Haute impédance:
et Adresses : sélection
d’une donnée en sondu périphérique
sein –déconnecte
– Haute impédance:
Ecriture : du
demandée. bus il se
il récupère la donnée
et d’une donnée en son sein déconnecte
fournie par le duprocesseur
bus
Données : valeur de la donnée à échanger Écriture : il récupère la donnée
Adresses : sélection du périphérique – Haute impédance: il se
Données : valeur de la donnée à échanger fournie par le processeur.
et d’une donnée en son sein déconnecte du bus
Contrôle : lire / écrire / haute impédance Haute impédance : il se
Contrôle
Données: :lire / écrire
valeur / haute
de la impédance
donnée à échanger déconnecte du bus.
14
Contrôle : lire / écrire / haute impédance 14
.
14

Plan
1 Introduction
Unité opérative
Unité de contrôle
Mémoire
4 Processeur 8 bits
Architecture
Macro-instructions
6 Travaux Pratiques

Plan
1 Introduction
Unité opérative
Unité de contrôle
Mémoire
4 Processeur 8 bits
Architecture
Macro-instructions
6 Travaux Pratiques

Architecture du processeur
Mémoire
Mémoire :
Architecture Von Neumann (prog. et données partagent la mémoire)
Bus de données (1 entrée et 1 sortie)
Bus d’adresse
Signaux de contrôles
Unité de contrôle :
Compteur de programme (PC)
Registre d’instruction (RI)
Machine d’état
Unité de traitement :
Registre ACCU
UAL : NOR et ADD uniquement
Registre carry
STA écrit le contenu de ACCU dans la mémoire et réinitialise carry

Plan
1 Introduction
Unité opérative
Unité de contrôle
Mémoire
4 Processeur 8 bits
Architecture
Macro-instructions
6 Travaux Pratiques

Jeu d’instructions
Processeur 8-bits à usage universel
Basé sur un registre accumulateur appelé ACCU (8 bits)
Quatre type d’instructions
Abréviation Codage de l’instruction Description de l’instruction
NOR 00 AAAAAA1 ACCU = ACCU NOR Mem[AAAAAA]
ADD 01 AAAAAA1 ACCU = ACCU + Mem[AAAAAA]
mise à jour de la retenue
STA 10 AAAAAA1 Mem[AAAAAA] = ACCU
JCC 11 AAAAAA2 Si Carry = 0 alors PC=AAAAAA
sinon effacer la retenue (Carry = 0)
(1) AAAAAA : bits d’adressage ;

Table – Jeu d’instructions du processeur
Chaque instruction est codée sur 8 bits. Deux bits pour coder le type de
l’opération (code op) et 6 bits pour coder l’opérande ou l’adresse de
l’opérande dans la mémoire selon le type de l’instruction.
Mémoire du processeur minimal 8 bits
Adr. Hex Bin Interprétation Valeur Accu Mem (hex) Mem (bin)
00 X"08" 00001000
01 X"47" 01000111
02 X"86" 10000110
03 X"C4" 11000100
04 X"C4" 11000100
05 X"00" 00000000
06 X"00" 00000000
07 X"7E" 01111110
08 X"FE" 11111110
Adresse[00,04] : instructions mémorisées ; Adresse[05,08] : données mémorisées

00 X"08" 00001000
01 X"47" 01000111
02 X"86" 10000110
03 X"C4" 11000100
04 X"C4" 11000100
05 X"00" 00000000
06 X"00" 00000000
07 X"7E" 01111110
08 X"FE" 11111110

00 X"08" 00001000 ACCU = ACCU 00000000
NOR mem[8] 00000001
01 X"47" 01000111
02 X"86" 10000110
03 X"C4" 11000100
04 X"C4" 11000100
05 X"00" 00000000 donnée X"00" 00000000
06 X"00" 00000000 donnée X"00" 00000000
07 X"7E" 01111110 donnée X"7E" 01111110
08 X"FE" 11111110 donnée X"FE" 11111110

00 X"08" 00001000 ACCU = ACCU 00000000
NOR mem[8] 00000001
01 X"47" 01000111 ACCU = ACCU 00000001
+ mem[7] 01111111
02 X"86" 10000110
03 X"C4" 11000100
04 X"C4" 11000100
05 X"00" 00000000 donnée X"00" 00000000
06 X"00" 00000000 donnée X"00" 00000000
07 X"7E" 01111110 donnée X"7E" 01111110
08 X"FE" 11111110 donnée X"FE" 11111110

00 X"08" 00001000 ACCU = ACCU 00000000
NOR mem[8] 00000001
01 X"47" 01000111 ACCU = ACCU 00000001
+ mem[7] 01111111
02 X"86" 10000110 mem[6] = ACCU
03 X"C4" 11000100
04 X"C4" 11000100
05 X"00" 00000000 donnée X"00" 00000000
06 X"00" 00000000 donnée X"7F" 01111111
07 X"7E" 01111110 donnée X"7E" 01111110
08 X"FE" 11111110 donnée X"FE" 11111110

00 X"08" 00001000 ACCU = ACCU 00000000
NOR mem[8] 00000001
01 X"47" 01000111 ACCU = ACCU 00000001
+ mem[7] 01111111
02 X"86" 10000110 mem[6] = ACCU
03 X"C4" 11000100 PC = 04 01111111
04 X"C4" 11000100
05 X"00" 00000000 donnée X"00" 00000000
06 X"00" 00000000 donnée X"7F" 01111111
07 X"7E" 01111110 donnée X"7E" 01111110
08 X"FE" 11111110 donnée X"FE" 11111110

00 X"08" 00001000 ACCU = ACCU 00000000
NOR mem[8] 00000001
01 X"47" 01000111 ACCU = ACCU 00000001
+ mem[7] 01111111
02 X"86" 10000110 mem[6] = ACCU
03 X"C4" 11000100 PC = 04 01111111
04 X"C4" 11000100 PC = 04 01111111
05 X"00" 00000000 donnée X"00" 00000000
06 X"00" 00000000 donnée X"7F" 01111111
07 X"7E" 01111110 donnée X"7E" 01111110
08 X"FE" 11111110 donnée X"FE" 11111110

Plan
1 Introduction
Unité opérative
Unité de contrôle
Mémoire
4 Processeur 8 bits
Architecture
Macro-instructions
6 Travaux Pratiques

Macro-instructions
Abréviation Code assembleur Contenu de ACCU

CLR NOR @allone 1 ACCU NOR 11111111 = 00000000
LDA adr NOR @allone 1 ACCU NOR 11111111 = 00000000
ADD adr ACCU + mem[adr] = mem[adr]
NOT NOR @zero 2 ACCU NOR 00000000 = NOT(ACCU)
SUB adr NOR @zero 2 ACCU NOR 00000000 = NOT(ACCU)
ADD adr ACCU + mem[adr] = NOT(ACCU) + mem[adr]
ADD one 3 ACCU + 1 = NOT(ACCU) + mem + 1
(1) mem[@allone] = 11111111

(2) mem[@zero] = 00000000
(3) mem[@one] = 00000001

Exercices
On souhaite calculer le complément à deux d’un nombre stocké dans la

mémoire à l’adresse 63.
Ecrivez le pseudo-code qui permet d’implémenter cet algorithme.
Ecrivez le code assembleur qui permet d’exécuter cet algorithme sur
le processeur 8 bits.
Un peu plus difficile :
Ecrivez un code assembleur qui compare deux valeurs stockées en
mémoire
Ecrivez un code assembleur qui charge une valeur et la décale de un
bit vers la gauche
Ecrivez un code assembleur qui calcule le NAND de deux valeurs
stockées en mémoire

Utilisation du bit carry pour faire un test de nullité
Constat : Si on ajoute une valeur V non-nulle au nombre xFF, la retenue

sortante c7 vaut 1 sinon elle vaut 0.
c7 c6 c5 c4 c3 c2 c1 c0
v7 v6 v5 v4 v3 v2 v1 v0
+ 1 1 1 1 1 1 1 1
s7 s6 s5 s4 s3 s2 s1 s0
Si on execute une instruction ADD allone, la valeur de la carry

sortante nous indique si le contenu d’ACCU était nul ou non :
ACCU ACCU + xFF carry

0 xFF 0
6= 0 >xFF 1

Utilisation du bit carry pour faire un saut conditionnel
Abréviation Code assembleur Contenu de ACCU
JUMP to adr if (ACCU==0) ADD @allone 1 ACCU + 11111111

JCC adr
JUMP to adr if (ACCU==V) ADD @CA2(V)1 ACCU - V

ADD @allone 1 ACCU + 11111111
JCC adr
(1) mem[@allone] = 11111111

(2) mem[@CA2(V)] = contient le complément à 2 de la valeur V

Exercices
Trouvez la suite d’instructions qui permet de :
tester si ACCU>0,
tester si ACCU≥0,
tester si ACCU<0,
tester si ACCU≤0.
Trouvez la suite d’instructions qui permet de :
tester si ACCU> V ,
tester si ACCU≥ V ,
tester si ACCU< V ,
tester si ACCU≤ V .
Un peu plus difficile :
Ecrivez un code assembleur qui implèmente une boucle for qui permet
d’incrémenter une valeur de 0 à 7,
Ecrivez un code assembleur qui compare deux valeurs et les stocke
dans l’ordre croissant,
Ecrivez un code assembleur qui ordonne 4 valeurs dans l’ordre
décroissant.
Plan
1 Introduction
Unité opérative
Unité de contrôle
Mémoire
4 Processeur 8 bits
Architecture
Macro-instructions
6 Travaux Pratiques

Compilation - définition
Le processus de compilation consiste à traduire un algorithme décrit dans

un langage de haut-niveau en une suite d’instructions assembleurs
executables par une machine programmable.

Définition du PGCD et algorithme
Le Plus Grand Commun Diviseur (PGCD) de deux nombres entiers naturels

est le plus grand entier naturel qui divise simultanément ces deux entiers.
Il existe plusieurs méthodes pour trouver cet entier naturel. L’une

d’entre-elles est l’algorithme des différences ou des soustractions
successives. Le principe est le suivant :
Si un nombre est diviseur de 2 nombres a et b alors il est aussi un diviseur
de leur différence. Si cette différence est positive alors on remplace a par
la valeur de la différence sinon on remplace b par la valeur de la différence

Exemple et exercices
Exemple : a = 60 et b = 36
60 − 36 = 24 alors le PGCD est aussi diviseur de 24 et on remplace 60
par ce nombre,
24 − 36 = −12 alors le PGCD est aussi diviseur de 12 et on remplace
36 par ce nombre,
24 − 12 = 12 alors le PGCD est aussi diviseur de 12 et on remplace 24
par ce nombre,
12 − 12 = 0 alors le PGCD est 12.
Exercice 1 : Avec l’algorithme précédemment énoncé, calculez le
PGCD de 40 et 24 puis de 14 et 29.
Exercice 2 : Ecrivez le pseudo-code de cet algorithme et transformez
le pour qu’il utilise le jeu d’instructions du proceseeur 8 bits.

PGCD
Pseudo-code Version 1 :
diff = a-b
while(diff != 0)
diff = a-b
if(diff < 0)
b = -diff
else
a = diff
end if
end while

PGCD
Pseudo-code Version 2 : on utilise l’ACCU
ACCU = a-b
while(ACCU != 0)
ACCU = a-b // ACCU = diff
if(ACCU < 0)
b = -ACCU // b = - diff
else
a = ACCU // a = diff
end if
end while

PGCD
Pseudo-code Version 3 : on remplace le while et le if par des

instructions de saut
START: ACCU = a-b // ACCU = diff

JUMP TO NEG IF ACCU < 0
JUMP TO END IF a eq 0
JUMP TO START
NEG: b = -ACCU // b = -diff

JUMP TO START
END: JUMP TO END

PGCD
Pseudo-code Version 4 : on détaille les opérations arithmétiques et
logiques avec NOR et ADD uniquement
START: ACCU = ACCU NOR xFF // ACCU = 0
ACCU = ACCU NOR b // ACCU = NOT(b)
ACCU = ACCU + 1 // ACCU = -b
ACCU = ACCU + a // ACCU = a - b = diff
JUMP TO END IF a eq 0
JUMP TO START
NEG: ACCU = ACCU NOR x00 // ACCU = not(diff)

ACCU = ACCU + 1 // ACCU = - diff
b = ACCU
JUMP TO START
END: JUMP TO END

PGCD
Il reste à détailler les JUMP en utilisant la carry de l’UAL
Rappel : Carry=1 ssi le résultat de l’UAL dépasse la valeur 255 en
non-signé
<=> JUMP TO NEG IF -ACCU > 0
Sol. 1 :
ACCU = -ACCU
ACCU = ACCU + 128
JUMP TO NEG IF CARRY=0
Sol.2 : Hypothèse : ACCU contient le résultat de la soustraction de deux
nombres positifs : diff = a - b
Si le résultat est positif, alors carry = 1
Si le résultat est négatif, alors carry = 0
JUMP TO NEG SI CARRY=0
PGCD
Pseudo-code Version 5 : on détaille les opérations de saut
START: ACCU = ACCU NOR xFF // ACCU = 0
ACCU = ACCU NOR b // ACCU = NOT(b)
ACCU = ACCU + 1 // ACCU = -b
ACCU = ACCU + a // ACCU = a - b = diff
JCC NEG
ACCU = ACCU + xFF
JCC END
JCC START
NEG: ACCU = ACCU NOR x00 // ACCU = not(diff)

ACCU = ACCU + 1 // ACCU = - diff
b = ACCU
JCC START
END: JCC END

Code binaire
Adresse Mem Mem Interprétation Mem en binaire Mem en hex
(hexa.) (hexa.) (bin.) après execution après execution
00
01
02
03
04
05
06
07
08
09
0A
0B
0C
0D
0E
0F
10
11
12
13

Code binaire
Adr. Mem Mem Interprétation Mem en hex Mem en binaire

(hexa.) (hexa.) (bin.) après execution après execution
00 0F 00 001111 ACCU = ACCU NOR Mem[x0F] - -
01 12 00 010010 ACCU = ACCU NOR Mem[x12] - -
02 50 01 010000 ACCU = ACCU + Mem[x10] - -
03 53 01 010011 ACCU = ACCU + Mem[x13] - -
04 C9 11 001001 JCC(Mem[x09]) if carry = 0 - -
05 93 10 010011 Mem[x13] = ACCU - -
06 4F 01 001111 ACCU = ACCU + Mem[x0F] - -
07 CD 11 001101 JCC(x0D) if carry = 0 - -
08 C0 11 000000 JCC(x00) if carry = 0 - -
09 11 00 010001 ACCU = ACCU NOR Mem[x11] - -
0A 50 01 010000 ACCU = ACCU + Mem[x10] - -
0B 92 10 010010 Mem[x12] = ACCU - -
0C C0 11 000000 JCC(x00) if carry = 0 - -
0D CD 11 001101 JCC(x0D) if carry = 0 - -
0E CD 11 001101 JCC(x0D) if carry = 0 - -
0F FF 11111111 donnée "allone" FF 11111111
10 01 00000001 donnée :1 01 00000001
11 00 00000000 donnée :0 00 00000000
12 28 00101000 donnée : b = 40 00 00000000
13 18 00011000 donnée : a = 24 08 00001000

Plan
1 Introduction
Unité opérative
Unité de contrôle
Mémoire
4 Processeur 8 bits
Architecture
Macro-instructions
6 Travaux Pratiques

Mémoire

Unité de traitement
Registre ACCU
UAL : NOR et ADD uniquement
Registre carry
STA écrit le contenu de ACCU dans le mémoire et réinitialise carry
Quelle est la taille de l’ACCU ?
Définissez l’architecture globale de l’unité de traitement.
Détaillez l’ensemble des signaux d’entrée/sortie.
Détaillez l’ensemble des signaux de contrôles.

Unité de mémorisation
Architecture Von Neumann (prog. et données partagent la mémoire)

Bus de données (1 entrée et 1 sortie)
Bus d’adresse
Signaux de contrôles
Quelle est la taille du bus de données ?
Quelle est la taille du bus d’adresse ?
Quelle est la capacité totale de la mémoire ?
Détaillez l’ensemble des signaux d’entrée/sortie de la mémoire.
Donnez la description VHDL de cette mémoire.

Unité de contrôle
Compteur de programme (PC)

Registre d’instruction (RI)
Machine d’état
Quelle est la taille du PC et du RI ?
Détaillez l’ensemble des signaux d’entrée/sortie.
Détaillez l’ensemble des signaux de contrôles.
Définissez la machine d’état

FSM : affectation des sorties
INIT FETCH FETCH DECODE FETCH FETCH

INS INS DLY OP OP DLY
clear PC
enable PC
load PC
load RI
sel adr
load R1
load accu
sel UAL
clear carry
load carry
enable mem
W mem

EXE EXE STORE STORE

NOR_ADD JCC DLY
clear PC
enable PC
load PC
load RI
sel adr
load R1
load accu
sel UAL
clear carry
load carry
enable mem
W mem

INIT FETCH FETCH DECODE FETCH FETCH

INS INS DLY OP OP DLY
clear PC 1 0 0 0 0 0
enable PC 0 0 0 0 0 0
load PC 0 0 0 0 0 0
load RI 0 0 1 0 0 0
sel adr 0 0 0 1 1 1
load R1 0 0 0 0 1 1
load accu 0 0 0 0 0 0
sel UAL 0 0 0 0 0 0
clear carry 1 0 0 0 0 0
load carry 0 0 0 0 0 0
enable mem 0 1 1 0 1 1
W mem 0 0 0 0 0 0

EXE EXE STORE STORE

NOR_ADD JCC DLY
clear PC 0 0 0 0
enable PC 1 carry 0 1
load PC 0 not(carry) 0 0
load RI 0 1 0 0
sel adr 1 1 1 1
load R1 0 0 0 0
load accu 1 0 0 0
sel UAL codeop(0) 0 0 0
clear carry 0 carry 0 0
load carry codeop(0) 0 0 0
enable mem 0 0 1 1
W mem 0 0 1 0

Plan
1 Introduction
Unité opérative
Unité de contrôle
Mémoire
4 Processeur 8 bits
Architecture
Macro-instructions
6 Travaux Pratiques

Objectifs
Décrire le processeur en VHDL

Simuler son fonctionnement à l’aide d’un testbench
L’implémenter sur circuit FPGA
Envoyer un programme depuis le PC
Executer le programme sur le processeur
Récupérer le contenu de la mémoire après éxecution

Description VHDL
Règles à suivre :
Signal de reset (rst) asynchrone actif à 1
Synchronisation sur front montant d’horloge (clk)
Signal d’activation (ce) actif à ’1’ dans TOUS les process séquentiels
Partir du top level : CPU_bootloader.vhd
TO DO :
Créer un projet Vivado
Ajouter les fichiers sources
Décrire les blocs
Instancier les blocs dans UC, UT, UM

Top level VHDL fourni : CPU_bootloader.vhd
boot
UC UT
boot
1
tx
Boot Loader rx
boot
boot boot scan memory
ENABLE R/W ADR D OUT D IN
UM

CPU 8 bits avec Bootloader
carry 8
boot
FSM UAL
8
6 8
2 6
R1 ACCU
RI PC 8
boot
6
1
8 6 8
tx
Boot Loader rx
boot
RAM

CPU 16 bits avec Bootloader
16
carry
boot
FSM UAL
16
6 16
2 6
R1 ACCU
RI PC 16
boot
6
1
16 6 16
tx
Boot Loader rx
boot
RAM

Fonctionnement du Boot Loader
Au démarrage, le BL met signal boot=’1’

Le BL attend le programme sur le port série (rx)
Le programme est transmis sur le port série depuis l’exterieur (fichier
texte en simu, port série du PC sur FPGA)
Dés que le BL reçoit un octet complet, il l’écrit dans la mémoire en
partant de l’adresse 0x00
Une fois que le BL a reçu 64 Octets et qu’ils sont dans la mémoire, il
met boot=’0’
Le CPU peut alors exécuter le programme
On laisse suffisamment de temps au CPU pour finir l’éxecution
En positionant scan_memory=’1’, le BL lit la mémoire octet par
octet et transmet le programme sur son port série (tx)

Simulation VHDL
Test bench fourni
Envoi contenu fichier texte octet par octet
Vérifier le contenu du fichier ram_out.txt une fois que le scan de la
mémoire est terminé
program.txt read int file.vhd UART fifoed send.vhd

0xOF 8
0x13
0x50
0x52
0xC9
... 1
rx
CPU bootloader.vhd
scan memory
process ce
rst
clk tx
1
RAM out.txt
0xOF write int file.vhd UART recv.vhd
0x13 8
0x50
0x52
0xC9
...

Implémentation sur circuit FPGA
Ajouter le fichier xdc (scan_memory sur un bouton poussoir et rx et

tx sur UART)
Faire la synthèse et la génération du bitstream
Reconfigurer le FPGA avec le bitstream

Envoi du programme depuis un PC
Une fois le FPGA configuré :

Répérer dans le repertoire /dev/, le nom du port sur lequel est
connecté la carte FPGA : habituellement /dev/ttyUSB0 ou
/dev/ttyUSB1
Ouvrir un terminal sur le port série :
minicom -w -D /dev/ttyUSB1 -b 115200 -H
Faites un appui sur le reset de la carte (bouton central)
Envoyer le programme depuis le port série du PC vers le FPGA :
./send_prog.sh pgcd.hex /dev/ttyUSB1
Faites un appui sur le bouton haut (scan memory)
Vérifier le contenu du programme dans le port série

Microprocesseur Conception

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Microprocesseur Conception

Transféré par

Droits d'auteur :

Formats disponibles

EN 210 : Conception d’un processeur avec jeu

Camille Leroux (Bordeaux INP) EN210 - Conception processeur 1 / 73

Camille Leroux (Bordeaux INP) EN210 - Conception processeur 2 / 73

+ Savoir distinguer une architecture dédiée d’une architecture

Camille Leroux (Bordeaux INP) EN210 - Conception processeur 3 / 73

Camille Leroux (Bordeaux INP) EN210 - Conception processeur 5 / 73

A partir d’une spécification algorithmique, comment concevoir un circuit

Camille Leroux (Bordeaux INP) EN210 - Conception processeur 6 / 73

La conception consiste à définir l’architecture

Camille Leroux (Bordeaux INP) EN210 - Conception processeur 7 / 73

Pour un algorithme donné, on peut imaginer une infinité

Camille Leroux (Bordeaux INP) EN210 - Conception processeur 8 / 73

Dans ce type d’architecture, on implémente uniquement les ressources

Dans ce type d’architecture, l’algorithme est traduit en une succession

ASIP : Application Specific Instruction set Processor

Camille Leroux (Bordeaux INP) EN210 - Conception processeur 11 / 73

N’importe qu’elle architecture de système numérique peut-être décrite sous

Camille Leroux (Bordeaux INP) EN210 - Conception processeur 12 / 73

Chaque porte/bascule est faite "à la main" (dimensionnement des

Camille Leroux (Bordeaux INP) EN210 - Conception processeur 13 / 73

Chaque porte/bascule est "mappée" sur une cellule pré-caractérisées

L’idée maitresse est de fabriquer le circuit (intégration) AVANT

Camille Leroux (Bordeaux INP) EN210 - Conception processeur 17 / 73

Processeur : Unité opérative + Unité de contrôle

Unité de contrôle commande

Camille Leroux (Bordeaux INP) EN210 - Conception processeur 18 / 73

Camille Leroux (Bordeaux INP) EN210 - Conception processeur 19 / 73

Camille Leroux (Bordeaux INP) EN210 - Conception processeur 20 / 73

Camille Leroux (Bordeaux INP) EN210 - Conception processeur 20 / 73

Camille Leroux (Bordeaux INP) EN210 - Conception processeur 20 / 73

Camille Leroux (Bordeaux INP) EN210 - Conception processeur 21 / 73

Camille Leroux (Bordeaux INP) EN210 - Conception processeur 22 / 73

Camille Leroux (Bordeaux INP) EN210 - Conception processeur 22 / 73

Camille Leroux (Bordeaux INP) EN210 - Conception processeur 22 / 73

Camille Leroux (Bordeaux INP) EN210 - Conception processeur 22 / 73

Camille Leroux (Bordeaux INP) EN210 - Conception processeur 22 / 73

Camille Leroux (Bordeaux INP) EN210 - Conception processeur 23 / 73

Le modèle d’architecture de Von Neumann est le modèle le plus utilisé

Déclinaison de base Déclinaison 1 Déclinaison 2

Camille Leroux (Bordeaux INP) EN210 - Conception processeur 25 / 73

Haute technologie (rapide et plutôt chère),

Camille Leroux (Bordeaux INP) EN210 - Conception processeur 26 / 73

Camille Leroux (Bordeaux INP) EN210 - Conception processeur 27 / 73

Camille Leroux (Bordeaux INP) EN210 - Conception processeur 27 / 73

Camille Leroux (Bordeaux INP) EN210 - Conception processeur 27 / 73

Camille Leroux (Bordeaux INP) EN210 - Conception processeur 28 / 73

Camille Leroux (Bordeaux INP) EN210 - Conception processeur 29 / 73

Camille Leroux (Bordeaux INP) EN210 - Conception processeur 30 / 73

Unité de contrôle Unité opérative

Camille Leroux (Bordeaux INP) EN210 - Conception processeur 32 / 73

Camille Leroux (Bordeaux INP) EN210 - Conception processeur 33 / 73

(1) AAAAAA : bits d’adressage ;

Adresse[00,04] : instructions mémorisées ; Adresse[05,08] : données mémorisées

Camille Leroux (Bordeaux INP) EN210 - Conception processeur 35 / 73

Adresse[00,04] : instructions mémorisées ; Adresse[05,08] : données mémorisées

Camille Leroux (Bordeaux INP) EN210 - Conception processeur 36 / 73

Adresse[00,04] : instructions mémorisées ; Adresse[05,08] : données mémorisées

Camille Leroux (Bordeaux INP) EN210 - Conception processeur 36 / 73

Adresse[00,04] : instructions mémorisées ; Adresse[05,08] : données mémorisées

Camille Leroux (Bordeaux INP) EN210 - Conception processeur 36 / 73

Adresse[00,04] : instructions mémorisées ; Adresse[05,08] : données mémorisées

Camille Leroux (Bordeaux INP) EN210 - Conception processeur 36 / 73

Adresse[00,04] : instructions mémorisées ; Adresse[05,08] : données mémorisées