Unidade de Controle Explicada: Componentes e Design em CPUs

A unidade de controle é o principal componente de uma unidade central de processamento (CPU) em computadores que direciona as operações durante a execução de um programa pelo processador/computador. A principal função da unidade de controle é buscar e executar instruções da memória de um computador. Ela recebe a instrução/entrada do usuário e a converte em sinais de controle, que são então enviados à CPU para execução posterior. Ela está incluída como parte da arquitetura de Von Neumann desenvolvida por John Neumann. É responsável por fornecer sinais de temporização, sinais de controle e dirige a execução de um programa pela CPU. Ela está incluída como parte interna da CPU em computadores modernos. Este artigo descreve informações completas sobre a unidade de controle.

O que é a Unidade de Controle?

O componente que recebe o sinal/entrada/instrução do usuário e converte em sinais de controle para execução na CPU. Ela controla e direciona a memória principal, a unidade aritmética e lógica (ULA), dispositivos de entrada e saída, e também é responsável pelas instruções enviadas à CPU de um computador. Ela busca as instruções da memória principal de um processador e envia ao registrador de instruções do processador, que contém o conteúdo dos registradores.

A unidade de controle converte a entrada em sinais de controle e os envia ao processador, dirigindo a execução de um programa. As operações que devem ser realizadas são direcionadas pelo processador no computador. Principalmente a Unidade Central de Processamento (CPU) e a Unidade de Processamento Gráfico (GPU) requerem uma unidade de controle como parte interna. O diagrama de blocos da unidade de controle é mostrado acima.

Componentes de uma Unidade de Controle

Os componentes desta unidade são registradores de instrução, sinais de controle dentro da CPU, sinais de controle para/do barramento, barramento de controle, flags de entrada e sinais de clock.

Os componentes da unidade de controle com fiação fixa (hardwired) são registrador de instrução (contém opcode e campo de endereço), unidade de temporização, gerador de estado de controle, matriz de geração de sinais de controle e decodificador de instrução.
Os componentes da unidade de controle microprogramada são o gerador de próximo endereço, um registrador de endereço de controle, memória de controle e registrador de dados de controle.

Funções

As funções da unidade de controle incluem o seguinte.

• Dirige o fluxo de sequência de dados entre o processador e outros dispositivos.
• Pode interpretar as instruções e controla o fluxo de dados no processador.
• Gera a sequência de sinais de controle a partir das instruções ou comandos recebidos do registrador de instrução.
• Tem a responsabilidade de controlar as unidades de execução como ULA, buffers de dados e registradores na CPU de um computador.
• Tem a capacidade de buscar, decodificar, lidar com a execução e armazenar resultados.
• Não pode processar e armazenar dados.
• Para transferir dados, comunica-se com dispositivos de entrada e saída e controla todas as unidades do computador.

Design da Unidade de Controle

O design desta pode ser feito usando dois tipos de unidade de controle que incluem o seguinte.

• Baseada em fiação fixa (hardwired)
• Baseada em microprogramação (single-level e two-level)

Unidade de Controle com Fiação Fixa

O design básico de uma unidade de controle com fiação fixa é mostrado acima. Neste tipo, os sinais de controle são gerados por um circuito lógico de hardware especial sem nenhuma mudança na estrutura do circuito. Neste, o sinal gerado não pode ser modificado para execução no processador.

Os dados básicos de um opcode (código de operação de uma instrução) são enviados ao decodificador de instrução para decodificação. O decodificador de instrução é o conjunto de decodificadores para decodificar diferentes tipos de dados no opcode. Isso resulta em sinais de saída que contêm valores de sinais ativos que são dados como entrada ao gerador de matriz para gerar sinais de controle para a execução de um programa pelo processador do computador.

O gerador de matriz fornece estados da unidade de controle e os sinais de saída do processador (sinais de interrupção). A matriz é construída como um array lógico programável. Os sinais de controle gerados pelo gerador de matriz são dados como entrada ao próximo gerador de matriz e combinados com os sinais de temporização da unidade de temporização que contém padrões retangulares.

Para busca de nova instrução, a unidade de controle entra em um estado inicial para a execução da nova instrução. A unidade de controle permanece no estado inicial ou primeiro estado enquanto os sinais de temporização, sinais de entrada e estados de instrução de um computador permanecerem inalterados. A mudança no estado da unidade de controle pode ocorrer se houver mudança em qualquer um dos sinais gerados.

