Rapport mini-projet VHDL Calculateur de Harvard - Projet Budgie ...

LEFEVRE CHALOPIN ELEC II

Juin 2007

Rapport mini-projet VHDL Calculateur de Harvard

LEFEVRE CHALOPIN

Calculateur de Harvard Juin 2007

1

Table des matières 1.Introduction....................................................................................................................................... 4 2. Modèle de programmation du calculateur........................................................................................ 4 A. Format registre............................................................................................................................ 5 B. Format immédiat......................................................................................................................... 6 C. Format branchement....................................................................................................................6 3. Architecture de Harvard................................................................................................................... 7 A. La mémoire de données.............................................................................................................. 8 B. Le chemin de données.................................................................................................................9 B.1 Le fichier de registres......................................................................................................... 10 B.2 L’unité fonctionnelle.......................................................................................................... 10 B.3 Le bloc zero fill.................................................................................................................. 11 B.4. Description en VHDL....................................................................................................... 11 C. L’unité de contrôle.................................................................................................................... 12 C.1 Le compteur ordinal........................................................................................................... 12 C.2 Le décodeur d’instructions................................................................................................. 12 C.4 Le Bloc Branch control...................................................................................................... 13 C.5 Description en VHDL........................................................................................................ 14 D. Le calculateur complet..............................................................................................................14 4.Descriptif du travail......................................................................................................................... 16 4.A La Mémoire de données..........................................................................................................16 Simulations et validations :....................................................................................................... 17 4.B Le Data Path............................................................................................................................19 4.B.1. Le banc de registre.....................................................................................................19 4.B.2. Les flags (indicateurs):.............................................................................................. 21 4.B.3. Le zero fill:................................................................................................................ 21 4.B.4. Les multiplexeurs:..................................................................................................... 21 4.B.5. L'unité fonctionnelle:................................................................................................. 21 4.B.6. Simulations et validations:.........................................................................................22 4.C L'unité de Contrôle..................................................................................................................23 4.C.1 La mémoire d'instructions:.............................................................................................. 24 4.C.2 Le Branch Control:.......................................................................................................... 24 4.C.3 Le Bloc d'extension:........................................................................................................ 25 4.C.4 Extraction de l'instruction:...............................................................................................25 4.C.5 Le Compteur de Programme........................................................................................... 25 4.C.6 Décodage :....................................................................................................................... 25 4.D Le calculateur Complet........................................................................................................... 26 Simulations et validations:................................................................................................... 27 5. Conclusion:.....................................................................................................................................28 6. Annexes.......................................................................................................................................... 29 6.A Mémoire:.................................................................................................................................29 6.A.1 memoire.vhd....................................................................................................................29 6.A.1 Testmemoire.vhd.............................................................................................................32 6.A.3 program.txt...................................................................................................................... 35 6.A.4 SimuMemoire.txt............................................................................................................ 36 6.A.5 Chronogrammes.............................................................................................................. 37 6.B DataPath:................................................................................................................................. 38 6.B.1 DataPath.vhd................................................................................................................... 38 6.B.2 TestDataPath.vhd............................................................................................................ 42 LEFEVRE CHALOPIN


2

6.B.3 initReg.txt........................................................................................................................ 45 6.B.4 SimuDataPath.txt.............................................................................................................46 6.B.5 Chronogrammes.............................................................................................................. 48 6.C Unité de Contrôle:................................................................................................................... 49 6.C.1 Ctrl Unit.vhd....................................................................................................................49 6.C.2 TestCtrl_Unit.vhd............................................................................................................53 6.C.3 programRom.txt.............................................................................................................. 55 6.C.4 SimuCtrl_Unit.txt............................................................................................................ 56 6.C.5 Chronogrammes:............................................................................................................. 58 6.D Le calculateur de Harvard:......................................................................................................59 6.D.1 HarvardCalculator.vhd.................................................................................................... 59 6.D.2 testHarvardCalculator.vhd.............................................................................................. 62 6.D.3Chronogrammes............................................................................................................... 63

