Unidad de Control Explicada: Componentes y Diseño en CPUs

La unidad de control es el componente principal de una unidad central de procesamiento (CPU) en computadoras que puede dirigir operaciones durante la ejecución de un programa por el procesador/computadora. La función principal de la unidad de control es buscar y ejecutar instrucciones de la memoria de una computadora. Recibe la instrucción/entrada/información del usuario y la convierte en señales de control, que luego se dan a la CPU para ejecución posterior. Está incluida como parte de arquitectura Von Neumann desarrollada por John Neumann. Es responsable de proporcionar señales de temporización, señales de control y dirige la ejecución de un programa por la CPU. Está incluida como parte interna de la CPU en computadoras modernas. Este artículo describe información completa sobre la unidad de control.

¿Qué es la Unidad de Control?

El componente que recibe señal de entrada/información/instrucción del usuario y convierte en señales de control para ejecución en la CPU. Controla y dirige memoria principal, unidad aritmético-lógica (ALU), dispositivos de entrada y salida, y también es responsable de instrucciones enviadas a la CPU de una computadora. Obtiene instrucciones de la memoria principal de un procesador y las envía al registro de instrucciones del procesador, que contiene contenidos de registro.

La unidad de control convierte la entrada en señales de control y las envía al procesador y dirige la ejecución de un programa. Las operaciones que deben realizarse son dirigidas por el procesador en la computadora. Principalmente Unidad Central de Procesamiento (CPU) y Unidad de Procesamiento Gráfico (GPU) requieren unidad de control como parte interna. El diagrama de bloques de la unidad de control se muestra arriba.

Componentes de una Unidad de Control

Los componentes de esta unidad son registros de instrucción, señales de control dentro de la CPU, señales de control hacia/desde el bus, bus de control, banderas de entrada y señales de reloj.

Los componentes de la unidad de control cableada son registro de instrucción (contiene opcode y campo dirección), unidad de temporización, generador de estado de control, matriz de generación de señales de control y decodificador de instrucción.
Los componentes de la unidad de control microprogramada son generador de siguiente dirección, registro de dirección de control, memoria de control y registro de datos de control.

Funciones

Las funciones de la unidad de control incluyen las siguientes.

• Dirige el flujo de secuencia de datos entre el procesador y otros dispositivos.
• Puede interpretar instrucciones y controla el flujo de datos en el procesador.
• Genera la secuencia de señales de control desde las instrucciones o comandos recibidos del registro de instrucción.
• Tiene la responsabilidad de controlar unidades de ejecución como ALU, buffers de datos y registros en la CPU de una computadora.
• Tiene la capacidad de buscar, decodificar, manejar la ejecución y almacenar resultados.
• No puede procesar y almacenar datos
• Para transferir datos, se comunica con dispositivos de entrada y salida y controla todas las unidades de la computadora.

Diseño de Unidad de Control

El diseño de esta puede hacerse usando dos tipos de unidad de control que incluyen los siguientes.

• Basada en cableado (Hardwired)
• Basada en microprogramación (single-level y two-level)

Unidad de Control Cableada

El diseño básico de una unidad de control cableada se muestra arriba. En este tipo, las señales de control son generadas por un circuito lógico de hardware especial sin cambio en la estructura del circuito. En esta, la señal generada no puede modificarse para ejecución en el procesador.

El dato básico de un opcode (código de operación de una instrucción) se envía al decodificador de instrucción para decodificación. El decodificador de instrucción es el conjunto de decodificadores para decodificar diferentes tipos de datos en el opcode. Esto resulta en señales de salida que contienen valores de señales activas que se dan como entrada al generador de matriz para generar señales de control para la ejecución de un programa por el procesador de la computadora.

El generador de matriz proporciona estados de unidad de control y las señales de salida del procesador (señales de interrupción). La matriz se construye como array lógico programable. Las señales de control generadas por el generador de matriz se dan como entrada al siguiente generador de matriz y se combinan con las señales de temporización de la unidad de temporización que contiene patrones rectangulares.

Para búsqueda de nueva instrucción, la unidad de control pasa a etapa inicial para ejecución de nueva instrucción. La unidad de control permanece en etapa inicial o primera mientras las señales de temporización, señales de entrada y estados de instrucción de una computadora no cambian. El cambio en el estado de la unidad de control puede surgir si hay cambio en cualquiera de las señales generadas.

Cuando ocurre señal externa o interrupción, la unidad de control va al siguiente estado y realiza procesamiento de la señal de interrupción. Las banderas y estados se usan para seleccionar estados deseados para realizar ciclo de ejecución de instrucción.

