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 mediante el procesador /ordenador. 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 entregan 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 una 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 del memoria principal de un procesador y se envía al registro de instrucciones del procesador, que contiene el contenido del registro.
Diagrama de bloques de la unidad de control
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 unidad central de procesamiento (CPU) y 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 instrucciones registros , 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 registro de instrucciones (contiene código de operación y campo de dirección), unidad de temporización, estado de control generador , matriz de generación de señales de control y decodificador de instrucciones.
Los componentes de la unidad de control microprogramada son el siguiente generador de direcciones, un registro de direcciones de control, una memoria de control y un registro de datos de control.
Funciones
los funciones de la unidad de control Incluya lo siguiente.
- Dirige el flujo de secuencia de datos entre el procesador y otros dispositivos.
- Puede interpretar las instrucciones y controla 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úfer 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 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 Unidad de Control
El diseño de esto se puede hacer usando dos tipos de una unidad de control que incluyen lo siguiente.
- Basado en cableado
- Basado en microprogramaciones (de un 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 hardware especial circuito lógico 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. descifrador 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 matriz para generar señales de control para la ejecución de un programa por parte del procesador de la computadora.
Unidad de control basada en cableado
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 el 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 mientras las señales de temporización, señales de entrada y estados de instrucción de una computadora no cambien. El cambio en el estado de la unidad de control puede elevarse si hay algún cambio en alguna de las señales generadas.
Cuando ocurre una señal externa o interrupción, la unidad de control pasa al siguiente estado y realiza el procesamiento de la señal de interrupción. Los indicadores y 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 captada por la unidad de control) es instrucción de fin, 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.
Unidad de control microprogramada
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 una 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 un microprograma la realiza el siguiente generador de direcciones 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
El código Verilog para la unidad de control se muestra a continuación.
`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, RF_DATA_RES, RF_DATA_RES, RF
// Señales de salida
// Salidas para el 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
entrada [`DATA_INDEX_LIMIT: 0] RF_DATA_R1, RF_DATA_R2, ALU_RESULT
entrada CERO, CLK, RST
// Señal de entrada
inout [`DATA_INDEX_LIMIT: 0] MEM_DATA
// Redes estatales
cable [2: 0] proc_state
// mantiene 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
si (RST)
Expresar<= RST
más
Expresar<= next_state
fin
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
fin
`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
fin
`PROC_EXE: comenzar
next_state = `PROC_MEM
ALU_OP1 = 1’b1 ALU_OP2 = 1’b1 ALU_OPRN = 1’b1
RF_ADDR_R1 = 1’b0
fin
`PROC_MEM: comenzar
next_state = `PROC_WB
MEM_READ = 1’b1 MEM_WRITE = 1’b0
fin
`PROC_WB: comenzar
next_state = `PROC_FETCH
MEM_READ = 1’b1 MEM_WRITE = 1’b0
fin
caso final
fin
endmodule
módulo PROC_SM (STATE, CLK, RST)
// lista de entradas
entrada CLK, RST
// lista de salidas
salida [2: 0] ESTADO
// lista de entrada
entrada CLK, RST
// lista de salida
ESTADO de salida
reg [2: 0] ESTADO
estado reg [1: 0]
reg [1: 0] next_state
reg PC_REG, INST_REG, SP_REF
`define PROC_FETCH 3’h0
`define PROC_DECODE 3’h1
`definir PROC_EXE 3’h2
`definir PROC_MEM 3'h3
`define PROC_WB 3’h4
// iniciación del estado
inicial
comenzar
estado = 2’bxx
next_state = `PROC_FETCH
fin
// restablecer el manejo de la señal
siempre @ (posedge RST)
comenzar
estado = `PROC_FETCH
next_state = `PROC_FETCH
fin
siempre @ (posedge CLK)
comenzar
state = next_state
fin
siempre @ (estado)
comenzar
si (estado === `PROC_FETCH)
comenzar
next_state = `PROC_DECODE
print_instruction (INST_REG)
fin
si (estado === `PROC_DECODE)
comenzar
next_state = `PROC_EXE
fin
si (estado === `PROC_EXE)
comenzar
next_state = `PROC_MEM
print_instruction (SP_REF)
fin
si (estado === `PROC_MEM)
comenzar
next_state = `PROC_WB
fin
si (estado === `PROC_WB)
comenzar
next_state = `PROC_FETCH
print_instruction (PC_REG)
fin
fin
tarea print_instruction
entrada [`DATA_INDEX_LIMIT: 0] inst
reg [5: 0] código de operación
reg [4: 0] rs
reg [4: 0] rt
reg [4: 0] rd
reg [4: 0] shamt reg [5: 0] funct reg [15: 0] inmediata reg [25: 0] dirección
comenzar
// analizar la instrucción
// tipo R
{opcode, rs, rt, rd, shamt, funct} = inst
// Yo tecleo
{código de operación, rs, rt, inmediato} = inst
// tipo J
{código de operación, dirección} = inst
$ escribir ('@% 6dns -> [0X% 08h]', $ tiempo, inst)
case (código de operación) // R-Type
6'h00: inicio
case (función)
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: $ escribir ('mul r [% 02d], r [% 02d], r [% 02d]', rs, rt, rd)
6’h24: $ escribir ('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: $ escribir ('srl r [% 02d], 0X% 02h, r [% 02d]', rs, shamt, rd)
6’h08: $ escribir ('jr r [% 02d]', rs)
predeterminado: $ escribir ('')
caso final
fin
// Yo tecleo
6’h08: $ escribir ('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: $ escribir ('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: $ escribir ('beq r [% 02d], r [% 02d], 0X% 04h', rs, rt, inmediato)
6’h05: $ escribir ('bne r [% 02d], r [% 02d], 0X% 04h', rs, rt, inmediato)
6’h23: $ escribir ('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: $ escribir ('presionar')
6’h1c: $ write ('pop')
predeterminado: $ escribir ('')
caso final
$ escribir (' n')
fin
tarea final
módulo final
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 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?
El secuencial y circuitos 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, decodificador y 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 la memoria de acceso aleatorio (RAM) y la memoria de solo lectura (ROM).
Por lo tanto, se trata de la definición, componentes, diseño, diagrama, funciones y tipos de unidad de control . Aquí tiene una pregunta: '¿Cuál es el propósito del registro de direcciones de control?'