LEFEVRE CHALOPIN


3

Avant-propos Le mini-projet qui vous est proposé de réaliser vise comme objectif essentiel de faire la synthèse de toutes vos connaissances accumulées dans le module d’enseignement VHDL. Il permet également de parfaire des connaissances dispensées dans d’autres modules en proposant une description d’une architecture dont les principes ont pu être étudiés dans ces modules. Enfin, ce mini-projet est destiné à vous permettre de développer une première expérience pratique de la modélisation VHDL, dans des conditions proches de celles d’un fonctionnement en entreprise.

1. Introduction Les circuits non programmables déterminent les opérations à exécuter sur la base uniquement de ces entrées de contrôle et de bits d’états du chemin de données. Un tel circuit n’exécute donc qu’une seule opération définie (ex : multiplication par additions et décalages, affichage d’une donnée décimale, etc). Par opposition, un microprocesseur est responsable de l’extraction d’instructions depuis la mémoire et du séquencement de l’exécution de ces instructions (calcul de l’adresse suivante de l’instruction à exécuter). Dans ce type d’architecture, le microprocesseur est composé d’un chemin de données dont les opérations sont pilotées par une unité de contrôle. La tâche de cette unité de contrôle consiste à extraire, décoder et exécuter les instructions. Un calculateur bâtit sur le modèle de harvard possède la faculté de traiter l’ensemble de ces opérations en un cycle d’horloge élémentaire. La séparation physique des données et instructions dans deux composants distincts est une des conditions indispensable. L’interconnexion de ces composants au travers de signaux permettant de propager les signaux de données ainsi que signaux de contrôle permettra de définir le modèle interne du microprocesseur. L’objectif du projet est de décrire le comportement des différents composants de ce modèle interne, modèle qui sera vérifié par simulation VHDL sous ModelSim.

2. Modèle de programmation du calculateur Le programmeur d’un calculateur doit spécifier les instructions à exécuter à l’aide d’un programme. Un programme peut donc se définir comme une liste d’instructions spécifiant les opérations (code opération) et leurs opérandes. Il peut également s’agir d’instructions de contrôle du déroulement du programme indiquant des branchements conditionnels ou inconditionnels à effectuer. Le registre compteur ordinal (PC) permet de conserver en mémoire l’adresse de la prochaine instruction à exécuter.

Les instructions sont stockées dans une mémoire d’instructions tandis que les opérandes peuvent être stockées dans différents emplacements : LEFEVRE CHALOPIN


4

un champ de l’instruction un registre dans un fichier de registres un emplacement mémoire de données

Par conséquent, outre la nature de l’opération à exécuter, le code opération doit préciser les modalités d’exécution de l’instruction et préciser l’emplacement des opérandes à utiliser. On parle de format d’instruction ou encore de méthode d’adressage (Figure 1). Le format des instructions qui nous intéresse ici est un format fixe (toutes les instructions sont codées sur un nombre de bits identique). Le format utilisé dans le cadre de notre calculateur fait apparaître l’utilisation de 3 champs adresse/opérande. On distingue par ailleurs 3 formats d’instruction différents:

A. Format registre Dans le cas d’un format registre, les 3 champs fournissent un n° de registre à utiliser comme emplacement des opérandes source A,B ou comme emplacement destinataire du résultat. Les champs étant codés sur 3 bits, on peut désigné jusqu’à 8 registres (23). Un des champs source peut s’avérer non significatif lorsque l’instruction n’a besoin que d’un seul opérande. Par exemple, l’instruction codée 0001011 011 101 XXX code machine NOT R3 R5 assembleur

définit une instruction de complément à 1 (NOT) du registre n°5 (Reg src A), résultat dans le registre n°3 (destination). La valeur des bits du champ B n’est pas significative. On notera que certaines opérations utilisent le champ B au lieu du champ A. Le champ registre destinataire peut également ne pas s’avérer significatif lorsqu’il s’agit d’un transfert vers la mémoire, un des registres stockant l’adresse mémoire pour le transfert. Par exemple, l’instruction codée 0100000 XXX 100 101 code machine ST R4,R5 assembleur