Quando ocorre um sinal externo ou interrupção, a unidade de controle vai para o próximo estado e realiza o processamento do sinal de interrupção. Flags e estados são usados para selecionar os estados desejados para realizar o ciclo de execução da instrução.

No último estado, a unidade de controle busca a próxima instrução e envia a saída para o contador de programa, depois para o registrador de endereço de memória, para o registrador de buffer e então para o registrador de instrução para ler a instrução. Finalmente, se a última instrução (buscada pela unidade de controle) for instrução de fim, então ela vai para o estado operacional do processador e espera até que o usuário direcione o próximo programa.

Unidade de Controle Microprogramada

Neste tipo, a memória de controle é usada para armazenar os sinais de controle que são codificados durante a execução de um programa. O sinal de controle não é gerado imediatamente e decodificado porque o microprograma armazena o campo de endereço na memória de controle. Todo o processo é de um único nível.

As micro-operações são feitas para a execução de micro-instruções no programa. O diagrama de blocos da unidade de controle microprogramada é mostrado acima. Do diagrama, o endereço da micro-instrução é obtido do registrador de endereço de memória de controle. Toda a informação da unidade de controle é armazenada permanentemente na memória de controle chamada ROM.

A micro-instrução da memória de controle é mantida pelo registrador de controle. Como a micro-instrução está na forma de palavra de controle (contém valores de controle binários) que precisa de 1 ou mais micro-operações para serem realizadas para o processamento de dados.

Durante a execução de micro-instruções, o gerador de próximo endereço calcula o próximo endereço da micro-instrução e então envia ao registrador de endereço de controle para ler a próxima micro-instrução.
A sequência de micro-operações de um microprograma é realizada pelo gerador de próximo endereço e atua como sequenciador de microprograma para obter o endereço de sequência, ou seja, ler da memória de controle.

Código Verilog para a Unidade de Controle

Código Verilog para Unidade de Controle mostrado abaixo.

`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)
// Output signals
// Outputs for register file
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;

// Outputs for ALU
output [`DATA_INDEX_LIMIT:0] ALU_OP1, ALU_OP2;
output [`ALU_OPRN_INDEX_LIMIT:0] ALU_OPRN;

// Outputs for memory
output [`ADDRESS_INDEX_LIMIT:0] MEM_ADDR;
output MEM_READ, MEM_WRITE;

// Input signals
input [`DATA_INDEX_LIMIT:0] RF_DATA_R1, RF_DATA_R2, ALU_RESULT;
input ZERO, CLK, RST;

// Inout signal
inout [`DATA_INDEX_LIMIT:0] MEM_DATA;

// State nets
wire [2:0] proc_state;

//holds program counter value, stores the current instruction, stack pointer register

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);
// list of inputs
input CLK, RST;
// list of outputs
output [2:0] STATE;

// input list
input CLK, RST;
// output list
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 of state
initial
begin
state = 2'bxx;
next_state = `PROC_FETCH;
end

// reset signal handling
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

// parse the 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;

Perguntas Frequentes

1). Qual é o trabalho de uma unidade de controle?

O trabalho da unidade de controle é direcionar o fluxo de dados ou instruções para execução pelo processador de um computador. Ela controla, gerencia e coordena a memória principal, ULA, registradores, entrada e saída. Ela busca as instruções e gera sinais de controle para a execução.

2). O que é a memória de controle?

Memória de controle é geralmente RAM ou ROM para armazenar o endereço e dados do registrador de controle.

3). O que é a unidade de controle de Wilkes?

Os circuitos sequenciais e combinacionais da unidade de controle com fiação fixa são substituídos pela unidade de controle de Wilkes. Ela usa uma unidade de armazenamento para armazenar as sequências de instruções de um microprograma.

4). O que é uma unidade de controle com fiação fixa?

A unidade de controle com fiação fixa gera os sinais de controle mudando de um estado para outro a cada pulso de clock sem nenhuma mudança física no circuito. A geração de sinais de controle depende do registrador de instruções, decodificador e sinais de interrupção.

5). O que é a memória de controle?

A informação da unidade de controle ou dados é armazenada temporária ou permanentemente na memória de controle.
A memória de controle é de dois tipos. São eles Memória de Acesso Aleatório (RAM) e Memória Somente Leitura (ROM).

Assim, isso é tudo sobre a definição, componentes, design, diagrama, funções e tipos de Unidade de Controle. Aqui está uma pergunta para você: "Qual é o propósito do registrador de endereço de controle?"