Teoría del todo

Parte V · Del electrón al programa

Del sumador a la CPU

en cursoÚltima actualización: 23 de octubre de 2026 · Primera versión del capítulo

Se construye sobre: Lógica y compuertas

Cuando sumas a mano 47 + 38, haces algo que ya ni notas. Siete más ocho, quince: escribes el cinco y “llevas uno”. Cuatro más tres más el que llevabas, ocho. Resultado, 85. Es un procedimiento local y repetitivo: cada columna mira solo sus dos cifras y lo que le llega de la derecha, produce una cifra y le pasa algo a la izquierda. Un procedimiento así se puede cablear. Este capítulo es el recorrido desde esa suma de escuela hasta una máquina que ejecuta programas, sin agregar ninguna pieza nueva: solo las compuertas del capítulo anterior, conectadas con cuidado.

Contar con dos dedos

Nuestro sistema de numeración es posicional: en 85, el 8 vale ocho decenas. Nada obliga a que la base sea diez, y como un transistor tiene dos estados cómodos, los computadores usan base dos. En binario cada posición vale el doble de la anterior:

Es el mismo número once de siempre, el de los números, escrito con otra regla. Cada cifra binaria es un bit, la misma unidad que en entropía e información mide la sorpresa de una moneda justa. Con bits se escriben los enteros de 0 a : con 4, de 0 a 15; con 64, hasta más de dieciocho trillones.

Sumar con compuertas

La suma binaria de una columna tiene una tabla diminuta. 0 + 0 = 0; 0 + 1 = 1; 1 + 1 = 10, es decir, escribo 0 y llevo 1. Si miras solo la cifra que se escribe, es 1 cuando las entradas son distintas: es un XOR. Si miras solo lo que se lleva, es 1 cuando las dos son 1: es un AND. Ese par de compuertas se llama medio sumador:

“Medio” porque le falta algo: en cualquier columna que no sea la primera también llega un acarreo de la derecha, y hay que sumar tres bits. El sumador completo lo hace con dos medios sumadores en cadena y un OR para juntar los dos acarreos posibles:

La forma de comprobarlo es la de siempre con tablas de verdad: son ocho filas, y en todas se cumple que . Para sumar números de bits pones sumadores completos en fila y conectas el acarreo de salida de cada uno con la entrada del siguiente. Es literalmente el “llevo uno” de la escuela, hecho de cobre y silicio.

Juega · un sumador de 4 bits

Toca los bits de A y de B. Cada caja es un sumador completo; el acarreo viaja de derecha a izquierda.

23 = 8
22 = 4
21 = 2
20 = 1
A
B
Σ10Σ10Σ10Σ0011sale

11 + 6 = 17

A
1011
B
0110
suma en 4 bits
0001 = 1

17 no cabe en 4 bits: el acarreo se sale por la izquierda y lo que queda es 17 − 16 = 1. Con 4 bits, el sumador calcula módulo 16.

Prueba 11 + 6. En binario es 1011 + 0110. La columna de la derecha da 1 sin acarreo; las otras tres dan 0 y llevan 1 cada una. El acarreo recorre la fila y se sale por la izquierda, y los cuatro bits que quedan dicen 0001: uno. El resultado verdadero es 17, que no cabe en 4 bits. Lo que calculó el sumador es 17 − 16. Con bits, toda suma es en realidad una suma módulo , la aritmética del reloj de anillos y cuerpos. Ese acarreo que se pierde se llama desborde, y es la razón de más de un error famoso en software.

El reloj, además, regala los números negativos. En el reloj de 16 horas, 1111 + 0001 da 0000, así que 1111 se comporta exactamente como −1: sumarlo es restar uno. Esa convención, el complemento a dos, deja que el mismo circuito sume y reste sin saber de signos. Es la estructura de grupo de la suma en el reloj de anillos y cuerpos, cableada.

Hay un detalle de tiempo que conviene notar. En 15 + 1 el acarreo tiene que atravesar las cuatro columnas, una tras otra, y cada compuerta tarda un poquito. Con 64 bits ese recorrido se vuelve lento, así que los procesadores usan sumadores más ingeniosos que calculan los acarreos por anticipado, en grupos, y el tiempo crece como el logaritmo del número de bits en vez de crecer en proporción. Es una pregunta de complejidad resuelta en hardware.

Recordar: una compuerta que se mira a sí misma

Un sumador es una función: la salida depende solo de lo que entra ahora. Para hacer una máquina hace falta lo contrario, que algo dependa de lo que pasó antes. La solución es conectar salidas a entradas. Toma dos compuertas NOR y lleva la salida de cada una a una entrada de la otra. Si la primera está en 1, obliga a la segunda a estar en 0, que a su vez deja a la primera en 1: el circuito se sostiene solo. Y el estado opuesto también. Con las otras dos entradas (fijar y borrar) lo empujas a uno u otro, y cuando las sueltas, se queda donde lo dejaste. Eso es un latch: un bit de memoria hecho de realimentación.

Con un poco más de circuito se obtiene el flip-flop, que copia el valor de su entrada solo en el instante en que una señal de control sube, y lo mantiene el resto del tiempo. Un registro es una fila de flip-flops, por ejemplo 64, que guarda un número entero. La memoria caché del procesador usa una versión compacta del latch: dos inversores cruzados y dos transistores de acceso, seis por bit. La memoria RAM principal usa un truco más barato: un transistor y un diminuto condensador por bit, cargado o descargado. Como el condensador se descarga solo, cada bit hay que releerlo y reescribirlo cada pocas decenas de milisegundos; y, como toda la RAM, olvida todo cuando se apaga.

