Qué es la unidad de control:componentes y su diseño

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

¿Qué es la unidad de control?

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

La unidad de control convierte la entrada en señales de control y luego 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, la Unidad de procesamiento central (CPU) y la Unidad de procesamiento gráfico (GPU) requieren una 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 instrucciones, señales de control dentro de la CPU, señales de control hacia / desde el bus, bus de control, indicadores de entrada y señales de reloj.

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

Funciones

Las funciones de la unidad de control incluir lo siguiente.

• Dirige el flujo de secuencia de datos entre el procesador y otros dispositivos.
• Puede interpretar las instrucciones y controlar el flujo de datos en el procesador.
• Genera la secuencia de señales de control a partir de las instrucciones recibidas o comandos del registro de instrucciones.
• Tiene la responsabilidad de controlar las unidades de ejecución como ALU, búferes 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 ni almacenar los datos
• Para transferir los datos, se comunica con los dispositivos de entrada y salida y controla todas las unidades de la computadora.

Diseño de la unidad de control

El diseño de este se puede hacer usando dos tipos de unidad de control que incluyen lo siguiente.

• Basado en cableado
• Basado en microprogramaciones (de un solo nivel y de dos niveles)

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 ningún cambio en la estructura del circuito. En esto, la señal generada no se puede modificar para su ejecución en el procesador.