LEFEVRE CHALOPIN


5

définit une demande de transfert de la valeur de R5 à l’emplacement mémoire d’adresse contenue dans R4.

B. Format immédiat Dans le cas d’un format immédiat, un des opérandes est implicitement stocké dans l’instruction, dans le champ de droite en l’occurrence ici. Il s’agit donc d’une constante dont la valeur se situera dans l’intervalle 0 à 7. Par exemple, 1000010 010 111 011 code machine ADI R2 R7 3 assembleur

spécifie une opération d’addition de R7 avec la constante 3, avec résultat de l’opération dans R2.

C. Format branchement Par opposition aux deux formats précédents, le dernier format d’instruction n’engendre aucune modification de registre ou de mémoire de données. L’instruction est destinée à modifier (éventuellement sous condition) l’ordre d’extraction des instructions de la mémoire, séquentiel par défaut On parle encore d’instructions de rupture de séquence. Pour cela, le champ d’adresse est séparé en deux parties , avec les 3 bits de poids forts situés dans le champ adresse(G) et les trois bits de poids faibles situés dans le champ adresse (D). La méthode d’adressage est appelée adressage relatif au PC, les 6 bits d’adresses formant le déplacement à ajouter au PC. Ce déplacement est considéré comme signé (représentation en complément à 2). Cela permet de se déplacer dans le sens croissant ou décroissant des adresses. Par exemple, 1100000 101 110 100 BRZ R6,-20

spécifie un branchement à l’adresse PC – 20(101100), si R6=0.

LEFEVRE CHALOPIN


6

La table de la Figure 3 liste les différentes catégories d’instruction. Une description de type transfert de registre explique le mode opératoire de chacune des instructions. La colonne de droite précise si les indicateurs N (pour négatif) et Z (pour zéro) sont affectés par les instructions.

3. Architecture de Harvard On s’intéresse à présent à l’architecture du calculateur permettant l’exécution des instructions définit précédemment, en un seul cycle d’horloge. Pour réduire la complexité du modèle, on se propose de décomposer le calculateur en trois entités élémentaires: l’unité de contrôle le chemin de données la mémoire centrale des données Comme le montre la Figure 4, l’unité de contrôle pilote le chemin de données grâce à un mot de contrôle. Ce mot de contrôle est formé d’un ensemble de signaux de contrôle permettant de positionner le chemin de données en fonction de l’instruction à exécuter. D’horloge.

Une constante (Opérande immédiat) permet également la récupération de valeur de l’opérande depuis la mémoire d’instructions dans le cas de l’adressage immédiat. Le chemin de données LEFEVRE CHALOPIN


7

communique avec la mémoire de données grâce à deux bus unidirectionnels, selon le sens du transfert à réaliser. Cette particularité, propre à l’architecture harvard, est l’une des particularités (avec la séparation des mémoires d’instructions et de données) autorisant l’exécution des instructions nécessitant des accès en lecture et en écriture dans le même cycle d’horloge.

A. La mémoire de données La mémoire de données est une mémoire de 216 éléments (adresses) de 16 bits chacun. L’opération d’écriture est autorisée par le signal de commande MW (pour memory write) sur niveau haut. La valeur du mot de 16 bits correspondant à l’adresse est accessible en permanence sur le bus en lecture. L’adresse du mot en lecture et en écriture est donc commune et toute valeur inscrite dans la mémoire modifie la valeur en sortie une fois celle-ci transférée.

