Fundamentos de Arquitectura de Computadores: Ejecución, Memoria y Rendimiento

Fases de Ejecución de Instrucciones en Arquitectura de Computadores

Se presenta la instrucción ADD R1, R2, [R3] y se solicitan las fases de su ejecución.

1. Fase de Fetch (Búsqueda)

En la fase de Fetch, la instrucción es recuperada de la memoria. Las micro-operaciones típicas son:

• AR <-- PC (El Registro de Dirección (AR) obtiene el valor del Contador de Programa (PC))
• PC <-- PC + n (El Contador de Programa (PC) se incrementa para apuntar a la siguiente instrucción)
• DR <-- M(AR) (El Registro de Datos (DR) obtiene el contenido de la Memoria (M) en la dirección indicada por AR)
• IR <-- DR (El Registro de Instrucción (IR) obtiene el contenido del DR)

Los componentes del computador involucrados en esta fase son:

• Registros: PC (Program Counter), AR (Address Register), DR (Data Register), IR (Instruction Register).
• Memoria: Se accede en lectura para recuperar el código binario de la instrucción a ejecutar.

2. Fase de Decodificación

En la fase de Decodificación, la instrucción recuperada es interpretada para determinar la operación a realizar y los operandos necesarios.

Los componentes involucrados en esta fase son:

• Registro de Instrucción (IR): Contiene la instrucción a decodificar.
• Unidad de Control: Genera las señales de control necesarias para la ejecución de la instrucción.

3. Fase de Ejecución

En la fase de Ejecución, la operación especificada por la instrucción se lleva a cabo.

Participan los siguientes elementos:

• Registros de Propósito General: R1, R2, R3, que forman parte del Banco de Registros (BR).
• Memoria: Se produce un acceso a lectura (o escritura) si la instrucción lo requiere, junto con sus registros asociados AR y DR.
• ALU (Unidad Aritmético-Lógica): Realiza las operaciones aritméticas y lógicas.
• Registro de Estado: Activa los flags correspondientes en función del resultado de la operación (ej. cero, negativo, acarreo).

Direccionamiento de Memoria y Registros Afectados

Sabiendo que un computador puede direccionar 256 GB, ¿cuántos bits se emplean para las direcciones de memoria y qué registros se ven afectados?

Cálculo de bits para el bus de direcciones:

• 256 GB = 2^8 * 2^30 B = 2^38 B

Para ser capaz de direccionar una memoria física de 256 GB, el bus de direcciones necesita tener al menos 38 bits.

Registros afectados:

Esto afecta a todos los registros que pueden contener direcciones de memoria, tales como:

• PC (Program Counter)
• AR (Address Register)
• SP (Stack Pointer)
• FP (Frame Pointer)

Si el procesador dispone de direccionamiento relativo a registro, los registros de propósito general del banco de registros también se verán afectados en su tamaño mínimo, ya que pueden contener direcciones.

Cálculo de Productividad: MIPS

Suponiendo que la ejecución de cada instrucción de cierto programa empleara 160 ciclos y la frecuencia del procesador es de 2 GHz, ¿cuál sería la productividad expresada en MIPS?

Datos:

• Ciclos por instrucción: 160 ciclos
• Frecuencia (f): 2 GHz

Cálculos:

1. Tiempo de ciclo (T_ciclo):
   T_ciclo = 1 / f = 1 / 2 GHz = 1 / (2 * 10^9 Hz) = 0.5 * 10^-9 s = 0.5 ns
2. Tiempo por instrucción:
   Tiempo por instrucción = Ciclos por instrucción * T_ciclo = 160 ciclos * 0.5 ns/ciclo = 80 ns/instrucción
3. MIPS (Millones de Instrucciones Por Segundo):
   MIPS = (1 / Tiempo por instrucción) / 10^6
MIPS = (1 / 80 ns) / 10^6 = (1 / (80 * 10^-9 s)) / 10^6
MIPS = (12.5 * 10^6 I/s) / 10^6 = 12.5 MIPS

