ALU elemental

01 · Punto de partida

Calculadora de 5 botones

El mismo silicio suma, resta y opera bits según S1S0 + M: AND, OR, XOR, ADD, SUB. Más 4 banderas (Z, C, N, V) que el micro usará para saltar. Es la 74181 en miniatura.

• ¿Qué hace cada operación?
• ¿Cómo se resta sin restador?
• ¿Qué avisa cada flag?
• ¿Cómo crece a N bits?

02 · Operaciones

Cinco por el precio de una

SUB con Bin=1: A + ~B + 1 (Tema 24). Cout en SUB = 1 significa “alcanzó” (sin préstamo); 0 = pidió prestado.

03 · N bits y 74181

Ripple + banderas

Z (cero)

F = 0000: igualdad, fin de conteo, string terminado. La más usada.

C (carry)

Acarreo/préstamo del MSB: aritmética sin signo y rotaciones.

N (signo)

Copia del MSB: con Ca2 dice si es negativo.

V (overflow)

Cin≠Cout del MSB: la suma con signo mintió (Tema 24).

04 · Para qué sirven

Los ojos del programa

El micro salta según flags: BEQ (Z=1), BCS (C=1), BMI (N=1). Sin ALU no hay comparación; sin flags no hay if. El curso 7 los usará; este tema los fabrica.

05 · ALU en código

Cinco ops, cuatro flags

ALU de 1 bit más versión 4 bits con banderas.

def alu1(op, a, b, cin=0):
    if op == "AND":
        f, c = a and b, 0
    elif op == "OR":
        f, c = a or b, 0
    elif op == "XOR":
        f, c = a ^ b, 0
    elif op == "ADD":
        f, c = a ^ b ^ cin, (a and b) or (a and cin) or (b and cin)
    else:
        nb = 1 - b
        f, c = a ^ nb ^ cin, (a and nb) or (a and cin) or (nb and cin)
    print(f"{op} {a},{b},{cin} -> F={int(f)} Cout={int(c)}")
    return int(f), int(c)


for op in ("AND", "OR", "XOR", "ADD", "SUB"):
    alu1(op, 1, 0, 1)

AND 1,0→0; OR→1; XOR→1; ADD 1+0+1→0 c1; SUB 1−0… con Bin=1: 1+1+1→1 c1. ¿Y SUB 0−1?

4 bits con flags

def alu4(op, a, b):
    bb = b if op != "SUB" else (~b) & 0xF
    cin, f, cs = (1 if op == "SUB" else 0), 0, []
    for i in range(4):
        ai, bi = (a >> i) & 1, (bb >> i) & 1
        if op in ("ADD", "SUB"):
            si, cout = ai ^ bi ^ cin, (ai and bi) or (ai and cin) or (bi and cin)
        else:
            si = {"AND": ai and bi, "OR": ai or bi, "XOR": ai ^ bi}[op]
            cout = 0
        f |= si << i
        cs.append(int(cout))
        cin = int(cout)
    z, n, v = (f == 0), (f >> 3) & 1, (cs[2] ^ cs[3])
    print(f"{op} {a:04b},{b:04b} -> {f:04b}={f} Z={int(z)} N={n} V={v} C={cin}")
    return f


alu4("ADD", 9, 6)
alu4("SUB", 6, 9)
alu4("AND", 9, 6)

06 · Analogía programador

CPU en miniatura

1. 1
   ALU = calculadora.

   Opera sin decidir el programa: el opcode elige, ella ejecuta.

2. 2
   Flags = return codes.

   Cero, carry, signo: como exit codes que el siguiente comando consulta.

3. 3
   74181 = librería.

   Operaciones listas y probadas: no reescribir lo que el MSI ya da.

07 · Exploración

Laboratorio: mini-181

ALU de 4 bits con 5 operaciones: mové A/B y mirá F más banderas.

Preguntas para explorar

1. Probá AND con 9 y 6. ¿F? ¿Por qué 0?
2. Probá SUB 6−9. ¿F? ¿Cout? ¿Qué significa?
3. Probá ADD 7+7. ¿F? ¿V? ¿Por qué?

08 · Comprensión

Confusiones frecuentes

09 · Práctica guiada

Ejercicios de operación

Ejercicio 1: tabla de 1 bit

Completá AND/OR/XOR/ADD/SUB para (1,0,1). Verificá cada fila con alu1().

Ejercicio 2: flags de 0

SUB 5−5. ¿F? ¿Z? ¿Cout? ¿Qué “dice” cada flag?

Ejercicio 3: XOR vs ADD

A=B=7: XOR da 0, ADD da 14. Explicá bit a bit por qué difieren.

10 · Síntesis

Ideas para recordar

Operaciones dominadas. Ahora lo que parpadea: en el próximo tema, hazards.