Cours #9 Conception et réalisation de processeurs à usage général

Plan pour aujourd’hui Mise en contexte Retour sur les processeurs à usage spécifique Processeurs à usage général: introduction Chemin des données Unité de contrôle + Des précisions sur les notes de cours, des exemples et une parenthèse sur VHDL!

La machine distributrice Comment réaliser ce processeur? Concevoir un processeur à usage spécifique? Utiliser un processeur à usage général?

Deux types de processeurs (notes, section 5.1) Deux types de processeurs Un processeur est un type spécial de système numérique dont le but est de traiter des données par une succession d’étapes simples, pouvant résulter en un traitement global complexe. Un processeur doit acquérir des données, les traiter, et produire un résultat sous forme numérique ou vidéo. On distingue deux types principaux de processeurs : Les processeurs à usage général peuvent être programmés. Le programme exécuté par un processeur est gardé en mémoire sous la forme d’une liste d’instructions. On réfère souvent à ce type de processeur par le nom de « microprocesseur ». Un microcontrôleur est un cas particulier d’un processeur à usage général. Un processeur spécialisé est un processeur à usage général auquel on a ajouté des instructions spéciales. Les processeurs à usage spécifique sont des processeurs non programmables qui sont conçus dans le but de répondre à un besoin unique. Ils sont plus simples et plus efficaces que les processeurs à usage général. Ils ne peuvent pas en général être facilement reprogrammés.

Parties d’un processeur (notes, section 5.1) Parties d’un processeur Un processeur est composé de deux parties: Le chemin des données (datapath) traite les données. Il inclut: des registres; des unités fonctionnelles (comme une unité arithmétique et logique) un mécanisme de commutation pour transférer et manipuler les données. L’unité de contrôle (control unit) est responsable du séquençage des opérations à exécuter par le chemin de données selon des entrées externes et le résultat des opérations.

Plan pour aujourd’hui Mise en contexte Retour sur les processeurs à usage spécifique Processeurs à usage général: introduction Chemin des données Unité de contrôle + Des précisions sur les notes de cours, des exemples et une parenthèse sur VHDL!

Exemple de processeur à usage spécifique: transmetteur RS-232 (notes, section 6.4) Exemple de processeur à usage spécifique: transmetteur RS-232 Le chemin des données ne contient que les registres nécessaires. La machine à états de l’unité de contrôle ne peut faire qu’une seule tâche.

Exemple de processeur à usage spécifique: joueur de Blackjack (notes, section 6.7) Exemple de processeur à usage spécifique: joueur de Blackjack Le chemin des données ne contient que les registres nécessaires. La machine à états de l’unité de contrôle ne peut faire qu’une seule tâche.

Du processeur à usage spécifique au processeur à usage général (notes, section 9.1) Du processeur à usage spécifique au processeur à usage général Pour changer la tâche d’un processeur à usage spécifique, il faut: ajouter les registres et structures de calculs nécessaires à son chemin des données; changer la machine à états de son unité de contrôle; et, changer les signaux de contrôle entre le chemin des données et l’unité de contrôle. Un processeur à usage général doit pouvoir effectuer n’importe quelle tâche qu’un processeur à usage spécifique, mais avec: un chemin des données fixe; une unité de contrôle fixe; et, des signaux de contrôle fixes. Un processeur à usage général doit pouvoir être programmé sans changer sa structure ni ses interconnexions. Pour effectuer une tâche différente, au lieu de changer la machine à états, on la traverse de différentes façons en fonction du programme entreposé en mémoire.

Plan pour aujourd’hui Mise en contexte Retour sur les processeurs à usage spécifique Processeurs à usage général: introduction Chemin des données Unité de contrôle + Des précisions sur les notes de cours, des exemples et une parenthèse sur VHDL!

Processeurs à usage général (notes, section 9.1) Processeurs à usage général Certains processeurs à usage général, comme les processeurs Core de Intel et les processeurs FX-8000 de AMD, sont destinés principalement au marché des stations de travail et des ordinateurs portables. Ces circuits sont d’une complexité inouïe et sont le résultat du travail de centaines d’ingénieurs-années. D’autres processeurs, comme les ARM, MIPS, Intel 8051 et TMS320 sont moins bien connus mais sont fréquemment utilisés dans des applications embarquées comme les dispositifs mobiles et le domaine de l’automobile. Les processeurs à usage général sont habituellement fabriqués à très, très grande échelle. Leurs coûts de développement faramineux peuvent donc être répartis sur un très grand nombre d’unités, rendant rentable leur production et mise en marché. Il est intéressant d’observer que le développement de chaque nouvelle génération de processeur se fait à l’aide de stations de travail équipées de processeurs de la génération précédente. En d’autres mots, sans la puissance de calcul des processeurs d’aujourd’hui, on serait incapable de concevoir les processeurs de demain.

