L'unité de contrôle est le composant principal d'une unité centrale de traitement (CPU) dans les ordinateurs qui peut diriger les opérations pendant l'exécution d'un programme enle processeur/ordinateur. La fonction principale de l'unité de contrôle est de récupérer et d'exécuter des instructions à partir de la mémoire d'un ordinateur. Il reçoit les instructions/informations d'entrée de l'utilisateur et les convertit ensignaux de commande, qui sont ensuite transmises au processeur pour une exécution ultérieure. Il fait partie de l'architecture Von Neumann développée par John Neumann. Il est chargé de fournir les signaux de synchronisation et de contrôler les signaux et dirige l'exécution d'un programme par la CPU. Il est inclus en tant que partie interne du processeur dans les ordinateurs modernes. Cet article décrit des informations complètes sur l'unité de contrôle.
Qu'est-ce que l'unité de contrôle ?
Le composant qui reçoit le signal d'entrée/l'information/l'instruction de l'utilisateur et le convertit en signaux de commande pour l'exécution dans la CPU. Il contrôle et dirige la mémoire principale, l'unité arithmétique et logique (ALU), les périphériques d'entrée et de sortie, et est également responsable des instructions envoyées au processeur d'un ordinateur. Il récupère les instructions dumémoire principaled'un processeur et envoyé au registre d'instructions du processeur, qui contient le contenu du registre.
L'unité de contrôle convertit l'entrée en signaux de commande, puis l'envoie au processeur et dirige l'exécution d'un programme. Les opérations à effectuer sont dirigées par le processeur de l'ordinateur. Principalement l'unité centrale de traitement (CPU) etUnité de traitement graphique(GPU) nécessitent une unité de contrôle comme partie interne. Le schéma fonctionnel de l'unité de contrôle est illustré ci-dessus.
Composants d'une unité de contrôle
Les composants de cette unité sont des instructionsregistres, les signaux de commande dans le CPU, les signaux de commande vers/depuis le bus, le bus de commande, les indicateurs d'entrée et les signaux d'horloge.
Les composants de l'unité de contrôle câblée sont le registre d'instructions (contient l'opcode et le champ d'adresse), l'unité de synchronisation, l'état de contrôleGénérateur, matrice de génération de signal de commande et décodeur d'instructions.
Les composants de l'unité de contrôle programmée Micro sont le générateur d'adresse suivante, un registre d'adresse de contrôle, une mémoire de contrôle et un registre de données de contrôle.
Les fonctions
Lefonctions de l'unité de commandeinclure les éléments suivants.
- Il dirige le flux de séquence de données entre le processeur et les autres appareils.
- Il peut interpréter les instructions et contrôler le flux de données dans le processeur.
- Il génère la séquence de signaux de commande à partir des instructions ou commandes reçues du registre d'instructions.
- Il a la responsabilité de contrôler les unités d'exécution telles que l'ALU, les tampons de données et les registres du processeur d'un ordinateur.
- Il a la capacité de récupérer, de décoder, de gérer l'exécution et de stocker les résultats.
- Il ne peut pas traiter et stocker les données
- Pour transférer les données, il communique avec les périphériques d'entrée et de sortie et contrôle toutes les unités de l'ordinateur.
Conception de l'unité de contrôle
La conception de ceci peut être faite en utilisant deuxtypes d'unité de contrôlequi comprennent ce qui suit.
- Câblé basé
- Microprogrammé (à un niveau et à deux niveaux)
Unité de contrôle câblée
La conception de base d'une unité de commande câblée est illustrée ci-dessus. Dans ce type, les signaux de commande sont générés par un matériel spécialcircuit logiquesans aucune modification de la structure du circuit. En cela, le signal généré ne peut pas être modifié pour être exécuté dans le processeur.
Les données de base d'un opcode (le code d'opération d'une instruction sont envoyés au décodeur d'instructions pour décodage. L'instructiondécodeurest l'ensemble de décodeurs pour décoder différents types de données dans l'opcode. Il en résulte des signaux de sortie qui contiennent des valeurs de signaux actifs qui sont donnés en entrée au générateur de matrice pour générer des signaux de commande pour l'exécution d'un programme par le processeur de l'ordinateur.
Le générateur de matrice fournit les états de l'unité de contrôle et les signaux sortant du processeur (signaux d'interruption). La matrice est construite comme leréseau logique programmable. Les signaux de commande générés par le générateur de matrice sont donnés en tant qu'entrée à la matrice de générateur suivante et se combinent avec les signaux de synchronisation de l'unité de synchronisation qui contient des modèles rectangulaires.
Pour l'extraction d'une nouvelle instruction, l'unité de commande se transforme en une étape initiale pour l'exécution d'une nouvelle instruction. L'unité de commande reste dans l'étape initiale ou la première étape tant que les signaux de synchronisation, les signaux d'entrée et les états d'instruction d'un ordinateur sont inchangés. Le changement d'état de l'unité de commande peut être augmenté s'il y a un changement dans l'un quelconque des signaux générés.
Lorsqu'un signal externe ou une interruption se produit, l'unité de commande passe à l'état suivant et effectue le traitement du signal d'interruption. Les drapeaux et les états sont utilisés pour sélectionner les états souhaités pour effectuer le cycle d'exécution de l'instruction.
Dans le dernier état, l'unité de contrôle récupère l'instruction suivante et envoie la sortie au compteur de programme, puis au registre d'adresses mémoire, au registre tampon, puis au registre d'instructions pour lire l'instruction. Enfin, si la dernière instruction (qui est récupérée par l'unité de contrôle) est une instruction de fin, alors elle passe à l'état de fonctionnement du processeur et attend que l'utilisateur dirige le programme suivant.
Unité de contrôle microprogrammée
Dans ce type, la mémoire de contrôle est utilisée pour stocker les signaux de contrôle qui sont codés lors de l'exécution d'un programme. Le signal de commande n'est pas généré et décodé immédiatement parce que le microprogramme stocke le champ d'adresse dans la mémoire de commande. L'ensemble du processus est à un seul niveau.
Les micro-opérations sont faites pour l'exécution de micro-instructions dans le programme. Le schéma fonctionnel de l'unité de commande programmée Micro est présenté ci-dessus. D'après le schéma, l'adresse de la micro-instruction est obtenue à partir du registre d'adresse de la mémoire de contrôle. Toutes les informations de l'unité de contrôle sont stockées en permanence dans la mémoire de contrôle appelée ROM.
La micro-instruction de la mémoire de contrôle est conservée par le registre de contrôle. Étant donné que la micro-instruction se présente sous la forme d'un mot de contrôle (contient des valeurs de contrôle binaires), il faut effectuer 1 ou plusieurs micro-opérations pour le traitement des données.
Lors de l'exécution des micro-instructions, le générateur d'adresse suivante calcule l'adresse suivante de la micro-instruction puis l'envoie au registre d'adresse de contrôle pour lire la micro-instruction suivante.
La séquence de micro-opérations d'un micro-programme est exécutée par le générateur d'adresse suivant et agit comme un séquenceur de microprogramme pour obtenir l'adresse de séquence, c'est-à-dire la lire à partir de la mémoire de commande.
Code Verilog pour l'unité de contrôle
Le code Verilog pour l'unité de contrôle est indiqué ci-dessous.
`inclure "prj_definition.v"
module CONTROL_UNIT(MEM_DATA, RF_DATA_W, RF_ADDR_W, RF_ADDR_R1, RF_ADDR_R2, RF_READ, RF_WRITE, ALU_OP1, ALU_OP2, ALU_OPRN, MEM_ADDR, MEM_READ, MEM_WRITE, RF_DATA_R1, RF_DATA_R2, ALU_RESULT, ZERO, CLK, RST)
// Signaux de sortie
// Sorties pour le fichier de registre
sortie [`DATA_INDEX_LIMIT:0] RF_DATA_W ;
sortie [`ADDRESS_INDEX_LIMIT:0] RF_ADDR_W, RF_ADDR_R1, RF_ADDR_R2 ;
sortie RF_READ, RF_WRITE ;
// Sorties pour ALU
sortie [`DATA_INDEX_LIMIT:0] ALU_OP1, ALU_OP2 ;
sortie [`ALU_OPRN_INDEX_LIMIT:0] ALU_OPRN ;
// Sorties pour la mémoire
sortie [`ADDRESS_INDEX_LIMIT:0] MEM_ADDR ;
sortie MEM_READ, MEM_WRITE ;
// Signaux d'entrée
entrée [`DATA_INDEX_LIMIT:0] RF_DATA_R1, RF_DATA_R2, ALU_RESULT ;
entrer ZERO, CLK, RST ;
// Signal d'entrée
entrée [`DATA_INDEX_LIMIT:0] MEM_DATA ;
// Réseaux d'état
fil [2:0] proc_state ;
// contient la valeur du compteur de programme, stocke l'instruction actuelle, le registre de pointeur de pile
reg MEM_READ, MEM_WRITE ;
reg MEM_ADDR ;
reg ALU_OP1, ALU_OP2 ;
reg ALU_OPRN ;
reg RF_ADDR_W, RF_ADDR_R1, RF_ADDR_R2 ;
reg RF_DATA_W ;
état reg [1:0], état_suivant ;
PROC_SM state_machine(.STATE(proc_state),.CLK(CLK),.RST(RST));
toujours @ (posege CLK)
commencer
si (RST)
état <= RST ;
autre
état <= état_suivant ;
fin
toujours @ (indiquer)
commencer
MEM_READ = 1'b0 ; MEM_ECRITURE = 1'b0 ; MEM_ADDR = 1'b0 ;
ALU_OP1 = 1'b0 ; ALU_OP2 = 1'b0 ; ALU_OPRN = 1'b0 ;
RF_ADDR_R1 = 1'b0 ; RF_ADDR_R2 = 1'b0 ; RF_ADDR_W = 1'b0 ; RF_DATA_W = 1'b0 ;
cas (état)
`PROC_FETCH : commencer
état_suivant = `PROC_DECODE ;
MEM_READ = 1'b1 ;
RF_ADDR_R1 = 1'b0 ; RF_ADDR_R2 = 1'b0 ;
RF_ADDR_W = 1'b1 ;
fin
`PROC_DECODE : commencer
état_suivant = `PROC_EXE ;
MEM_ADDR = 1'b1 ;
ALU_OP1 = 1'b1 ; ALU_OP2 = 1'b1 ; ALU_OPRN = 1'b1 ;
MEM_ECRITURE = 1'b1 ;
RF_ADDR_R1 = 1'b1 ; RF_ADDR_R2 = 1'b1 ;
fin
`PROC_EXE : commencer
état_suivant = 'PROC_MEM ;
ALU_OP1 = 1'b1 ; ALU_OP2 = 1'b1 ; ALU_OPRN = 1'b1 ;
RF_ADDR_R1 = 1'b0 ;
fin
`PROC_MEM : commencer
état_suivant = `PROC_WB ;
MEM_READ = 1'b1 ; MEM_ECRITURE = 1'b0 ;
fin
`PROC_WB : commencer
état_suivant = `PROC_FETCH ;
MEM_READ = 1'b1 ; MEM_ECRITURE = 1'b0 ;
fin
endcase
fin
module final ;
module PROC_SM(ETAT,CLK,RST);
// liste des entrées
entrée CLK, RST ;
// liste des sorties
sortie [2:0] ETAT ;
// liste d'entrée
entrée CLK, RST ;
// liste de sortie
état de sortie ;
reg [2:0] ETAT ;
état reg [1:0] ;
reg [1:0] état_suivant ;
reg PC_REG, INST_REG, SP_REF ;
`définir PROC_FETCH 3'h0
`définir PROC_DECODE 3'h1
`define PROC_EXE 3'h2
`définir PROC_MEM 3'h3
`définir PROC_WB 3'h4
// initiation de l'état
initial
commencer
état = 2'bxx ;
état_suivant = `PROC_FETCH ;
fin
// réinitialiser la gestion du signal
toujours @ (posege RST)
commencer
état = 'PROC_FETCH ;
état_suivant = `PROC_FETCH ;
fin
toujours @ (posege CLK)
commencer
état = état_suivant ;
fin
toujours @(état)
commencer
si (état === `PROC_FETCH)
commencer
état_suivant = `PROC_DECODE ;
print_instruction(INST_REG);
fin
si (état === `PROC_DECODE)
commencer
état_suivant = `PROC_EXE ;
fin
si (état === `PROC_EXE)
commencer
état_suivant = 'PROC_MEM ;
print_instruction(SP_REF);
fin
si (état === 'PROC_MEM)
commencer
état_suivant = `PROC_WB ;
fin
si (état === 'PROC_WB)
commencer
état_suivant = `PROC_FETCH ;
print_instruction(PC_REG);
fin
fin
tâche print_instruction ;
entrée [`DATA_INDEX_LIMIT:0] inst ;
code opération reg [5:0] ;
reg [4:0] rs ;
reg [4:0] rt ;
reg [4:0] rd ;
reg [4:0] shamt ; fonction reg [5:0] ; reg [15:0] immédiat ; reg [25:0] adresse ;
commencer
// analyse l'instruction
// Type R
{opcode, rs, rt, rd, shamt, funct} = inst ;
// J'écris
{opcode, rs, rt, immédiat } = inst ;
// Type J
{opcode, adresse} = inst ;
$write("@ %6dns -> [0X%08h] ", $time, inst);
case(opcode) // R-Type
6’h00 : début
cas (fonction)
6'h20 : $write("ajouter r[%02d], r[%02d], r[%02d] ; », rs, rt, rd);
6'h22 : $write("sub r[%02d], r[%02d], r[%02d] ; », rs, rt, rd);
6'h2c : $write("mul r[%02d], r[%02d], r[%02d] ;", rs, rt, rd);
6'h24 : $write("et r[%02d], r[%02d], r[%02d] ;", rs, rt, rd);
6'h25 : $write("ou r[%02d], r[%02d], r[%02d] ;", rs, rt, rd);
6'h27 : $write("ni r[%02d], r[%02d], r[%02d] ; », rs, rt, rd);
6'h2a : $write("slt r[%02d], r[%02d], r[%02d] ;", rs, rt, rd);
6'h00: $write("sll r[%02d], %2d, r[%02d];", rs, shamt, rd);
6'h02 : $write("srl r[%02d], 0X%02h, r[%02d] ;", rs, shamt, rd);
6'h08: $write("jr r[%02d];", rs);
par défaut : $write("");
endcase
fin
// J'écris
6'h08 : $write("addi r[%02d], r[%02d], 0X%04h;", rs, rt, immédiat);
6'h1d : $write("muli r[%02d], r[%02d], 0X%04h;", rs, rt, immédiat);
6'h0c : $write("andi r[%02d], r[%02d], 0X%04h;", rs, rt, immédiat);
6'h0d : $write("ori r[%02d], r[%02d], 0X%04h;", rs, rt, immédiat);
6'h0f : $write("lui r[%02d], 0X%04h;", rt, immédiat);
6'h0a : $write("slti r[%02d], r[%02d], 0X%04h;", rs, rt, immédiat);
6'h04 : $write("beq r[%02d], r[%02d], 0X%04h;", rs, rt, immédiat);
6'h05 : $write("bne r[%02d], r[%02d], 0X%04h;", rs, rt, immédiat);
6’h23 : $write(“lw r[%02d], r[%02d], 0X%04h;”, rs, rt, immédiat);
6'h2b : $write("sw r[%02d], r[%02d], 0X%04h;", rs, rt, immédiat);
// Type J
6'h02 : $write("jmp 0X%07h;", adresse);
6'h03 : $write("jal 0X%07h;", adresse);
6'h1b : $write("pousser;");
6'h1c : $write("pop;");
par défaut : $write("");
endcase
$écrire ("\n");
fin
tâche finale
module final ;
FAQ
1). Quel est le travail d'une unité de contrôle?
Le travail de l'unité de contrôle est de diriger le flux de données ou d'instructions pour l'exécution par le processeur d'un ordinateur. Il contrôle, gère et coordonne la mémoire principale, l'ALU, les registres, les unités d'entrée et de sortie. Il récupère les instructions et génère des signaux de contrôle pour l'exécution.
2). Quelle est la mémoire de contrôle ?
La mémoire de contrôle est généralement une RAM ou une ROM pour stocker l'adresse et les données du registre de contrôle.
3). Qu'est-ce que l'unité de contrôle Wilkes ?
Le séquentiel etcircuits combinatoiresde l'unité de commande câblée sont remplacées par l'unité de commande Wilkes. Il utilise une unité de stockage pour stocker les séquences d'instructions d'un micro-programme.
4). Qu'est-ce qu'une unité de contrôle filaire ?
L'unité de commande câblée génère les signaux de commande en passant d'un état à un autre à chaque impulsion d'horloge sans aucun changement physique dans le circuit. La génération de signaux de commande dépend du registre d'instructions, du décodeur et des signaux d'interruption.
5). Quelle est la mémoire de contrôle ?
Les informations de l'unité de contrôle ou les données sont temporairement ou définitivement stockées dans la mémoire de contrôle.
La mémoire de contrôle est de deux types. Il s'agit de la mémoire vive (RAM) et de la mémoire morte (ROM).
Ainsi, il s'agit de la définition, des composants, de la conception, du diagramme, des fonctions ettypes d'unité de contrôle. Voici une question pour vous, "Quel est le but du registre d'adresses de contrôle?"
