Unité de contrôle expliquée : composants et conception dans les CPU

L'unité de contrôle est le composant principal d'une unité centrale de traitement (CPU) dans les ordinateurs qui dirige les opérations pendant 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 exécuter les instructions depuis la mémoire d'un ordinateur. Elle reçoit l'instruction/l'information d'entrée de l'utilisateur et la convertit en signaux de contrôle, qui sont ensuite donnés au CPU pour exécution ultérieure. Elle est incluse comme partie de l'architecture Von Neumann développée par John Neumann. Elle est responsable de fournir signaux temporels, signaux contrôle et dirige l'exécution d'un programme par le CPU. Elle est incluse comme partie interne du CPU dans ordinateurs modernes. Cet article décrit information complète sur l'unité de contrôle.

Qu'est-ce que l'unité de contrôle ?

Le composant qui reçoit signal/information/instruction entrée utilisateur et convertit en signaux contrôle pour exécution dans CPU. Il contrôle et dirige mémoire principale, unité arithmétique & logique (ALU), dispositifs entrée/sortie, et responsable instructions envoyées au CPU d'un ordinateur. Il récupère instructions depuis mémoire principale processeur et les envoie au registre d'instruction processeur, qui contient contenus registres.

L'unité de contrôle convertit l'entrée en signaux contrôle puis envoyés au processeur et dirige exécution programme. Opérations à effectuer dirigées par processeur sur ordinateur. Principalement Unité Centrale Traitement (CPU) et Unité Traitement Graphique (GPU) requièrent unité de contrôle comme partie interne. Diagramme blocs unité contrôle montré ci-dessus.

Composants d'une unité de contrôle

Composants de cette unité : registres d'instruction, signaux contrôle dans CPU, signaux contrôle vers/depuis bus, bus contrôle, drapeaux entrée, signaux horloge.

Composants unité contrôle câblée : registre instruction (contient opcode et champ adresse), unité temporelle, générateur état contrôle, matrice génération signaux contrôle, décodeur instruction.
Composants unité contrôle microprogrammée : générateur adresse suivant, registre adresse contrôle, mémoire contrôle, registre données contrôle.

Fonctions

Les fonctions de l'unité de contrôle incluent :

• Dirige flux séquence données entre processeur et autres dispositifs.
• Interprète instructions et contrôle flux données dans processeur.
• Génère séquence signaux contrôle depuis instructions/commandes reçues registre instruction.
• Responsable contrôle unités exécution : ALU, tampons données, registres dans CPU ordinateur.
• Capacité récupérer, décoder, gérer exécution, stocker résultats.
• Ne peut pas traiter et stocker données
• Pour transférer données, communique avec dispositifs entrée/sortie et contrôle toutes unités ordinateur.

Conception de l'unité de contrôle

La conception peut se faire using deux types d'unité de contrôle :

• Câblée (Hardwired)
• Microprogrammée (single-level et two-level)

Unité de contrôle câblée

La conception de base d'une unité de contrôle câblée est montrée ci-dessus. Dans ce type, signaux contrôle générés par circuit logique matériel spécial sans changement structure circuit. Dans ce cas, signal généré ne peut être modifié pour exécution dans processeur.

Données de base d'un opcode (code opération d'instruction) envoyées au décodeur instruction pour décodage. Décodeur instruction est ensemble décodeurs décoder différents types données dans opcode. Résultat signaux sortie contenant valeurs signaux actifs donnés en entrée générateur matrice pour générer signaux contrôle exécution programme par processeur ordinateur.

Générateur matrice fournit états unité contrôle et signaux sortie processeur (signaux interruption). Matrice construite comme réseau logique programmable. Signaux contrôle générés générateur matrice donnés en entrée générateur matrice suivant et combinés avec signaux temporels unité temporelle contenant motifs rectangulaires.

Pour récupération nouvelle instruction, unité contrôle passe état initial pour exécution nouvelle instruction. Unité contrôle reste état initial ou premier état tant que signaux temporels, signaux entrée, états instruction ordinateur inchangés. Changement état unité contrôle peut survenir si changement dans signaux générés.

Quand signal externe ou interruption survient, unité contrôle passe état suivant et traite signal interruption. Drapeaux et états utilisés sélectionner états désirés effectuer cycle exécution instruction.

Dans dernier état, unité contrôle récupère instruction suivante et envoie sortie au compteur programme, puis registre adresse mémoire, registre tampon, puis registre instruction pour lire instruction. Finalement, si dernière instruction (récupérée par unité contrôle) est instruction fin, alors passe état opération processeur et attend utilisateur dirige programme suivant.

Unité de contrôle microprogrammée

Dans ce type, mémoire contrôle utilisée stocker signaux contrôle encodés pendant exécution programme. Signal contrôle non généré immédiatement et décodé car microprogramme stocke champ adresse dans mémoire contrôle. Processus entier niveau unique.

Micro-opérations effectuées pour exécution micro-instructions dans programme. Diagramme blocs unité contrôle microprogrammée montré ci-dessus. Du diagramme, adresse micro-instruction obtenue depuis registre adresse mémoire contrôle. Toute info unité contrôle stockée définitivement mémoire contrôle appelée ROM.

Micro-instruction depuis mémoire contrôle tenue par registre contrôle. Puisque micro-instruction sous forme mot contrôle (contient valeurs contrôle binaires) nécessite 1 ou plusieurs micro-opérations pour traitement données.

Pendant exécution micro-instructions, générateur adresse suivant calcule prochaine adresse micro-instruction et envoie au registre adresse contrôle pour lire micro-instruction suivante.
Séquence micro-opérations micro-programme effectuée par générateur adresse suivant et agit comme séquenceur microprogramme pour obtenir adresse séquence i.e., lire depuis mémoire contrôle.