(notes, section 9.1) Jeu d’instructions Le jeu d’instructions (Instruction Set Architecture – ISA) est la spécification de toutes les instructions pouvant être effectuées par le processeur, leur encodage numérique, et l’inventaire des ressources mises à la disponibilité des programmeurs (comme des registres, des piles, des coprocesseurs, etc.). Le jeu d’instructions est le contrat entre les concepteurs du processeur et les programmeurs. On peut catégoriser les jeux d’instructions selon plusieurs dimensions. Une dimension concerne la forme du chemin des données du processeur, selon qu’il contient ou non des registres et de la mémoire. Les processeurs de type registre-registre (register-register ou load-store) sont les plus populaires. Pour ce type de processeur, les opérations peuvent être effectuées uniquement sur des valeurs gardées dans des registres. Il est possible de transférer des données entre les registres et la mémoire. Aujourd’hui on considère des processeurs basés sur l’architecture Harvard, c'est-à-dire qui ont des mémoires séparées pour le programme et les données (contrairement à l’architecture Von Neumann). Voir: http://fr.wikipedia.org/wiki/Jeu_d%27instructions

Micro-opérations du chemin des données (notes, section 9.1) Micro-opérations du chemin des données La grande taille du jeu d’instructions d’un processeur à usage général implique qu’il faut pouvoir supporter un grand nombre de micro-opérations. On peut classifier les micro-opérations en trois groupes : le chargement de données de l’extérieur ou une mémoire vers un bloc de registres; la transformation des données grâce à une unité arithmétique et logique; et, l’entreposage de données en mémoire ou leur transfert vers l’extérieur.

Exemple d’aujourd’hui Le processeur au complet (pas dans les notes) Exemple d’aujourd’hui Le processeur au complet

Plan pour aujourd’hui Mise en contexte Retour sur les processeurs à usage spécifique Processeurs à usage général: introduction Chemin des données Unité de contrôle + Des précisions sur les notes de cours, des exemples et une parenthèse sur VHDL!

Architecture d’un chemin des données (notes, section 5.2) Architecture d’un chemin des données Un chemin des données a deux parties principales: un bloc de registres qui conserve les données à traiter et des résultats précédents, de façon à pouvoir combiner toutes ces valeurs dans de nouveaux calculs. des unités fonctionnelles pour effectuer des opérations sur les données conservées dans les registres. Des modules combinatoires permettent de choisir, router et contrôler le flot d’information entre les registres et les unités fonctionnelles. L’unité fonctionnelle peut parfois avoir un état entreposé dans des éléments à mémoire. Information sur un calcul précédent (p. ex. négatif, zéro, etc.). Pour effectuer un calcul sur plusieurs cycles. Pour garder en mémoire une valeur spéciale (p. ex. un accumulateur).

Architecture d’un chemin des données Exemple: processeur BlackFin Le processeur Blackfin est un processeur à usage général, spécialisé pour le traitement du signal et d’images. Analog Devices, BlackFin Embedded Processor ADSP-BF534/ADSP-BF536/ADSP-BF537, 2009.

Chemin des données d’un processeur à usage général (notes, section 9.2) Chemin des données d’un processeur à usage général

Effectuer des opérations (notes, section 9.2.9) Effectuer des opérations Pour effectuer une instruction avec le chemin des données proposé, il s’agit de donner les bonnes valeurs aux différents signaux de contrôle. Supposons que le bloc des registres contient quatre registres R0, R1, R2, R3 et que la mémoire contient 256 cellules. Par exemple, pour copier le contenu du registre R1 dans le registre R0, il faut: aiguiller la valeur du registre R1 à l’extérieur du bloc des registres; indiquer à l’UAL de n’effectuer aucune opération; passer à travers du multiplexeur de sélection de source; revenir à l’entrée du bloc des registres, et aiguiller cette valeur dans R0; le signal sur le port B du bloc des registres n’est pas utilisé et est sans importance; la mémoire ne doit pas charger de nouvelle valeur pendant cette opération.