En el último estado, la unidad de control busca la siguiente instrucción y envía la salida al contador de programa, luego al registro de dirección de memoria, al registro buffer, y luego al registro de instrucción para leer la instrucción. Finalmente, si la última instrucción (obtenida por la unidad de control) es instrucción fin, entonces va al estado operativo del procesador y espera hasta que el usuario dirija el siguiente programa.

Unidad de Control Microprogramada

En este tipo, el almacenamiento de control se usa para guardar señales de control que son codificadas durante la ejecución de un programa. La señal de control no se genera inmediatamente y decodifica porque el microprograma almacena campo de dirección en el almacenamiento de control. Todo el proceso es de un solo nivel.

Las micro-operaciones se hacen para la ejecución de micro-instrucciones en el programa. El diagrama de bloques de la unidad de control microprogramada se muestra arriba. Del diagrama, la dirección de la micro-instrucción se obtiene del registro de dirección de memoria de control. Toda la info de la unidad de control se almacena permanentemente en la memoria de control llamada ROM.

La micro-instrucción de la memoria de control es retenida por el registro de control. Como la micro-instrucción está en forma de palabra de control (contiene valores de control binarios) que necesita 1 o más micro-operaciones para ser realizadas para procesamiento de datos.

Durante la ejecución de micro-instrucciones, el generador de siguiente dirección computa la siguiente dirección de la micro-instrucción y luego envía al registro de dirección de control para leer la siguiente micro-instrucción.
La secuencia de micro-operaciones de un micro-programa es realizada por el generador de siguiente dirección y actúa como secuenciador de microprograma para obtener la dirección de secuencia i.e., leer de la memoria de control.

Código Verilog para la Unidad de Control

Código Verilog para Unidad de Control se muestra abajo.

`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)

// Señales de salida
// Salidas para archivo de registros

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;

// Salidas para ALU
output [`DATA_INDEX_LIMIT:0] ALU_OP1, ALU_OP2;
output [`ALU_OPRN_INDEX_LIMIT:0] ALU_OPRN;

// Salidas para memoria
output [`ADDRESS_INDEX_LIMIT:0] MEM_ADDR;
output MEM_READ, MEM_WRITE;

// Señales de entrada
input [`DATA_INDEX_LIMIT:0] RF_DATA_R1, RF_DATA_R2, ALU_RESULT;
input ZERO, CLK, RST;

// Señal inout
inout [`DATA_INDEX_LIMIT:0] MEM_DATA;

// Redes de estado
wire [2:0] proc_state;

//mantiene valor contador programa, almacena instrucción actual, registro puntero pila

reg MEM_READ, MEM_WRITE;
reg MEM_ADDR;
reg ALU_OP1, ALU_OP2;
reg ALU_OPRN;
reg RF_ADDR_R1, RF_ADDR_R2, RF_ADDR_W;
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);
// lista de entradas
input CLK, RST;
// lista de salidas
output [2:0] STATE;

// lista de entradas
input CLK, RST;
// lista de salidas
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

// iniciación de estado
initial
begin
state = 2'bxx;
next_state = `PROC_FETCH;
end

// manejo señal 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

// parsear la instrucción
// 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;

Preguntas Frecuentes

1). ¿Cuál es el trabajo de una unidad de control?

El trabajo de la unidad de control es dirigir el flujo de datos o instrucciones para la ejecución por el procesador de una computadora. Controla, gestiona y coordina memoria principal, ALU, registros, entrada y salida. Obtiene instrucciones y genera señales de control para la ejecución.

2). ¿Qué es la memoria de control?

La memoria de control es usualmente RAM o ROM para almacenar dirección y datos del registro de control.

3). ¿Qué es la unidad de control Wilkes?

Los circuitos secuenciales y combinacionales de la unidad de control cableada son reemplazados por la unidad de control Wilkes. Usa una unidad de almacenamiento para guardar las secuencias de instrucciones de un micro-programa.

4). ¿Qué es una unidad de control cableada?

La unidad de control cableada genera las señales de control cambiando de un estado a otro en cada pulso de reloj sin cambio físico en el circuito. La generación de señales de control depende de registro de instrucciones, decodificador y señales de interrupción.

5). ¿Qué es la memoria de control?

La información de la unidad de control o datos se almacena temporal o permanentemente en la memoria de control.
La memoria de control es de dos tipos. Son Memoria de Acceso Aleatorio (RAM) y Memoria de Solo Lectura (ROM).

Así, esto es todo sobre definición, componentes, diseño, diagrama, funciones y tipos de Unidad de Control. Aquí hay una pregunta para ti, "¿Cuál es el propósito del registro de dirección de control?"