Qu'est-ce que l'unité de contrôle :composants et sa conception

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 lors de l'exécution d'un programme par le 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 en signaux de commande, qui sont ensuite transmis à la CPU 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 les signaux de commande 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/les informations/l'instruction de l'utilisateur et les 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 de la mémoire principale d'un processeur et les envoie au registre d'instructions du processeur, qui contient le contenu du registre.

L'unité de contrôle convertit l'entrée en signaux de contrôle 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. L'unité centrale de traitement (CPU) et l'unité de traitement graphique (GPU) nécessitent principalement une unité de contrôle comme partie interne. Le schéma fonctionnel de l'unité de contrôle est présenté ci-dessus.

Composants d'une unité de contrôle

Les composants de cette unité sont des registres d'instructions, des signaux de contrôle dans l'UC, des signaux de contrôle vers/depuis le bus, un bus de contrôle, des indicateurs d'entrée et des signaux d'horloge.

Les composants de l'unité de commande câblée sont un registre d'instructions (contient un code d'opération et un champ d'adresse), une unité de synchronisation, un générateur d'état de commande, une matrice de génération de signal de commande et un décodeur d'instructions.
Les composants de l'unité de commande microprogrammée sont l'adresse suivante générateur, un registre d'adresses de contrôle, une mémoire de contrôle et un registre de données de contrôle.

Fonctions

Les fonctions de l'unité de contrôle inclure les éléments suivants.

• Il dirige le flux de séquences 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 contrôle à partir des instructions reçues ou des commandes 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 dans le processeur d'un ordinateur.
• Il a la capacité d'extraire, 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 celui-ci peut être effectuée à l'aide de deux types d'unité de contrôle qui incluent ce qui suit.

• Basé sur le filaire
• Basé sur des microprogrammes (un niveau et deux niveaux)

Unité de contrôle câblé

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 circuit logique matériel spécial sans aucun changement dans 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 est envoyé au décodeur d'instructions pour le décodage. Le décodeur d'instructions est l'ensemble des décodeurs pour décoder différents types de données dans l'opcode. Cela se traduit par 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 matriciel fournit les états de l'unité de contrôle et les signaux sortant du processeur (signaux d'interruption). Matrix est construit comme le réseau logique programmable. Les signaux de commande générés par le générateur matriciel sont fournis en entrée de la matrice génératrice suivante et se combinent avec les signaux de synchronisation de l'unité de synchronisation qui contient des motifs rectangulaires.

Pour l'extraction d'une nouvelle instruction, l'unité de contrôle se transforme en une étape initiale pour l'exécution d'une nouvelle instruction. L'unité de commande reste à 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 restent inchangés. Le changement d'état de l'unité de contrôle peut être augmenté s'il y a un changement dans l'un des signaux générés.

Lorsqu'un signal externe ou une interruption se produit, l'unité de contrôle passe à l'état suivant et exécute 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'adresse mémoire, au registre tampon, puis au registre d'instruction 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é immédiatement et décodé car 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 effectuées 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. A partir du 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) qui nécessite 1 ou plusieurs micro-opérations à effectuer pour le traitement des données.

Lors de l'exécution des micro-instructions, le générateur d'adresses suivant a calculé l'adresse suivante de la micro-instruction puis l'envoie au registre d'adresses de contrôle pour lire la micro-instruction suivante.
La séquence des micro-opérations d'un micro -program est exécuté 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 lue à partir de la mémoire de contrôle.

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_LK2, RF_DATA_R)

// Signaux de sortie
// Sorties pour 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 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;
entrée ZERO, CLK, RST ;