Effectuer l’opération R0 ← R1 (notes, section 9.2.9) Effectuer l’opération R0 ← R1 R0 R1 R2 - 1 R3 1 1 - 7 instruction choixSource choixCharge charge choixA choixB opération lectureEcriture’ R0 ← R1 1 - 7 R2 ← R1 + R3 2 3 R2 ← R2 ET R3 5 R3 ← M[25] M[25] ← R0 case op is when 0 => F <= A + B; when 1 => F <= A - B; when 2 => F <= shift_right(A, 1); when 3 => F <= shift_left(A, 1); when 4 => F <= not(A); when 5 => F <= A and B; when 6 => F <= A or B; when 7 => F <= A; when others => F <= (others => 'X'); end case;

Effectuer l’opération R2 ← R1 + R3 (notes, section 9.2.9) Effectuer l’opération R2 ← R1 + R3 R0 R1 + 2 R2 - 1 R3 1 1 3 instruction choixSource choixCharge charge choixA choixB opération lectureEcriture’ R0 ← R1 1 - 7 R2 ← R1 + R3 2 3 R2 ← R2 ET R3 5 R3 ← M[25] M[25] ← R0 case op is when 0 => F <= A + B; when 1 => F <= A - B; when 2 => F <= shift_right(A, 1); when 3 => F <= shift_left(A, 1); when 4 => F <= not(A); when 5 => F <= A and B; when 6 => F <= A or B; when 7 => F <= A; when others => F <= (others => 'X'); end case;

Effectuer l’opération R2 ← R2 ET R3 (notes, section 9.2.9) Effectuer l’opération R2 ← R2 ET R3 R0 R1 ET 2 R2 - 1 R3 1 2 3 5 instruction choixSource choixCharge charge choixA choixB opération lectureEcriture’ R0 ← R1 1 - 7 R2 ← R1 + R3 2 3 R2 ← R2 ET R3 5 R3 ← M[25] M[25] ← R0 case op is when 0 => F <= A + B; when 1 => F <= A - B; when 2 => F <= shift_right(A, 1); when 3 => F <= shift_left(A, 1); when 4 => F <= not(A); when 5 => F <= A and B; when 6 => F <= A or B; when 7 => F <= A; when others => F <= (others => 'X'); end case;

Effectuer l’opération R3 ← M[25] (notes, section 9.2.9) Effectuer l’opération R3 ← M[25] 3 R0 R1 … 23 24 25 3 R2 25 1 R3 1 - - - instruction choixSource choixCharge charge choixA choixB opération lectureEcriture’ R0 ← R1 1 - 7 R2 ← R1 + R3 2 3 R2 ← R2 ET R3 5 R3 ← M[25] M[25] ← R0 case op is when 0 => F <= A + B; when 1 => F <= A - B; when 2 => F <= shift_right(A, 1); when 3 => F <= shift_left(A, 1); when 4 => F <= not(A); when 5 => F <= A and B; when 6 => F <= A or B; when 7 => F <= A; when others => F <= (others => 'X'); end case;

Effectuer l’opération M[25] ← R0 (notes, section 9.2.9) Effectuer l’opération M[25] ← R0 - R0 R1 … 23 24 25 - R2 25 R3 - - instruction choixSource choixCharge charge choixA choixB opération lectureEcriture’ R0 ← R1 1 - 7 R2 ← R1 + R3 2 3 R2 ← R2 ET R3 5 R3 ← M[25] M[25] ← R0 case op is when 0 => F <= A + B; when 1 => F <= A - B; when 2 => F <= shift_right(A, 1); when 3 => F <= shift_left(A, 1); when 4 => F <= not(A); when 5 => F <= A and B; when 6 => F <= A or B; when 7 => F <= A; when others => F <= (others => 'X'); end case;

Effectuer l’opération … (notes, section 9.2.9) Effectuer l’opération … R0 R1 R2 R3 instruction choixSource choixCharge charge choixA choixB opération lectureEcriture’ case op is when 0 => F <= A + B; when 1 => F <= A - B; when 2 => F <= shift_right(A, 1); when 3 => F <= shift_left(A, 1); when 4 => F <= not(A); when 5 => F <= A and B; when 6 => F <= A or B; when 7 => F <= A; when others => F <= (others => 'X'); end case;

Éléments à mémoire pour chemins des données Bloc de registres (notes, section 9.2.3) Éléments à mémoire pour chemins des données Bloc de registres Un bloc de registre peut avoir plusieurs ports d’entrée et de sortie. Un registre peut à la fois être la cible d’une écriture et la source pour l’un des ports de sortie. Version coûteuse en multiplexeurs!