La productividad del procesador es de 12.5 MIPS.

Ejemplos de Decodificación de Instrucciones y Micro-operaciones

A continuación, se detallan las micro-operaciones para diversas instrucciones, interpretando la sintaxis proporcionada.

1. Instrucción: ADD R3, [--R8], [#8[R7]]

Esta instrucción realiza una suma donde el primer operando se obtiene de la memoria con pre-decremento en R8, y el segundo operando se obtiene de la memoria mediante doble indirección con offset en R7.

• R8 <-- R8 - 8 (Pre-decremento del registro R8)
• T_OP1 <-- M(R8) (Carga el primer operando desde la memoria apuntada por R8)
• T1 <-- R7 (Copia R7 a un registro temporal T1)
• T1 <-- T1 + 8 (Calcula la dirección base para el segundo operando)
• T1 <-- M(T1) (Carga la dirección del segundo operando desde la memoria en T1)
• T_OP2 <-- M(T1) (Carga el segundo operando desde la memoria en la dirección obtenida en T1)
• R3 <-- T_OP1 + T_OP2 (Suma ambos operandos y almacena el resultado en R3)

2. Instrucción: DBNZ R3, #24[--R4]

Decrementa R3 y salta si R3 no es cero. El segundo operando parece indicar un cálculo de dirección de salto, aunque el [--R4] se interpreta como una operación separada.

• R3 <-- R3 - 1 (Decrementa el registro R3)
• R4 <-- R4 - 8 (Pre-decremento del registro R4)
• T1 <-- R4 (Copia R4 a un registro temporal T1)
• T1 <-- T1 + 24 (Calcula la dirección de salto relativa)
• IF R3 != 0 THEN PC <-- T1 (Si R3 no es cero, el Contador de Programa (PC) se actualiza con la dirección calculada en T1, realizando el salto)

3. Instrucción: SWAP [R1], [#16[R2++]]

Intercambia el contenido de dos posiciones de memoria, con post-incremento en R2.

• T1 <-- R2 (Copia R2 a un registro temporal T1)
• T1 <-- T1 + 16 (Calcula la dirección para el segundo operando)
• SWAP M(R1), M(T1) (Intercambia el contenido de la memoria en la dirección de R1 con el contenido de la memoria en la dirección de T1)
• R2 <-- R2 + 8 (Post-incremento del registro R2)

4. Instrucción: CALL [#4[R7]]

Llama a una subrutina cuya dirección está almacenada en una posición de memoria calculada.

• RT1 <-- R7 (Copia R7 a un registro temporal RT1)
• RT1 <-- RT1 + 4 (Calcula la dirección base para obtener la dirección de la subrutina)
• RT1 <-- M(RT1) (Carga la dirección de la subrutina desde la memoria en RT1)
• PC <-- RT1 (El Contador de Programa (PC) se actualiza con la dirección de la subrutina, transfiriendo el control. Se asume que el PC actual se guarda en la pila antes de este salto.)

5. Instrucción: OR [R1], [#4[R7++]]

Realiza una operación OR bit a bit entre el contenido de una posición de memoria y un valor obtenido de otra posición de memoria, con post-incremento en R7.

• RT1 <-- R7 (Copia R7 a un registro temporal RT1)
• RT1 <-- RT1 + 4 (Calcula la dirección base para el segundo operando)
• RT1 <-- M(RT1) (Carga la dirección del operando desde la memoria en RT1)
• RT1 <-- M(RT1) (Carga el valor del operando desde la memoria en RT1, doble indirecto)
• RT2 <-- M(R1) (Carga el contenido de la memoria en la dirección de R1 en RT2)
• RT2 <-- RT2 OR RT1 (Realiza la operación OR bit a bit entre RT2 y RT1, almacenando el resultado en RT2)
• M(R1) <-- RT2 (Almacena el resultado de la operación OR de vuelta en la memoria en la dirección de R1)
• R7 <-- R7 + 4 (Post-incremento del registro R7)