// Signal d'entrée
inout [`DATA_INDEX_LIMIT:0] MEM_DATA;

// Réseaux d'état
wire [2:0] proc_state;

//contient la valeur du compteur du programme, stocke l'instruction actuelle, le registre du 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;
reg [1:0] état, next_state ;

PROC_SM state_machine(.STATE(proc_state),.CLK(CLK),.RST(RST));

toujours @ (posedge CLK)
begin
if (RST)
state <=RST;
else
state <=next_state;

fin

toujours @ (état)
commence

MEM_READ =1'b0 ; MEM_WRITE =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 :begin
next_state =`PROC_DECODE;
MEM_READ =1'b1;
RF_ADDR_R1 =1'b0; RF_ADDR_R2 =1'b0;
RF_ADDR_W =1'b1;
fin

`PROC_DECODE :begin
next_state =`PROC_EXE;
MEM_ADDR =1'b1;
ALU_OP1 =1'b1; ALU_OP2 =1'b1 ; ALU_OPRN =1'b1;
MEM_WRITE =1'b1;
RF_ADDR_R1 =1'b1; RF_ADDR_R2 =1'b1;
fin

`PROC_EXE :begin
next_state =`PROC_MEM;
ALU_OP1 =1'b1; ALU_OP2 =1'b1 ; ALU_OPRN =1'b1;
RF_ADDR_R1 =1'b0;
fin

`PROC_MEM : début
next_state =`PROC_WB ;
MEM_READ =1'b1 ; MEM_WRITE =1'b0;
fin

`PROC_WB : début
next_state =`PROC_FETCH ;
MEM_READ =1'b1 ; MEM_WRITE =1'b0;
fin
fin

fin
fin module ;

module PROC_SM(STATE,CLK,RST);
// liste des entrées
entrée CLK, RST;
// liste des sorties
sortie [2:0] STATE;

// liste d'entrée
entrée CLK, RST ;
// liste de sortie
sortie STATE ;

reg [2:0] STATE;
reg [1:0] state;
reg [1:0] next_state;

reg PC_REG, INST_REG, SP_REF ;

`définir PROC_FETCH 3’h0
`définir PROC_DECODE 3’h1
`définir PROC_EXE 3’h2
`définir PROC_MEM 3’h3
`définir PROC_WB 3’h4

// lancement de l'état
initial
begin
state =2'bxx;
next_state =`PROC_FETCH;
end

// réinitialiser la gestion du signal
always @ (posedge RST)
begin
state =`PROC_FETCH;
next_state =`PROC_FETCH;
end
always @ ( posedge CLK)
begin
state =next_state;
end
toujours @(state)
begin
if (state ===`PROC_FETCH)
commencer
next_state =`PROC_DECODE;

print_instruction(INST_REG);
fin

if (état ===`PROC_DECODE)
begin
next_state =`PROC_EXE;

fin

if (état ===`PROC_EXE)
begin
next_state =`PROC_MEM;

print_instruction(SP_REF);
fin

if (état ===`PROC_MEM)
begin
next_state =`PROC_WB;

fin

if (état ===`PROC_WB)
begin
next_state =`PROC_FETCH;

print_instruction(PC_REG);
fin
fin

tâche print_instruction;

saisir [`DATA_INDEX_LIMIT:0] inst ;

reg [5:0] opcode;
reg [4:0] rs;
reg [4:0] rt;
reg [4:0] rd;
reg [ 4:0] putain; 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 ;

// I-type
{opcode, rs, rt, immediate } =inst;
// J-type
{opcode, address} =inst;
$write(“ @ %6dns -> [0X%08h] ", $time, inst);
case(opcode) // R-Type
6'h00 :begin
case(funct)

6'h20 : $write(“add 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(“nor 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
end

// I-type

6'h08 :$write(“addi r[%02d], r[%02d], 0X%04h;”, rs, rt, immediate);
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, immediate);
6'h0d :$write(“ori r[%02d], r[%02d], 0X%04h;”, rs, rt, immediate);
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 (« push ; »);
6'h1c :$write(« pop; »);
par défaut :$write(« »);
endcase
$write (« \n”);
fin
endtask
fin module;

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). Qu'est-ce que 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 ?

Les circuits séquentiels et combinatoires de l'unité de commande câblée sont remplacés 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 câblée ?

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 des signaux de contrôle dépend du registre d'instructions, du décodeur et des signaux d'interruption.

5). Qu'est-ce que 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 en lecture seule (ROM).

Ainsi, il s'agit de la définition, des composants, de la conception, du schéma, des fonctions et des types d'unité de contrôle. Voici une question pour vous :« À quoi sert le registre d'adresses de contrôle ? »