Son comportement sera décrit par un process manipulant une variable de type tableau, process synchrone à l’horloge clk. Le contenu devra pouvoir être initialisé pour mémoriser les données initiales avant exécution du programme(signal rst). Pour cela plusieurs solutions sont possibles avec, dans l’ordre de flexibilité: • initialisation dans le programme VHDL au niveau de la déclaration : cette solution est la plus simple mais elle suppose une recompilation de la description pour tout changement de contenu. • déclaration d’un paramètre générique avec initialisation du contenu sur un signal rst. Cette solution ne nécessite plus que la re-compilation de l’entité test en cas de modification du contenu. Mais, il vous faudra définir un package pour déclarer le type de ce paramètre. • Lecture des données initiales lues à partir d’un fichier : c’est la solution la plus souple car elle ne nécessite aucune recompilation. C’est également la solution la plus proche de la réalité.Vous pouvez définir une fonction load_program, fonction réalisant le chargement de la mémoire au rst. Vous sélectionnerez une des 3 méthodes, au choix. Le bus d’adresse sera de type unsigned, tandis que les bus de données seront de type signed (package numeric_bit de la bibliothèque ieee). La fonction de conversion to_integer vous permettra de convertir le type unsigned de l’adresse sous forme d’entier, de manière à pouvoir indicer correctement le tableau. On prendra 4 ns comme délai de propagation en lecture ou écriture.

LEFEVRE CHALOPIN


8

B. Le chemin de données Différents composants forment la structure du chemin de données partagé. On peut distinguer: un banc de registres, mémoire rapide interne au processeur composé de 8 registres de 16 bits chacun. une unité fonctionnelle, circuit combinatoire réalisant des opérations arithmétiques, logiques, décalages ou simples transferts. quelques multiplexeurs permettant de configurer le chemin de données en fonction du mot de contrôle.

A titre d’illustration, la table ci-dessous montre quelques exemples de micro-opérations réalisées par le chemin de données selon l’état du mot de contrôle. Pour chaque microopération, le multiplexeur MB est positionnée en mode registre ou constante. Dans le premier cas, l’opérande utilisé par l’unité fonctionnelle provient du fichier de registre.. Dans le second cas, l’opérande provient de l’extérieur (de la mémoire d’instructions de l’unité de contrôle) et passe de 3 à 16 bits par ajout de 13 bits à zéro en tête. Le multiplexeur MD permet d’aiguiller le résultat d’une opération ou une donnée de la mémoire de données (data in) vers un registre du fichier. Les 4 bits FS définissent la nature de l’opération à effectuer le cas échéant. Finalement, RW précise si un registre doit être modifié (1) ou non (0).

LEFEVRE CHALOPIN


9

B.1 Le fichier de registres Comme pour la mémoire de données, le banc de registre enregistre les données à l’adresse DR sur un niveau haut de RW. La lecture des données s’effectue sur deux bus distincts, le bus A et le bus B. La présence des données en sortie est permanente et fonction des adresses respectives DA et DB. On notera que les écritures sont synchrones à l’horloge et sont effectuées au début du cycle d’horloge suivant la fin du traitement de l’instruction courante.

B.2 L’unité fonctionnelle

LEFEVRE CHALOPIN


10

L’unité fonctionnelle est capable de réaliser différentes opérations s’étendant de la simple opération de transfert pour les mouvements de données internes au microprocesseur ou les transferts impliquant la mémoire externe de données. La table de vérité complète du composant vous est fournie Figure 7.

B.3 Le bloc zero fill Comme mentionné précédemment, le microprocesseur peut utiliser une donnée implicitement contenu dans l’instruction elle-même. L’UF utilisant des données de 16 bits, 13 bits à zéros sont ajoutés en tête de cette donnée de 3 bits pour respecter cette contrainte. Par exemple, 110 devient 0000000000000110

B.4. Description en VHDL

La description des différents composants du chemin de données s’effectuera à l’aide d’instructions d’affectations concurrentes pour les différents signaux : bus D, dataout, ardout, busB, etc. On n’oubliera pas de décrire le comportement des indicateurs d’états en sortie de l’UF avec comme convention: • Z =1 si le résultat de l’opération est nul • N=1 si le résultat de l’opération est négatif. La description des indicateurs C(carry) et V(overflow) sera facultative. Le signal rst permettra de positionner les registres dans un état initial souhaité. On retiendra les temps de propagation • Lecture ou écriture d’un registre du fichier de registre : 3 ns • Multiplexeurs (MD ou MB) et indicateurs: 1 ns • Unité fonctionnelle : 4 ns On notera que des conversions unsigned-signed peuvent être nécessaire lors, par exemple, de la récupération d’une adresse à partir du bus de données (par un simple « cast »).

