Regla del 75/25 (o 60/40): en cualquier programa compilado:

• 60–75 % = operaciones simples de carga y almacenamiento (load/store), comparaciones, incrementos de índices. Se resuelven en el pipeline secundario V en pocos ciclos.
• 25–40 % = cómputo pesado: cálculo numérico, trigonométricas (sen, cos), logaritmos, exponenciales, derivadas, integrales, sigmoides para IA, multiplicación de matrices. Requieren FPU y pueden consumir cientos/miles de ciclos.

Implicación arquitectónica: esta distribución fundamenta la separación de pipelines en el Pentium P5 y la filosofía RISC de mantener instrucciones simples rápidas para aprovechar los ciclos muertos.

• Pipeline U (principal): capaz de ejecutar cualquier instrucción, incluyendo cómputo pesado en FPU.
• Pipeline V (secundario): optimizado únicamente para instrucciones simples (load/store) en paralelo.
• Caché separada: aunque la RAM sea unificada (Von Neumann/CISC), internamente se separan caché de código (I-cache) y datos (D-cache) para evitar cuellos de botella en el bus.
• Transición arquitectónica: de la serie 286/386/486 (pipeline simple de 5 etapas) a superescalar con dos pipelines independientes.

Proceso de compilación modular en sistemas embebidos:

• Compilación directa: gcc programa.c -o ejecutable → binario final (o a.out sin `-o`).
• Compilación por paso de objeto (`-c`): gcc -c modulo1.c → genera `modulo1.o`. Permite compilación incremental mediante `make` o `CMake` (comparación de fechas de modificación: si `.c` no cambió, evita recompilar).
• Generación de ensamblador (`-S`): gcc -S programa.c → genera `programa.s` en código ASM humanamente legible. Propósito en sistemas embebidos: inspeccionar a nivel de registros, detectar cuellos de botella de CPU, realizar optimizaciones finas.
• El enlazador (`ld`): toma todos los archivos objeto (`.o`) y librerías para construir el ejecutable final.

En arquitecturas de 64 bits, la memoria se organiza en palabras de 8 bytes (no por bytes).

Ejemplo de struct con padding (desperdicio):

struct Datos {
    int a;    // 4 bytes nominales → 8 bytes (alineado a palabra)
    int b;    // 4 bytes nominales → 8 bytes
    double c; // 8 bytes nominales → 8 bytes
};
// Cálculo teórico: 4 + 4 + 8 = 16 bytes
// Realidad: 8 + 8 + 8 = 24 bytes (relleno/padding)

Solución — Empaquetado (`packed`): directiva del compilador para forzar almacenamiento contiguo sin bytes de relleno, optimizando transmisión en ráfaga por bus serie/red:

struct Datos {
    int a;
    int b;
    double c;
} __attribute__((packed));  // Ahora pesa exactamente 16 bytes

• MMX (1997): extensión SIMD de 64 bits (compartida físicamente con la FPU). Manipulable como 8 `char`, 4 `short`, 2 `int` o 1 `long`. Paralelismo a nivel de palabra.
• Memoria DDR (Double Data Rate): tecnología que duplica ancho de banda efectivo transfiriendo datos en flanco de subida Y de bajada de reloj, sin ensanchar el bus físico.
• SSE (Streaming SIMD Extensions): reemplaza MMX introduciendo 8 registros independientes de 128 bits (XMM), desvinculados de la FPU. 70 nuevas instrucciones vectoriales para paralelismo de datos más potente.

• PAE (Physical Address Extension): extiende bus de direcciones a 36 bits para direccionar hasta 64 GB de RAM, manteniendo registros internos y espacio lógico en 32 bits.
• Ejecución fuera de orden (Out-of-Order Execution): reordena dinámicamente instrucciones entrantes para ejecutar las que ya tienen datos listos en caché, aprovechando ciclos de reloj.
• Ejecución especulativa: ejecuta por adelantado ramas de código o instrucciones antes de saber si serán necesarias.
• Renombrado de registros (Register Renaming): mapeo dinámico de registros nominales (AX, BX) hacia banco de registros físicos libres más grande, permitiendo ejecutar múltiples hilos en paralelo sin conflictos de dependencia.

• Pentium II (1997): integra P6 con cache L2 externo, mantiene SSE inicial.
• Pentium III (1999): añade SSE (8 registros XMM de 128 bits), desvincula del FPU, 70 nuevas instrucciones vectoriales.
• Pentium 4 / NetBurst (2000): pipeline profundo de más de 20 etapas diseñado para alcanzar altas frecuencias (hasta 3.8 GHz), pero altamente ineficiente energéticamente por disipación de calor (400–500 W de consumo).

• Intel Itanium (IA-64): arquitectura mononúcleo de 64 bits no retrocompatible con x86 (IA-32). Requería recompilar completamente sistemas operativos y aplicaciones → fracaso comercial.
• AMD64 / Opteron (x86-64): arquitectura de 64 bits con retrocompatibilidad nativa total:
  • Modo Real (8086)
  • Modo Protegido (286/386)
  • Modo Largo (64 bits)
  Esto permitió migración suave de software heredado → éxito global de x86-64.

• IMC (Integrated Memory Controller): integración del controlador de memoria directamente en el die del procesador, eliminando dependencia del Northbridge externo.
• HyperTransport: conmutador crossbar de alta velocidad para interconectar múltiples núcleos e interprocesadores en sistemas servidores.
• Coherencia de caché: protocolo de sincronización entre cachés de múltiples procesadores en el mismo die o en sistemas de múltiples procesadores.

Problema: dado un conjunto de puntos en un plano, encontrar el contorno convexo que los delimita.

• Fuerza bruta: evaluar todas las combinaciones de puntos → O(N²) o peor.
• Optimización matemática: ordenar previamente los puntos → O(N log N) (Heapsort, Mergesort).
• Relación arquitectónica: el algoritmo de ordenamiento realiza casi en su totalidad (95 %) operaciones de comparación, carga y almacenamiento (intercambiar índices, mover variables en memoria). No satura la FPU → se resuelve en pipelines de instrucciones simples (U/V).

• (Contexto) Anécdota del Dr. Urrutia: demostración en tres pizarrones de la reducción de cierre convexo a N log N para artículo científico.
• (Contexto) Primera computadora del profesor (1995): Pentium 75 MHz, 8 MB RAM, disco 800 MB. Comparación con potencia de ESP32 actual.
• (Contexto) Fuentes de poder de los 90s: eficiencia del 60%, transformadores basados, requería 1.4 kW para alimentar Pentium 4 de 400 W.
• (Contexto) Cartas ASM: diseño de máquinas de estados a nivel de transistores (referencia al libro del Dr. Jesús Carmona).

• Profundización en arquitectura AMD Opteron: estructura interna de enlaces interprocesador (HyperTransport), matriz de conmutación crossbar, protocolo de coherencia de caché en Opteron.