Code Verilog pour l'unité de contrôle

Code Verilog pour Unité de Contrôle montré ci-dessous.

`include "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 sortie
// Sorties pour fichier registres

output [`DATA_INDEX_LIMIT:0] RF_DATA_W;
output [`ADDRESS_INDEX_LIMIT:0] RF_ADDR_W, RF_ADDR_R1, RF_ADDR_R2;
output RF_READ, RF_WRITE;

// Sorties pour ALU
output [`DATA_INDEX_LIMIT:0] ALU_OP1, ALU_OP2;
output [`ALU_OPRN_INDEX_LIMIT:0] ALU_OPRN;

// Sorties pour mémoire
output [`ADDRESS_INDEX_LIMIT:0] MEM_ADDR;
output MEM_READ, MEM_WRITE;

// Signaux entrée
input [`DATA_INDEX_LIMIT:0] RF_DATA_R1, RF_DATA_R2, ALU_RESULT;
input ZERO, CLK, RST;

// Signal inout
inout [`DATA_INDEX_LIMIT:0] MEM_DATA;

// Nets état
wire [2:0] proc_state;

// contient valeur compteur programme, stocke instruction courante, registre pointeur 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] state, next_state;

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

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

end

always @ (state)
begin

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;

case( state )

`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;
end

`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;
end

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

`PROC_MEM: begin
next_state = `PROC_WB;
MEM_READ = 1'b1; MEM_WRITE = 1'b0;
end

`PROC_WB: begin
next_state = `PROC_FETCH;
MEM_READ = 1'b1; MEM_WRITE = 1'b0;
end
endcase

end
endmodule;

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

// liste entrées
input CLK, RST;
// liste sorties
output STATE;

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

reg PC_REG, INST_REG, SP_REF;

`define PROC_FETCH 3'h0
`define PROC_DECODE 3'h1
`define PROC_EXE 3'h2
`define PROC_MEM 3'h3
`define PROC_WB 3'h4

// initiation état
initial
begin
state = 2'bxx;
next_state = `PROC_FETCH;
end

// gestion signal reset
always @ (posedge RST)
begin
state = `PROC_FETCH;
next_state = `PROC_FETCH;
end
always @ (posedge CLK)
begin
state = next_state;
end
always @(state)
begin
if (state === `PROC_FETCH)
begin
next_state = `PROC_DECODE;

print_instruction(INST_REG);
end

if (state === `PROC_DECODE)
begin
next_state = `PROC_EXE;

end

if (state === `PROC_EXE)
begin
next_state = `PROC_MEM;

print_instruction(SP_REF);
end

if (state === `PROC_MEM)
begin
next_state = `PROC_WB;

end

if (state === `PROC_WB)
begin
next_state = `PROC_FETCH;

print_instruction(PC_REG);
end
end

task print_instruction;

input [`DATA_INDEX_LIMIT:0] inst;

reg [5:0] opcode;
reg [4:0] rs;
reg [4:0] rt;
reg [4:0] rd;
reg [4:0] shamt; reg [5:0] funct; reg [15:0] immediate; reg [25:0] address;

begin

// analyse instruction
// R-type

{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("and r[%02d], r[%02d], r[%02d];", rs, rt, rd);
6'h25: $write("or 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);
default: $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, immediate);
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, immediate);
6'h0a : $write("slti r[%02d], r[%02d], 0X%04h;", rs, rt, immediate);
6'h04 : $write("beq r[%02d], r[%02d], 0X%04h;", rs, rt, immediate);
6'h05 : $write("bne r[%02d], r[%02d], 0X%04h;", rs, rt, immediate);
6'h23 : $write("lw r[%02d], r[%02d], 0X%04h;", rs, rt, immediate);
6'h2b : $write("sw r[%02d], r[%02d], 0X%04h;", rs, rt, immediate);

// J-Type

6'h02 : $write("jmp 0X%07h;", address);
6'h03 : $write("jal 0X%07h;", address);
6'h1b : $write("push;");
6'h1c : $write("pop;");
default: $write("");
endcase
$write ("\n");
end
endtask
end module;

FAQ

1). Quel est le travail d'une unité de contrôle ?

Le travail de l'unité de contrôle est de diriger flux données ou instructions pour exécution par processeur ordinateur. Elle contrôle, gère et coordonne mémoire principale, ALU, registres, entrée, et sorties. Elle récupère instructions et génère signaux contrôle pour exécution.

2). Qu'est-ce que la mémoire de contrôle ?

Mémoire contrôle généralement RAM ou ROM pour stocker adresse et données registre contrôle.

3). Qu'est-ce que l'unité de contrôle Wilkes ?

Circuits séquentiels et combinatoires unité contrôle câblée remplacés par unité contrôle Wilkes. Elle utilise unité stockage stocker séquences instructions micro-programme.

4). Qu'est-ce qu'une unité de contrôle câblée ?

Unité contrôle câblée génère signaux contrôle en changeant d'état à chaque impulsion horloge sans changement physique circuit. Génération signaux contrôle dépend registres instruction, décodeur, signaux interruption.

5). Qu'est-ce que la mémoire de contrôle ?

Information unité contrôle ou données stockée temporairement ou définitivement mémoire contrôle.
Mémoire contrôle deux types : Mémoire Accès Aléatoire (RAM) et Mémoire Lecture Seule (ROM).

Ainsi, ceci couvre définition, composants, conception, diagramme, fonctions, types Unité de Contrôle. Question pour vous : « Quel est le but du registre d'adresse de contrôle ? »