(notes, section 9.2.5) Éléments à mémoire pour chemins des données Bloc de registres: code VHDL -- dans la partie déclarative de l’architecture type lesRegistres_type is array(0 to Nreg - 1) of signed(Wd - 1 downto 0); signal lesRegistres : lesRegistres_type; signal A : signed(Wd - 1 downto 0); signal choixA : integer range 0 to Nreg - 1; signal B : signed(Wd - 1 downto 0); signal choixB : integer range 0 to Nreg - 1; signal donnee : signed(Wd - 1 downto 0); signal choixCharge : integer range 0 to Nreg - 1; signal charge : std_logic; -- dans le corps de l’architecture process (CLK, reset) begin if rising_edge(CLK) then if reset = '1' then lesRegistres <= (others => (others => '0')); else if charge = '1' then lesRegistres(choixCharge) <= donnee; end if; end process; -- signaux de sortie du bloc des registres A <= lesRegistres(choixA); B <= lesRegistres(choixB); sortieExterne <= B; Dans cette description du bloc des registres: le nombre de ports d’entrée est fixé à 1 le nombre de ports de sortie est fixé à 2 le nombre de registres est déterminé par le paramètre Nreg la largeur des registres est déterminée par le paramètre Wd

Unité arithmétique et logique (notes, section 9.2.6) Unité arithmétique et logique -- dans la partie déclarative de l’architecture   signal F : signed(Wd - 1 downto 0); signal Z : std_logic; signal N : std_logic; signal op : integer range 0 to 7; -- dans le corps de l’architecture process(A, B, op) begin case op is when 0 => F <= A + B; when 1 => F <= A - B; when 2 => F <= shift_right(A, 1); when 3 => F <= shift_left(A, 1); when 4 => F <= not(A); when 5 => F <= A and B; when 6 => F <= A or B; when 7 => F <= A; when others => F <= (others => 'X'); end case; end process; -- registre d'état de l'UAL process(clk, reset) begin if rising_edge(clk) then if reset = '1' then Z <= '0'; N <= '0'; else if (etat = opUAL) then if F = 0 then Z <= '1'; end if; N <= F(F'left); end process; Dans cette description de l’UAL: les opérations sont fixes l’encodage est fixe la façon d’établir la valeur des bits d’état est fixe la largeur de l’UAL est déterminée par le paramètre Wd

(notes, section 9.2.6) UAL - suite Plusieurs auteurs distinguent l’UAL et le module de décalage. Nous choisissons ici de les joindre, c'est-à-dire que l’UAL est capable d’effectuer des opérations arithmétiques, logiques et de décalage. L’UAL inclut ici un registre d’état. La fonction de ce registre est d’entreposer un mot d’information sur la dernière opération effectuée, comme un résultat négatif ou nul, un débordement ou la génération d’une retenue. Ici l’état se résume à 2 bits, Z et N, indiquant respectivement un résultat nul ou négatif. Lors d’une opération sur l’UAL, le résultat est entreposé dans un registre du bloc des registres. L’état correspondant est entreposé dans le registre d’état. Cette approche simplifie la synchronisation avec l’unité de contrôle. La complexité de l’UAL est une fonction de sa largeur et du nombre d’opérations qu’elle doit supporter.

(notes, section 9.2.7) Mémoire des données En théorie, un processeur avec un bloc des registres suffisamment grand n’aurait pas besoin d’une mémoire des données associée. C’est souvent le cas pour les processeurs spécialisés. En pratique cependant, un processeur à usage général a toujours besoin d’une telle mémoire. Pour la plupart des processeurs, la mémoire des données est placée à l’extérieur de celui-ci. La mémoire des données a en général un port de sortie, un port d’entrée, un port d’adresse et un port de contrôle de l’opération. La mémoire peut avoir plusieurs ports d’entrée et de sortie. En général, il est utile que les cellules de la mémoire aient est la même taille que celles du bloc des registres, mais ce n’est pas strictement nécessaire. Le port d’adresse spécifie une cellule de la mémoire en particulier. Le signal lecture/ecriture’ détermine si la cellule sera lue (1) ou écrite (0).

Mémoire des données en VHDL (notes, section 9.2.7) Mémoire des données en VHDL Une mémoire vive peut être vue comme un bloc de registres de très grande taille, avec: un (parfois deux) port de sortie un (parfois deux) port d’entrée un (parfois deux) port d’adresse un port de contrôle de l’opération. La description d’une mémoire des données en VHDL peut prendre plusieurs formes, selon une multitude de paramètres. Ceux-ci incluent, entre autres : le nombre de ports d’entrée et de sortie; le fait que les sorties soient synchrones ou asynchrones; le nombre de cycles nécessaires à la mémoire pour déplacer des données; la présence de signaux d’activation; et, la spécification de valeurs initiales. Il faut consulter la documentation du synthétiseur pour adopter le bon patron de code VHDL correspondant aux paramètres de la mémoire RAM désirée.

Mémoire des données en VHDL (notes, section 9.2.7) Mémoire des données en VHDL -- dans la partie déclarative de l’architecture type memoireDonnees_type is array(0 to 2 ** Md - 1) of signed(Wd - 1 downto 0); signal memoireDonnees : memoireDonnees_type; signal sortieMemoireDonnees : signed(Wd - 1 downto 0); signal adresseMemoireDonnees : integer range 0 to 2 ** Md - 1; signal lectureEcritureN : std_logic; -- dans le corps de l’architecture -- mémoire des données process (CLK) begin if rising_edge(CLK) then if lectureEcritureN = '0' then memoireDonnees(adresseMemoireDonnees) <= B; end if; end process; sortieMemoireDonnees <= memoireDonnees(adresseMemoireDonnees); Important: pas de signal de réinitialisation dans le modèle, ce qui empêcherait le synthétiseur d’utiliser la mémoire distribuée. Dans cette description de la mémoire: le nombre de mots est déterminée par le paramètre Md la taille des mots est déterminée par le paramètre Wd habituellement, la lecture d’une donnée nécessite un cycle d’horloge pour charger l’adresse, ce n’est pas modélisé ici

Comment se synthétise la mémoire dans un FPGA? (notes, section 3.5.5) Comment se synthétise la mémoire dans un FPGA? Colonnes de blocs de mémoire intégrées à travers les CLBs. (Xilinx: Block RAM) LUTs des CLBs (Xilinx: Distributed RAM) Le choix peut être contrôlé par les paramètres du synthétiseur – démo à partir d’Active-HDL. Source: Maxfield, © Mentor Graphics, 2004

Plan pour aujourd’hui Mise en contexte Retour sur les processeurs à usage spécifique Processeurs à usage général: introduction Chemin des données Unité de contrôle + Des précisions sur les notes de cours, des exemples et une parenthèse sur VHDL!

Unité de contrôle du processeur à usage général (notes, section 9.3) Unité de contrôle du processeur à usage général choixSource choixCharge charge choixA choixB opération lectureEcriture’

Unité de contrôle du processeur à usage général (notes, section 9.3) Unité de contrôle du processeur à usage général L’unité de contrôle du processeur doit effectuer les opérations en fonction des instructions du programme à exécuter. L’unité de contrôle est composée des composantes suivantes : une mémoire des instructions contenant le programme à exécuter; un compteur de programme (Program Counter – PC) qui pointe à la prochaine instruction à exécuter; un registre d’instruction (Instruction Register – IR) qui contient l’instruction courante; et, un contrôleur qui implémente une machine à états et qui génère les signaux de contrôle pour le chemin des données. Certains auteurs séparent la mémoire du programme et l’unité de contrôle, mais ici nous les combinons. On peut aussi considérer le registre d’états de l’UAL comme faisant partie de l’unité de contrôle.

Choix d’approche pour l’encodage des instructions (pas dans les notes) Choix d’approche pour l’encodage des instructions Le code d’une instruction doit permettre de spécifier sans ambiguïté tous les signaux de contrôle du chemin des données. Il y a trois grandes approches: CISC, RISC et NISC Nous choisissons l’approche RISC. Les signaux de contrôle du chemin des données sont encodés, ce qui réduit la taille du programme. La spécification du processeur monte alors au niveau du jeu d’instructions. L’implémentation peut être différente pour deux processeurs qui ont le même comportement. NISC Technology and Toolset, University of California Irvine, [en ligne: http://www.ics.uci.edu/~nisc/], consulté le 2009/11/11

Cycle des instructions et machine à états (notes, section 9.3.2) Cycle des instructions et machine à états Pour exécuter une instruction, l’unité de contrôle doit exécuter la séquence de tâches suivante : Aller quérir l’instruction à exécuter (fetch). Le registre des instructions est chargé avec le contenu de la cellule de la mémoire des instructions pointée par le compteur de programme. Le compteur de programme est incrémenté pour pointer à la prochaine instruction ou à des données emmagasinées immédiatement après l’instruction en cours. Décoder l’instruction (decode). Le contrôleur décode l’instruction obtenue afin de générer les signaux de contrôle pour le chemin des données. Exécuter l’instruction (execute). Le chemin des données exécute l’instruction. Cette étape peut être décomposée en plusieurs états selon la complexité de l’instruction.

Cycle des instructions et machine à états (notes, section 9.3.2) Cycle des instructions et machine à états quérir (fetch): 1. Le registre des instructions est chargé avec le contenu de la cellule de la mémoire des instructions pointée par le compteur de programme. 2. Le compteur de programme est incrémenté pour pointer à la prochaine instruction ou à des données emmagasinées immédiatement après l’instruction en cours. décoder (decode): Le contrôleur décode l’instruction obtenue afin de générer les signaux de contrôle pour le chemin des données. exécuter (execute): Le chemin des données exécute l’instruction.

Encodage des instructions en mémoire (notes, section 9.3.3) Encodage des instructions en mémoire Suppositions: le chemin des données contient 16 registres de 16 bits, R0 à R15 l’ALU peut exécuter les 8 instructions +, -, ÷2, ×2, NON, ET, OU, identité; et, les mémoires des données et des instructions contiennent 256 mots de 16 bits. instruction bits 15-12 bits 11-8 bits 7-4 bits 3-0 Rdest ← Rsource1 ◊ Rsource2 {0|op2|op1|op0} destination source1 source2 Rdest ← MD[adresse] 1000 adresse[7:4] adresse[3:0] MD[adresse] ← Rsource 1001 source JUMP adresse 1100 condition STOP 1111 - instruction condition bits 11-8 de l’instruction JUMP aucune 0000 JZ zéro 0001 JNZ pas zéro 0010 JNeg négatif 0011 JPos positif 0100 Pour l’instruction qui nécessite un traitement par l’ALU, les 3 bits {op2|op1|op0} correspondent à l’encodage des opérations de l’ALU. Pour l’instruction JUMP, les différentes combinaisons des bits 11-8 de l’instruction permettent d’avoir jusqu’à 16 conditions différentes. Ce tableau en propose cinq.

Exemples d’encodage d’instructions (notes, section 9.3.3) Exemples d’encodage d’instructions instruction bits 15-12 bits 11-8 bits 7-4 bits 3-0 R7 ← R5 + R2 0000 0111 0101 0010 R9 ← R0 – R11 0001 1001 1011 R8 ← R4 1000 0100 ---- R12 ← MD[240] 1100 1111 MD[28] ← R10 1010 JZ 2 R15 ← R14 × 2 R0 ← R1 ET R4 R7 ← NON(R12) MD[128] ← R7 Jpos 48 On observe: 1. plusieurs codes ne sont pas utilisés, comme par exemple ceux qui commencent par 101 2. certaines opérations n’utilisent pas tous les champs. Bien que cela signifie que plus de bits sont utilisés que nécessaire, cela donne de la flexibilité pour ajouter des instructions au processeur.

Exemple de programme instruction bits 15-12 bits 11-8 bits 7-4 (notes, section 9.4) Exemple de programme instruction bits 15-12 bits 11-8 bits 7-4 bits 3-0 R0 ← M[0] 8 R1 ← M[1] 1 R12 ← R0 – R1 C JPos 5 4 6 R12 ← R1 – R0 M[3] ← R12 9 3 STOP F -

Exercice de programmation (notes, section 9.6) Exercice de programmation Donnez les instructions et les codes numériques d’un programme qui calcule la moyenne de 8 valeurs gardées en mémoire dans des cellules contigües à partir de l’adresse 0.

Exercice de programmation (notes, section 9.6) Exercice de programmation Donnez les instructions et les codes numériques d’un programme qui multiplie deux nombres non signés de 8 bits.

Mémoire des instructions en VHDL (notes, section 9.3.4) Mémoire des instructions en VHDL La mémoire des instructions est en mode lecture seule. L’écriture initiale n’est faite que lors de la configuration du dispositif. La mémoire est définie dans la partie déclarative de l’architecture comme un tableau constant à deux dimensions dans lequel on place les valeurs des instructions du programme. Le code suivant définit une mémoire qui contient 6 instructions, suivies de 250 cases contenant FFFF (instruction STOP). -- dans la partie déclarative de l’architecture type memoireInstructions_type is array (0 to 2 ** Mi - 1) of std_logic_vector(Wi - 1 downto 0); constant memoireInstructions : memoireInstructions_type := (x"0752", x"190b", x"7840", x"8cf0", x"9a1c", x"c102", others => x"FFFF");

Parenthèse: littéraux numériques en VHDL (section 2.5 et plus …) Parenthèse: littéraux numériques en VHDL Littéraux numériques abstraits entiers (sans point) réels (avec point) avec une base ou pas (base 10 présumée) Format général: base#chiffres[.chiffres]#[exposant] Littéraux composés d’une chaîne de bits placés entre guillemets la base peut être spécifiée par B, O ou X (binaire, octal, hexadécimal) Le caractère de soulignement peut être utilisé pour améliorer la lisibilité -- Littéraux décimaux 14 7755 156E7 188.993 88_670_551.453_909 44.99E-22 -- Littéraux avec une base 16#FE# -- 254 2#1111_1110# -- 254 8#376# -- 254 16#D#E1 -- 208 16#F.01#E+2 -- 3841.00 2#10.1111_0001#E8 -- 1506.00 B"1111_1111" -- un vecteur de bits B"11111111" -- le même vecteur X"FF" -- le même vecteur O"377" -- le même vecteur

Machine à états plus détaillée (notes, section 9.3.5) Machine à états plus détaillée L’état ‘exécuter’ a été remplacé par d’autres états. À partir de l’état décoder, la machine peut passer à l’un de cinq états, correspondant aux cinq types d’instructions du processeur. Dans chacun des ces états, les signaux de contrôle appropriés doivent être générés pour le chemin des données.

Code VHDL pour l’unité de contrôle (1/3) (notes, section 9.3.6) Code VHDL pour l’unité de contrôle (1/3) -- dans la partie déclarative de l’architecture type type_etat is (depart, querir, decoder, stop, ecrireMemoire, lireMemoire, opUAL, jump); signal etat : type_etat; signal PC : integer range 0 to (2 ** Mi - 1); -- compteur de programme signal IR : std_logic_vector(Wi - 1 downto 0); -- registre d'instruction -- dans le corps de l’architecture process (CLK, reset) begin if rising_edge(CLK) then if reset = '1' then etat <= depart; else case etat is when depart => PC <= 0; etat <= querir; when querir => IR <= memoireInstructions(PC); PC <= PC + 1; etat <= decoder;

Code VHDL pour l’unité de contrôle (2/3) (notes, section 9.3.6) Code VHDL pour l’unité de contrôle (2/3) when decoder => if (IR(15) = '0') then etat <= opUAL; else case IR(14 downto 12) is when "000" => etat <= lireMemoire; when "001" => etat <= ecrireMemoire; when "100" => etat <= jump; when "111" => etat <= stop; when others => etat <= stop; end case; end if; when opUAL | lireMemoire | ecrireMemoire => etat <= querir; when jump => if (IR(11 downto 8) = "0000") or -- branchement sans condition (IR(11 downto 8) = "0001" and Z = '1') or -- si = 0 (IR(11 downto 8) = "0010" and Z = '0') or -- si /= 0 (IR(11 downto 8) = "0011" and N = '1') or -- si < 0 (IR(11 downto 8) = "0100" and N = '0') -- si >= 0 then PC <= to_integer(unsigned(IR(7 downto 0))); when stop => etat <= stop; when others => etat <= depart; end process;

Code VHDL pour l’unité de contrôle (3/3) (notes, section 9.3.6) Code VHDL pour l’unité de contrôle (3/3) adresseMemoireDonnees <= to_integer(unsigned(IR(7 downto 0))); lectureEcritureN <= '0' when etat = ecrireMemoire else '1'; choixSource <= 0 when etat = opUAL else 3; choixCharge <= to_integer(unsigned(IR(11 downto 8))); choixA <= to_integer(unsigned(IR(7 downto 4))); choixB <= to_integer(unsigned(IR(11 downto 8))) when etat = ecrireMemoire else to_integer(unsigned(IR(3 downto 0))); charge <= '1' when etat = opUAL or etat = lireMemoire else '0'; op <= to_integer(unsigned(IR(14 downto 12))); L’adresse de la mémoire des données est contenue dans les bits 7 à 0 du registre d’instructions, sauf pour les instructions concernant l’UAL. Cependant, comme la sortie de la mémoire n’est pas sollicitée pour les instructions concernant l’UAL, on peut se permettre de simplifier la description et ne pas inclure de condition en rapport avec l’état de la machine.

Le problème du logiciel (notes, section 9.4) Le problème du logiciel L’écriture directe d’un programme en codes de 16 bits est ardue. Pour simplifier la tâche, on peut utiliser un programme spécial appelé assembleur qui donne automatiquement les codes numériques des instructions à partir de leur représentation symbolique. Pour les programmes très complexes, cependant, on utilise plutôt un compilateur qui accepte en entrée un programme dans un langage de haut niveau comme C ou Python et qui produit les codes des instructions. Le compilateur doit s’appuyer sur une connaissance approfondie des instructions pouvant être réalisées par le processeur ainsi que des architectures de son chemin des données et de son unité de contrôle. Un simulateur et un débogueur seraient bien aussi … 

Améliorations architecturales au processeur (notes, section 9.5) Améliorations architecturales au processeur Le processeur montré ici nécessite trois cycles d’horloge par instruction. La technique du pipeline pourrait permettre de compléter une instruction à chaque coup d’horloge. L’instanciation de plusieurs UALs pourrait permettre de compléter plusieurs instructions à chaque coup d’horloge.

Exercices d’ajout d’instructions au processeur (1) (notes, section 9.6) Exercices d’ajout d’instructions au processeur (1) Chargement de constantes Ajoutez une instruction de la forme Rk ← #XY, permettant de charger un registre avec une valeur constante de 8 bits de large, spécifiée dans le programme. Utilisez le signal constante en entrée au multiplexeur qui détermine l’entrée du bloc des registres. Ajoutez une instruction de la forme Rk ← #WXYZ, permettant de charger un registre avec une valeur constante de 16 bits de large, spécifiée dans le programme. Dans le flot des instructions, la constante serait entreposée immédiatement après l’instruction de chargement. Il faudrait alors incrémenter le compteur de programme deux fois. Utilisez le signal constante en entrée au multiplexeur qui détermine l’entrée du bloc des registres. Une réponse complète comporte: Un encodage pour la nouvelle instruction. Les modifications au chemin des données Les modifications à la machine à états de l’unité de contrôle. Les modifications à l’unité de contrôle. Le code VHDL modifié.

Exercices d’ajout d’instructions au processeur (2) (notes, section 9.6) Exercices d’ajout d’instructions au processeur (2) Plus d’opérations Donnez trois options pour modifier le processeur afin de permettre de supporter plus de 8 opérations de l’UAL. Saut sur une plus grande plage d’adresses Proposez une modification à l’instruction JUMP pour pouvoir effectuer un branchement vers une adresse exprimée sur plus de 8 bits. Entrées et sorties Ajoutez une instruction pour pouvoir lire une donnée externe, de la forme Rk ← entreeExterne. Ajoutez un signal de contrôle en entrée, entreeExterneValide, qui prend une valeur de 1 quand l’entrée externe est prête à être lue. Quand il exécute cette instruction, le processeur doit ‘geler’ tant que l’entrée externe n’est pas valide. Ajoutez une instruction pour pouvoir écrire une donnée externe, de la forme sortieExterne ← Rk. Ajoutez un signal de contrôle en sortie, sortieExterneValide, qui est mis à ‘1’ quand la sortie externe est prête à être lue. Une réponse complète comporte: Un encodage pour la nouvelle instruction. Les modifications au chemin des données Les modifications à la machine à états de l’unité de contrôle. Les modifications à l’unité de contrôle. Le code VHDL modifié.

Encodage des instructions (notes, section 9.3.5) Encodage des instructions instruction bits 15-12 bits 11-8 bits 7-4 bits 3-0 Rdest ← Rsource1 ◊ Rsource2 {0|op2|op1|op0} destination source1 source2 Rdest ← MD[adresse] 1000 adresse[7:4] adresse[3:0] MD[adresse] ← Rsource 1001 source JUMP adresse 1100 condition STOP 1111 -

Chemin des données et unité de contrôle

Machine à états de l’unité de contrôle (notes, section 9.3.5) Machine à états de l’unité de contrôle

Résumé: processeur à usage général Notions à retenir et maîtriser Importance relative 1. Expliquer les différences et les forces relatives entre un processeur à usage spécifique et un processeur à usage général. 10 2. Chemin des données d’un processeur à usage général: Donner un diagramme montrant les composantes, connexions et signaux de contrôle Montrer comment aiguiller les signaux pour effectuer des opérations Donner le code VHDL pour le bloc des registres, l’UAL et la mémoire des données 35 3. Unité de contrôle d’un processeur à usage général: Donner un diagramme montrant les composantes et leurs connexions Donner un diagramme d’états montrant le cycle des instructions Expliquer comment effectuer l’encodage et le décodage des instructions Interpréter et écrire des programmes simples pour le processeur Donner le code VHDL pour la mémoire des instructions et la machine à états 4. Expliquer comment modifier le processeur pour lui ajouter des instructions: Expliquer les modifications au chemin des données Expliquer les modifications à l’unité de contrôle (architecture et diagramme d’états) Expliquer les modifications à l’encodage des instructions 20 Total 100