LEFEVRE CHALOPIN


11

C. L’unité de contrôle Bien que traditionnellement considérée comme ne faisant pas partie de l’unité de contrôle, la mémoire d’instructions est décrite ici par convenance. Lors de l’exécution du programme, seuls des accès en lecture vers cette mémoire sont possibles.

Outre la mémoire d’instructions (215 x 16 bits), l’unité de contrôle intègre les modules suivants:

C.1 Le compteur ordinal Le compteur ordinal PC fournit l’adresse de l’instruction à extraire de la mémoire (16 bits). Le compteur est mis à jour à chaque cycle d’horloge. Il peut s’agir d’une simple incrémentation, d’un chargement de la valeur en sortie du bloc extension (cas d’un branchement conditionnel) ou de l’adresse (cas d’un branchement inconditionnel). Un signal rst asynchrone (non représenté sur la figure) permet le positionnement sur la première adresse du programme à exécuter (adresse 0 généralement).

C.2 Le décodeur d’instructions La sortie de la mémoire est exploitée par le décodeur de l’instruction, sortie que l’on désignera par IR (IR pour instruction register, même s’il ne s’agit pas d’un registre à proprement parlé).

LEFEVRE CHALOPIN


12

16 bits des 20 bits en sortie du décodeur permettant de contrôler le fonctionnement du chemin de données forment ce qu’on appelle le mot de contrôle. La valeur de 3 bits DA, BA, AA s’obtient de manière directe à partir des champs d’adresse de l’instruction. Il est en de même pour les bits de sélection de l’opération de l’UF (FS) qui sont directement issus des bits de poids faible du code opération de l’instruction, sauf pour l’instruction de branchement conditionnel où les 4 bits de FS seront forcés à zéro. Cela permet l’évaluation des indicateurs Z et N par rapport au contenu du registre adressé par RA. L’etat des autres bits du décodeur est fonction de l’instruction et se définit par la table de vérité ci-dessous (Figure 10). Cette table de vérité montre les différentes catégories d’instructions.

Outre les signaux de commande du chemin de données, on trouve également la valeur des signaux de commande interne à l’unité de contrôle et permettant la gestion du séquencement (PL, JB, BC). La table de vérité montre que PL vaut 1 lorsque le code opération spécifie une instruction de contrôle, JB valant 1 lorsque le branchement est inconditionnel, 0 sinon. Dans le cas d’un branchement conditionnel, BC précise l’indicateur servant de condition de branchement (0 pour Z, 1 pour N).

C.4 Le Bloc Branch control Le rôle de ce bloc est de déterminer la valeur de LD (autorisation de branchement conditionnel) en fonction des valeurs des bits BC,N, Z. Le comportement de ce bloc peut être spécifié par la table de vérité compactée ci-dessous.

LEFEVRE CHALOPIN


13

La table de vérité montre que la valeur de LD dépend de l’indicateur utilisé (déterminé par BC) et de la valeur de cet indicateur. Par exemple, si BC=0, il faut Z=1 pour que le branchement soit effectué.

C.5 Description en VHDL

Comme pour le chemin de données, la description des différents composants s’effectuera à l’aide d’instructions d’affectation concurrentes. Les valeurs non significatives (X) lors du décodage seront forcées à 0. On retiendra les temps de propagation suivants : • Incrémentation ou chargement du PC : 1 ns • Lecture de la mémoire d’instructions : 3 ns • Décodage : 1 ns