El reloj

Ya hay piezas que calculan y piezas que recuerdan. Falta ponerlas de acuerdo, porque las señales tardan en propagarse y en algún momento hay que decidir que el resultado ya está listo. Eso lo hace el reloj: una señal que sube y baja a ritmo fijo, generada casi siempre a partir de un cristal de cuarzo que vibra y multiplicada después por circuitos que la aceleran. En cada subida, los flip-flops capturan lo que tienen en la entrada; entre una subida y la siguiente, las compuertas tienen tiempo de terminar sus cuentas. Ese es el diseño síncrono: el estado cambia a saltos, y en cada salto el estado siguiente es una función del estado actual y de las entradas.

Oscilador de cristal abierto sobre papel milimetrado: dentro de una cajita metálica de pocos milímetros hay un disco delgado de cuarzo con un electrodo plateado, sostenido por unos soportes, junto a unos componentes electrónicos diminutos
Un oscilador de cristal de 16,257 MHz abierto, sobre papel milimetrado. El disco transparente es el cuarzo: vibra a una frecuencia fijada por su tamaño y su corte, y el circuito de al lado lo mantiene vibrando y convierte esa vibración en la señal que sube y baja del reloj.Foto: Marcin Andrzejewski · CC BY-SA 3.0 · Wikimedia Commons

Un reloj de 3 GHz da tres mil millones de pulsos por segundo; cada ciclo dura un tercio de nanosegundo, el tiempo en que la luz recorre unos diez centímetros. Pero conviene no leer de más en ese número. Los GHz dicen cuántos ciclos hay por segundo, no cuánto trabajo se hace en cada uno: un procesador moderno trabaja en cadena, con varias instrucciones a medio hacer al mismo tiempo, puede terminar varias por ciclo o quedarse esperando muchos ciclos a que llegue un dato de la memoria, y tiene varios núcleos. Comparar dos procesadores de diseños distintos por sus GHz es casi tan informativo como comparar dos carros por las revoluciones del motor. Y desde mediados de los años 2000 la frecuencia casi dejó de subir: subirla más disparaba el calor, el mismo problema de termodinámica que asoma en semiconductores. La industria respondió con más núcleos en vez de núcleos más rápidos.

Una CPU de juguete

Con sumadores, registros y un reloj ya se puede armar un procesador. Imagina uno mínimo con dos registros de datos, y , y un registro especial, el contador de programa (PC), que dice en qué instrucción va. Las instrucciones están en una memoria, numeradas, y cada una es un patrón de bits: unos bits dicen qué operación es y otros dicen sobre qué. Este programa multiplica 3 por 5 sin saber multiplicar:

  1. 0 · CARGAR R0, 0
  2. 1 · CARGAR R1, 3
  3. 2 · SUMAR R0, 5
  4. 3 · RESTAR R1, 1
  5. 4 · SI R1 ≠ 0, SALTAR A 2
  6. 5 · PARAR

La máquina repite un solo ciclo, siempre el mismo. Buscar: lee de la memoria la instrucción en la posición que indica el PC. Decodificar: los bits de la operación encienden las líneas de control correctas, por ejemplo las que conectan a la entrada del sumador. Ejecutar: el sumador hace su cuenta, el resultado se guarda en el registro en el siguiente pulso del reloj, y el PC avanza en uno, o salta a otra posición si la instrucción era un salto y se cumple su condición.

Síguelo a mano. Después de las instrucciones 0 y 1, y . Primera vuelta: R0 queda en 5, R1 en 2, y como R1 no es cero, el PC vuelve a 2. Segunda: 10 y 1, vuelve. Tercera: 15 y 0, y esta vez no salta; el PC sigue a 5 y la máquina para con . La multiplicación salió de sumar, restar y una sola decisión. Ese salto condicional, la capacidad de elegir qué hacer después según un resultado, es lo que convierte una calculadora en un computador.

Hay una idea más, sutil y enorme: las instrucciones viven en la misma memoria que los datos, y son bits como cualquier otro. Esa arquitectura de programa almacenado suele asociarse al informe que John von Neumann escribió en 1945, aunque la idea se gestó entre varias personas. Su consecuencia es que un programa puede leer, escribir o generar otros programas, y eso es lo que hace posible un compilador, un sistema operativo o un intérprete.

Lo que queda por preguntar

Mira el camino completo. Un voltaje en una compuerta abre un canal de silicio. Dos transistores niegan, cuatro hacen un NAND, unas cuantas NAND suman un bit, una fila de sumadores suma números, dos compuertas cruzadas recuerdan, un reloj pone orden y un contador recorre una lista de instrucciones. Ninguna pieza entiende nada; todas son interruptores. Y sin embargo la máquina multiplica, y con las mismas piezas, multiplicadas por millones, ejecuta las sumas y productos de una red neuronal.

Con memoria suficiente, un procesador así puede ejecutar cualquier procedimiento que se pueda describir paso a paso, y aquí empieza otra pregunta, que ya no es de electrónica: qué cosas se pueden describir paso a paso y cuáles no. Esa es la de qué se puede computar, y después, la de cuánto cuesta hacerlo, en algoritmos y complejidad.