Arquitectura de Computadores: Resumen de Conceptos

Unidades Funcionales

IF (Fetch): Lugar donde residen las instrucciones del programa. Se corresponde con la caché L1 de instrucciones (L1I). Solo lectura.

• PC (Program Counter): Registro de 32 bits que contiene la dirección de la siguiente instrucción a leer y ejecutar.
• Sumador: Para calcular la dirección de la siguiente instrucción a ejecutar.

ID (Decode):

• Banco de Registros: 32 registros de 32 bits cada uno. Cada registro tiene un identificador de 5 bits.

EX (Execute):

• Concatenador: Para obtener la dirección destino de una instrucción J (Jump).
• Sumador: Calcular la dirección destino de un salto BEQ (Branch if Equal).
• ALU (Arithmetic Logic Unit): Tiene 2 entradas y produce un resultado de 32 bits y una señal Z que se activa cuando el resultado es 0. Según la instrucción, el segundo parámetro puede venir de un offset o de otro registro.

MEM (Memory):

• PC: Si la instrucción es de salto, se sobrescribe el PC con la dirección calculada en la fase anterior, proveniente del concatenador o sumador.
• MEM DATOS: Se almacenan los datos del programa. Se corresponde con la L1D, tiene 2 entradas y 1 salida. Si se va a leer, se usa la primera entrada y la salida, y si se va a escribir, se usan las dos entradas.

WB (Write Back):

• BANCO REG: El valor a guardar puede venir de la ALU (operaciones aritmético-lógicas) o de memoria (instrucciones de carga y descarga). El identificador del registro destino puede estar en 2 posiciones: bits 20-16 si es de carga, o bits 15-11 si es aritmético-lógica.

Señales de Control

• RegWrite: Controla cuándo se escribe en el banco de registros. Debe estar activa en el flanco de subida.
• RegDst: Determina de dónde proviene el identificador del registro. 1 si es aritmético-lógica, 0 si es de carga.
• RegSrc: Determina de dónde proviene el dato que se almacena en el registro destino. 1 si viene de memoria, 0 si viene de la ALU.
• PCSrc1: 1 si la siguiente instrucción es un salto J, 0 si no.
• PCSrc2: 1 si la siguiente instrucción es un salto BEQ, 0 si no (se suma +4 al PC).
• ALUSrc: Determina de dónde proviene el segundo operando de la ALU. 1 si viene de un offset (carga-almacenamiento), 0 si viene de un registro (aritmético-lógica y saltos).
• ALUop: Señal de 4 bits usada para seleccionar la operación de la ALU.
• MemRead: Controla cuándo leer de la memoria de datos. 1 si lee datos, 0 si no hace nada.
• MemWrite: Controla cuándo se realiza una escritura en la memoria de datos. 1 si escribe, 0 si no.

MemRead y MemWrite no pueden estar activas al mismo tiempo.

Tabla de Señales de Control

• LW: RegWrite, RegSrc y MemRead
• SW: ALUSrc y MemWrite
• ADD, SUB, AND, OR: RegWrite y RegDst
• BEQ: PCSrc2
• J: PCSrc1

Dependencias

RAW (Read After Write): La segunda instrucción no puede ejecutarse hasta que acabe la primera. Es una dependencia verdadera, ya que hay transferencia de datos entre instrucciones. Solución: Anticipar el resultado o reordenar el código. Si no, se produce un bloqueo.

WAR (Write After Read): La segunda instrucción no puede ejecutarse hasta que acabe la primera. Es una dependencia falsa, porque no hay transferencia entre instrucciones. Solución: Renombre de registros.

WAW (Write After Write): Dependencia falsa, ya que la instrucción 3 no puede acabar antes que la 1; de lo contrario, habrá valores inadecuados en los registros. Solución: Renombre de registros.

CISC vs. RISC

CISC (Complex Instruction Set Computer)

• Implementado en x86 e IA-32.
• Tamaño de instrucciones variable.
• Muchas instrucciones, muy específicas.
• Muchos modos de direccionamiento.
• Registros específicos de muchos tamaños.
• Paralelismo complicado.
• Muy optimizado para instrucciones.
• Compiladores más simples y menos costosos.

RISC (Reduced Instruction Set Computer)

• Implementado en MIPS y ARM.
• Tamaño de instrucción fijo y corto.
• Instrucciones simples y reducidas.
• Pocos modos de direccionamiento.
• Gran número de registros.
• Paralelismo simplificado.
• Muy simple y fácil manejo.
• CPU más rápida.

Modos de Operación x86

1. Modo heredado:
   1. Modo real: sistema de 16 bits, registros de 16 bits.
   2. Modo virtual: sistema de 32 bits, registros de 16 bits.
   3. Modo protegido: sistema de 32 bits, registros de 32 bits.
2. Modo extendido:
   1. Modo compatibilidad: sistema de 64 bits, registros de 16 o 32 bits.
   2. Modo 64: sistema de 64 bits, registros de 64 bits.

Registros x86 (64 bits/32 bits)

• RAX/EAX: Acumulador de operando y del resultado.
• RBX/EBX: Puntero a datos en el segmento de datos (DS).
• RCX/ECX: Contador para cadenas y bucles.
• RDX/EDX: Puntero de entrada y salida de datos.
• RSI/ESI: Puntero origen de operaciones con cadenas y a DS.
• RDI/EDI: Puntero al segmento de cadenas y destino de estas.
• RSP/ESP: Puntero de pila.
• RBP/EBP: Puntero a datos de pila.

Tipos de Instrucciones x86

• Destructivas: Ejemplo: ADD EAX, EBX
• Acceso a memoria: Ejemplo: ADD EAX, [etiqueta]
• Ambiguas: Ejemplo: ADD EAX, [inmediato]

Tipos de Direccionamiento x86

• Registro: Permite usar un dato almacenado en un registro.
• Inmediato: Se especifica un operando en la propia instrucción.
• Implícito: Algunas operaciones llevan registros predeterminados.
• A memoria: Utiliza como operando un valor de memoria. Se accede a él con []. Para obtener la dirección a la que hace referencia la etiqueta, se usa ADDR. Dentro de [] puede ir un inmediato, una etiqueta, un registro de 32 bits o una operación (puntero base + desplazamiento): [EBX + (ECX * 4)]. Se debe indicar el tamaño del dato.

Pila

El funcionamiento sigue la estructura LIFO (último en entrar, primero en salir). Los registros tienen un tamaño de doble palabra y la pila tiene un puntero que, al meter un dato, hace que su valor disminuya en 4, y si se saca un dato, aumenta en 4. Su uso principal es para pasar parámetros a subprogramas. Al iniciar un programa con la orden CALL, se introduce EBP en la pila con el valor de ESP, y cuando se acaba el programa, se resta el valor de ESP a EBP. Para volver de un subprograma al programa principal, se usa RET.