D. Le calculateur complet Le calculateur complet (dont les entrées/sorties se limitent aux entrées clk et rst) se décrira en assemblant 2 entités mémoire et CPU, cette dernière entité étant elle-même une entité formée des composants datapath et contrôle.

Le cycle d’horloge devra être réglé par rapport au chemin critique en cumulant les temps de propagation des composants traversés lors de l’exécution d’une instruction la plus longue. LEFEVRE CHALOPIN


14

Comme le montre la Figure 16, le cumul des temps de propagation aboutit à un délai de 17 ns. La fréquence d’horloge maximale est donc de 58.8 MHZ.

LEFEVRE CHALOPIN


15

4.Descriptif du travail Pour réaliser ce mini-projet nous avons choisi de respecter l'ordre conseillé dans les sujets. C'est à dire que nous avons commencé par la conception de la mémoire, puis celle du Data Path et enfin l'Unité de Contrôle.

4.A La Mémoire de données Nous avons conçu l'entité mémoire à l'aide de paramètres génériques pour pouvoir la rendre modulable. Néanmoins nous choisissons d'imposer la même taille pour le bus d'adresse et le bus de donnée. Le temps de propagation dans la mémoire est lui aussi générique. generic(NbBits : natural ; tco : time);

Nous choisissons de définir notre mémoire comme tableau contenant des entiers signés. Sa taille est donc 2^ NbBits-1, nous appelons notre type mémoire MemTableau. type MemTableau is array (0 to 2**NbBits-1) of signed(NbBits-1 downto 0);

D'après la description du cahier des charges, l’écriture dans la mémoire de donnée se fait uniquement sur un niveau haut du signal memory_write (mw). La valeur de datain alors écrite sur la sortie dataout ainsi que dans la mémoire à l’adresse adresse (adr). En mode lecture, on transfère la donnée qui se trouve dans la mémoire à l’adresse adresse sur la sortie dataout. Les écritures sont synchrones mais les lectures doivent pouvoir s’effectuer en permanence. Le process qui décrit le fonctionnement de cette mémoire est donc sensible aux paramètres clk (l’horloge), rst (reset) et adresse. L'entrée rst permet d'initialiser le contenu de la mémoire à partir d'un fichier. mem:process(clk,rst,adr) -- declaration de notre memoire, tabdata represente la memoire comme -- un tableau contenant des entiers signés variable tabdata : MemTableau; begin if (rst= '1') then -- rst asynchrone actif etat bas -- première solution : initialisation dans le programme -- VHDL au niveau de la déclaration -- init_zero: for i in 0 to 2**NbBits-1 loop -- tabdata(i):= (others => std_logic'('0')); -- end loop init_zero; -- solution non retenue -- deuxième solution : Lecture des données initiales lues -- à partir d'un fichier : tabdata := load_program; -- les evenements synchrones à l'horloge elsif ( clk='1' and clk'event) then

LEFEVRE CHALOPIN


16

if(Mw ='1') then --write dataout0 and ligne(1)/='-' then read(ligne,data); mem2(numli):=unsigned(to_bitvector(data)); numli:=numli+1; end if; end loop; return mem2; end initROM; Comme cette mémoire n'est accessible seulement en lecture, nous choisissons d'utliser une constante pour représenter cette mémoire: constant mem_instruc: ROM:=initRom;

4.C.2 Le Branch Control: Le branch Control spécifie au PC s'il faut effectuer un saut d'adresse ou charger une adresse LEFEVRE CHALOPIN


24

externe déterminée par le bloc d'extension. Le comportement du Branch Control est définie dans le cahier des charges.Voici comment nous l'avons décrit en VHDL: LdIR_sur_16_bits(7),3=>IR_sur_16_bits(6), 2=>IR_sur_16_bits(2),1=>IR_sur_16_bits(1),0=>IR_sur_16_bits(0),others=>IR_sur_16_bits(8));