Los datos básicos de un código de operación (el código de operación de una instrucción se envía al decodificador de instrucciones para su decodificación. El decodificador de instrucciones es el conjunto de decodificadores para decodificar diferentes tipos de datos en el código de operación. Esto da como resultado señales de salida que contienen valores de señales activas que se dan como entrada al generador de matrices para generar señales de control para la ejecución de un programa por parte del procesador de la computadora.

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

Para obtener una nueva instrucción, la unidad de control se convierte en una etapa inicial para la ejecución de una nueva instrucción. La unidad de control permanece en la etapa inicial o primera etapa siempre que no se modifiquen las señales de temporización, las señales de entrada y los estados de instrucción de una computadora. El cambio en el estado de la unidad de control se puede plantear si hay algún cambio en alguna de las señales generadas.

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

En el último estado, la unidad de control busca la siguiente instrucción y envía la salida al contador del programa, luego al registro de direcciones de memoria, al registro de búfer y luego al registro de instrucciones para leer la instrucción. Finalmente, si la última instrucción (que es obtenida por la unidad de control) es instrucción final, entonces pasa al estado operativo del procesador y espera hasta que el usuario dirige el siguiente programa.

Unidad de control microprogramada

En este tipo, el almacén de control se utiliza para almacenar las señales de control que se codifican durante la ejecución de un programa. La señal de control no se genera y decodifica inmediatamente porque el microprograma almacena el campo de dirección en el almacén de control. Todo el proceso es de un solo nivel.

Las microoperaciones se realizan para la ejecución de microinstrucciones en el programa. El diagrama de bloques de la unidad de control microprogramada se muestra arriba. Del diagrama, la dirección de la microinstrucción se obtiene del registro de direcciones de la memoria de control. Toda la información de la unidad de control se almacena permanentemente en la memoria de control llamada ROM.

La microinstrucción de la memoria de control se mantiene en el registro de control. Dado que la microinstrucción tiene la forma de palabra de control (contiene valores de control binarios), es necesario realizar 1 o más microoperaciones para el procesamiento de datos.

Durante la ejecución de las microinstrucciones, el siguiente generador de direcciones calculó la siguiente dirección de la microinstrucción y luego la envió al registro de direcciones de control para leer la siguiente microinstrucción.
La secuencia de microoperaciones de una microinstrucción. -El siguiente generador de direcciones realiza el programa y actúa como secuenciador de microprogramas para obtener la dirección de secuencia, es decir, leer de la memoria de control.

Código Verilog para la unidad de control

A continuación se muestra el código Verilog para la unidad de control.

`incluir" prj_definition.v "

módulo 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_RES, RES2, RF_DATA_RES, RF>

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

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

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

// Salidas para memoria
salida [`ADDRESS_INDEX_LIMIT:0] MEM_ADDR;
salida 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 de entrada
inout [`DATA_INDEX_LIMIT:0] MEM_DATA;

// Estado nets
cable [2:0] proc_state;

// contiene el valor del contador del programa, almacena la instrucción actual, apila el registro del puntero

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] estado, next_state;

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

siempre @ (posedge CLK)
comenzar
if (RST)
estado <=RST;
más
estado <=siguiente_stado;

final

siempre @ (estado)
comenzar

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;

caso (estado)

`PROC_FETCH:comenzar
next_state =` PROC_DECODE;
MEM_READ =1’b1;
RF_ADDR_R1 =1’b0; RF_ADDR_R2 =1’b0;
RF_ADDR_W =1’b1;
final

`PROC_DECODE:comenzar
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;
final

`PROC_EXE:comenzar
next_state =` PROC_MEM;
ALU_OP1 =1’b1; ALU_OP2 =1’b1; ALU_OPRN =1’b1;
RF_ADDR_R1 =1’b0;
final

`PROC_MEM:comenzar
next_state =` PROC_WB;
MEM_READ =1’b1; MEM_WRITE =1’b0;
final

`PROC_WB:comenzar
next_state =` PROC_FETCH;
MEM_READ =1’b1; MEM_WRITE =1’b0;
fin
endcase

end
endmodule;

módulo PROC_SM (STATE, CLK, RST);
// lista de entradas
input CLK, RST;
// lista de salidas
output [2:0] STATE;

// lista de entrada
entrada CLK, RST;
// lista de salida
estado de salida;

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

// inicio del estado
inicial
begin
state =2’bxx;
next_state =`PROC_FETCH;
end

// restablecer el manejo de la señal
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)
comenzar
next_state =`PROC_DECODE;

print_instruction (INST_REG);
final

if (estado ===`PROC_DECODE)
comenzar
next_state =` PROC_EXE;

final

if (estado ===`PROC_EXE)
comenzar
siguiente_estado =` PROC_MEM;

print_instruction (SP_REF);
final

if (estado ===`PROC_MEM)
comenzar
next_state =` PROC_WB;

final

if (estado ===`PROC_WB)
comenzar
next_state =` PROC_FETCH;

print_instruction (PC_REG);
final
final

tarea print_instruction;

entrada [`DATA_INDEX_LIMIT:0] inst;

reg [5:0] opcode;
reg [4:0] rs;
reg [4:0] rt;
reg [4:0] rd;
reg [ 4:0] farsa; reg [5:0] funct; reg [15:0] inmediato; reg [25:0] dirección;

comenzar

// analizar la instrucción
// tipo R

{código de operación, rs, rt, rd, simulacro, función} =inst;

// Tipo I
{código de operación, rs, rt, inmediato} =inst;
// Tipo J
{código de operación, dirección} =inst;
$ write (“ @% 6dns -> [0X% 08h] “, $ time, inst);
case (opcode) // R-Type
6'h00:begin
case (funct)

6'h20:$ escribir (“agregar r [% 02d], r [% 02d], r [% 02d];”, rs, rt, rd);
6'h22:$ escribir (“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 (“ y r [% 02d], r [% 02d], r [% 02d]; ”, rs , rt, rd);
6'h25:$ escribir (“o r [% 02d], r [% 02d], r [% 02d];”, rs, rt, rd);
6'h27:$ escribir (“nor r [% 02d], r [% 02d], r [% 02d];”, rs, rt, rd);
6'h2a:$ escribir (“slt r [% 02d], r [% 02d], r [% 02d]; ”, rs, rt, rd);
6'h00:$ escribir (“ 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);
predeterminado:$ write (“”);
endcase
end

// Tecleo

6'h08:$ write (“addi r [% 02d], r [% 02d], 0X% 04h;”, rs, rt, inmediato);
6'h1d:$ write (“muli r [% 02d], r [% 02d], 0X% 04h; ”, rs, rt, inmediato);
6'h0c:$ write (“ andi r [% 02d], r [% 02d], 0X% 04h; ”, Rs, rt, inmediato);
6'h0d:$ write (“ ori r [% 02d], r [% 02d], 0X% 04h; ”, rs, rt, inmediato);
6'h0f:$ write (“lui r [% 02d], 0X% 04h;”, rt, inmediato);
6'h0a:$ write (“slti r [% 02d], r [% 02d], 0X% 04h; ”, rs, rt, inmediato);
6'h04:$ write (“ beq r [% 02d], r [% 02d], 0X% 04h; ”, rs, rt , inmediato);
6'h05:$ write (“bne r [% 02d], r [% 02d], 0X% 04h;”, rs, rt, inmediato);
6'h23:$ write (“lw r [% 02d], r [% 02d], 0X% 04h;”, rs, rt, inmediato);
6'h2b:$ write (“sw r [% 02d], r [% 02d], 0X% 04h; ”, rs, rt, inmediato);

// Tipo J

6'h02:$ write ("jmp 0X% 07h;", ​​dirección);
6'h03:$ write ("jal 0X% 07h;", ​​dirección);
6'h1b:$ write (“Push;”);
6'h1c:$ write (“pop;”);
predeterminado:$ write (“”);
endcase
$ write (“ \ n ”);
finalizar
endtask
finalizar módulo;

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 parte del procesador de una computadora. Controla, gestiona y coordina la memoria principal, ALU, registros, unidades de entrada y salida. Obtiene las instrucciones y genera señales de control para la ejecución.

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

La memoria de control suele ser RAM o ROM para almacenar la dirección y los 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. Utiliza una unidad de almacenamiento para almacenar las secuencias de instrucciones de un microprograma.

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 ningún cambio físico en el circuito. La generación de señales de control depende del registro de instrucciones, el decodificador y las señales de interrupción.

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

La información de la unidad de control o los datos se almacenan 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).

Por lo tanto, se trata de la definición, los componentes, el diseño, el diagrama, las funciones y los tipos de Unidad de control. Aquí tiene una pregunta:"¿Cuál es el propósito del registro de direcciones de control?"