Un programa no llega a la CPU como una idea completa, sino como una secuencia de instrucciones muy pequeñas. En esta presentación seguiremos una de ellas desde que la CPU sabe cuál debe leer hasta que guarda su resultado. Para entender el recorrido recuperaremos tres componentes ya conocidos: los registros, que guardan datos muy cerca de la CPU; la memoria, donde se encuentran las instrucciones del programa; y la ALU, que realiza cálculos y comparaciones. Al terminar, deberías poder contar con tus propias palabras qué ocurre cuando la CPU recibe una orden y por qué los distintos componentes deben colaborar en un orden concreto.
Esta instrucción es un ejemplo simplificado de una orden que podría formar parte de un programa. Indica que se deben tomar los valores que hay en los registros `R1` y `R2`, sumarlos y dejar el resultado en `R3`. Los registros son pequeñas ubicaciones de almacenamiento dentro de la CPU, mucho más rápidas que la memoria principal. Para completar la orden, la CPU no la resuelve de golpe: primero debe localizarla, interpretarla, preparar los datos, realizar el cálculo y conservar el resultado. En las siguientes diapositivas veremos cada una de esas acciones. La forma exacta de escribir una instrucción cambia de una arquitectura a otra; aquí usamos una notación pensada para hacer visibles sus partes.
Una CPU no entiende órdenes escritas en lenguaje natural como «suma estos números». Solo reconoce un repertorio limitado y preciso de instrucciones codificadas en bits. Ese repertorio recibe el nombre de conjunto de instrucciones o ISA (*Instruction Set Architecture*). Algunas instrucciones calculan, como `SUMAR`; otras trasladan información, como `COPIAR`; y otras cambian el orden normal del programa, como `SALTAR`. Cada familia de procesadores define su propio vocabulario y sus propias reglas para escribirlo. Por eso el mismo programa, antes de ejecutarse, debe traducirse a instrucciones adecuadas para la CPU que lo va a ejecutar.
Una instrucción combina dos tipos de información. El *opcode* (código de operación) indica qué debe hacer la CPU; en este caso, `SUMAR`. Los operandos indican con qué datos o ubicaciones debe trabajar. Aquí `R1` y `R2` son los registros de origen, porque contienen los valores que se van a sumar, y `R3` es el registro de destino, porque recibirá el resultado. En el interior del equipo todo esto se representa con ceros y unos, no con las palabras de esta diapositiva. Sin embargo, separar opcode y operandos permite entender cualquier instrucción básica: una parte expresa la acción y las demás identifican los datos implicados.
Las arquitecturas no organizan su vocabulario de instrucciones exactamente igual. En una aproximación RISC se prefieren instrucciones sencillas y regulares; para una tarea completa pueden ser necesarias varias órdenes. ARM es un ejemplo habitual de esta familia. En una aproximación CISC, una sola instrucción puede expresar una operación más compleja; x86 es el ejemplo más conocido. No significa que una familia sea simplemente «mejor» o siempre más rápida que la otra. Los procesadores actuales usan técnicas internas muy sofisticadas y a menudo combinan ideas de ambos enfoques. Lo importante aquí es comprender que el conjunto de instrucciones es el idioma que determina cómo se expresa el trabajo que debe hacer la CPU.
La CPU ejecuta los programas repitiendo un ciclo de cuatro fases. Primero busca la siguiente instrucción en memoria. Después la decodifica, es decir, determina qué significa y qué recursos necesita. A continuación la ejecuta y, por último, almacena el resultado cuando existe. Este ciclo se repite millones o miles de millones de veces por segundo. Aunque las CPUs reales pueden solapar varias instrucciones para ganar rendimiento, este recorrido de cuatro fases es el modelo básico que permite entender qué papel desempeña cada componente.
La fase de búsqueda comienza en el contador de programa, o `PC` (*Program Counter*). Este registro contiene la dirección de memoria donde está la próxima instrucción que debe ejecutarse. La CPU usa esa dirección para leer la instrucción desde la memoria y la copia al registro de instrucción, o `IR` (*Instruction Register*). El `IR` mantiene la instrucción disponible mientras la CPU la interpreta y la ejecuta. Mientras tanto, el `PC` queda preparado para apuntar a la siguiente dirección consecutiva. Más adelante veremos una excepción importante: una instrucción de salto puede cambiar ese recorrido y colocar en el `PC` una dirección distinta.
Cuando la instrucción está en el `IR`, la unidad de control la interpreta. En `SUMAR R3, R1, R2` reconoce que la operación es una suma, identifica que los datos de entrada están en `R1` y `R2` y que el destino es `R3`. Decodificar no es hacer el cálculo. La unidad de control actúa como coordinadora: activa las señales necesarias para que los registros proporcionen los datos, la ALU realice la operación y el resultado llegue a su destino. Esta preparación es necesaria porque cada tipo de instrucción necesita un recorrido interno diferente.
En esta instrucción, la unidad de control permite que los valores de `R1` y `R2` lleguen a la ALU (*Arithmetic Logic Unit*). La ALU suma ambos valores y produce un resultado. El diagrama representa precisamente ese movimiento de datos: los registros de origen aportan sus valores, la ALU los combina y el resultado queda disponible para el siguiente paso. La ejecución depende del opcode. Una suma necesita una operación aritmética de la ALU, pero una instrucción de copia podría limitarse a mover datos y una instrucción de salto cambiaría el valor del `PC`. Por tanto, «ejecutar» significa llevar a cabo la acción indicada, no necesariamente hacer un cálculo.
Tras sumar los dos valores, el resultado debe guardarse en el lugar indicado por la instrucción. En `SUMAR R3, R1, R2`, ese lugar es el registro `R3`; su contenido anterior se sustituye por el nuevo valor. Así, una instrucción posterior puede usar `R3` como dato de entrada. Según el tipo de instrucción, el resultado también puede escribirse en memoria o enviarse a un dispositivo de salida. No todos los resultados pasan por la RAM: cuando basta con conservarlos para el siguiente cálculo, mantenerlos en registros es más rápido y evita movimientos innecesarios.
Esta traza reúne las cuatro fases aplicadas a una instrucción concreta. El `PC` localiza la instrucción y esta se guarda en el `IR`. La unidad de control reconoce que debe sumar. Después los valores de `R1` y `R2` pasan a la ALU, que calcula el resultado, y finalmente ese resultado se escribe en `R3`. El orden importa: la CPU no puede sumar antes de saber qué instrucción debe ejecutar ni puede guardar el resultado antes de producirlo. Si en lugar de `SUMAR` apareciera `SALTAR 200`, las primeras fases serían parecidas, pero durante la ejecución se cambiaría el `PC` para que la siguiente búsqueda se realizara en la dirección 200, no en la dirección consecutiva.
`SALTAR 200` es una instrucción de control de flujo. Durante su ejecución, la CPU coloca 200 en el `PC`. Por eso, en el siguiente ciclo de búsqueda no leerá la instrucción situada justo después de `SALTAR`, sino la que se encuentre en la dirección 200. Los saltos permiten tomar decisiones, repetir pasos y cambiar el orden lineal de un programa. Como comprobación final, en `SUMAR R3, R1, R2` el opcode es `SUMAR`; `R1` y `R2` son operandos de origen, y `R3` es el operando de destino. Si puedes identificar estas partes y explicar la traza de la diapositiva anterior, ya puedes analizar el recorrido básico de una instrucción en la CPU.