4.C.4 Extraction de l'instruction: L'instruction est chargée à partir de la mémoire depuis l'adresse pointé par PC. Les deux bits de poids faible de l'instruction sont renvoyés vers le bloc d'extension: IR_sur_16_bits 0 and ligne(1) /='-' then read(ligne,adr); read(ligne,data); mem2(adr):=to_signed(data,NbBits); end if; end loop; return mem2; end load_program; ----------- DESCRIPTION ---------begin mem:process(clk,rst,adr) -- declaration de notre memoire, tabdata represente la memoire comme -- un tableau contenant des entiers signés variable tabdata : MemTableau; begin if (rst= '0') then -- rst asynchrone actif etat bas -- première solution : initialisation dans le programme -- VHDL au niveau de la déclaration -- init_zero: for i in 0 to 2**NbBits-1 loop -- tabdata(i):= (others => std_logic'('0')); -- end loop init_zero; -- solution non retenue -- deuxième solution : Lecture des données initiales lues -- à partir d?un fichier : tabdata := load_program; -- les evenements synchrones à l'horloge elsif ( clk='1' and clk'event) then LEFEVRE CHALOPIN


30

if(Mw ='1') then --write dataouttco)port map(datain=>datain_test,Mw=>Mw_test,rst=>rst_test,clk=>clk_test,adr=>adr_test,dataout=>datao ut_test); SIMU:process --declaration des signaux variable datainF: std_logic_vector(NbBits-1 downto 0); variable MwF,rstF: bit; variable adrF: std_logic_vector(NbBits-1 downto 0); variable ligne:line; begin while not endfile(fd) loop readline(fd,ligne); if ligne'length>0 and ligne(1)/='-' then read(ligne,rstF); read(ligne,MwF); read(ligne,adrF); read(ligne,datainF); --affectation des isugnaux lus dans le fichier rst_testIR_sur_16_bits(6),2=>IR_sur_16_bits(2),

LEFEVRE CHALOPIN


50

1=>IR_sur_16_bits(1),0=>IR_sur_16_bits(0),others=>IR_sur_16_bits(8)); -- Extraction d'instruction IR_sur_16_bitsNbBits,tco=>tco)port map(clk=>clk, rst=>rst, Mw=>Mw_uc_to_mem , datain=>data_dp_to_mem,adr=>adr_out_dp_to_mem_and_uc); dp : datapath generic map(NbBits=>NbBits,Nbreg=>Nbreg, twr_reg=>twr_reg,tmux=>tmux,tuf=>tuf) port map (clk=>clk, rst=>rst, V=>V_dp_to_uc, C=>C_dp_to_uc, N=>N_dp_to_uc, Z=>Z_dp_to_uc, ctrlword=>ctrlword_uc_to_dp, cste=>cste_uc_to_dp, data_in=>data_mem_to_dp, data_out=>data_dp_to_mem, adr_out=>adr_out_dp_to_mem_and_uc); uc : Ctrl_Unit generic map(NbBits=>NbBits,t_dec=>t_dec, t_r_mem=>t_r_mem,t_inc_load=>t_inc_load) port map (CLK=>clk, rst=>rst, V=>V_dp_to_uc, C=>C_dp_to_uc, N=>N_dp_to_uc, Z=>Z_dp_to_uc, adr=>adr_out_dp_to_mem_and_uc, Mw=>Mw_uc_to_mem, IR=>cste_uc_to_dp, ctrlword=>ctrlword_uc_to_dp); end struct;

LEFEVRE CHALOPIN


61

6.D.2 testHarvardCalculator.vhd Voici le source VHDL du TestBench du calculateur: entity test_Calculateur is end test_Calculateur; architecture bench of test_Calculateur is ----------- COMPOSANT : Calculateur ---------component CalculateurHarvard is generic (NbBits : natural ); port(CLK,rst:in bit); end component; --declaration des constantes constant NbBits : natural := 16; --declaration des signaux de test signal CLK_test,rst_test:bit; ----------- DESCRIPTION ---------begin calc: CalculateurHarvard generic map (NbBits=>NbBits)port map(CLK=>CLK_test,rst=>rst_test); process begin CLK_test