Procesadores paralelos y multinúcleo

Los sistemas informáticos paralelos realizan operaciones al mismo tiempo. Pueden reducir la latencia, el tiempo que tarda una tarea, o aumentar la productividad, el número de tareas terminadas por segundo. Estos objetivos dan lugar a distintas formas de dividir el trabajo.

El muro de potencia

Aumentar la frecuencia de reloj hacía antes que cada generación de procesadores fuera más rápida. La potencia dinámica sigue aproximadamente $P\approx C{V}^{2}f$: capacitancia por tensión al cuadrado por frecuencia de conmutación. La tensión aparece dos veces en ese producto. Reducir tanto la tensión como la frecuencia un 15 % da ${\mathrm{0,85}}^2\times \mathrm{0,85}=\mathrm{0,614125}$ de la potencia dinámica original, aproximadamente un 61 %.

La tensión no podía seguir bajando lo suficiente para compensar unas frecuencias de reloj más altas. Las fugas y el calor hicieron que seguir aumentando la frecuencia resultara demasiado costoso. Este muro de potencia impulsó a la industria hacia los chips multinúcleo a mediados de la década de 2000. Un chip multinúcleo coloca varios núcleos de procesador en un solo chip; un sistema multiprocesador tiene al menos dos procesadores. Los núcleos más modestos pueden realizar más trabajo total por julio, siempre que haya suficiente trabajo que repartir.

Cuatro formas de encontrar trabajo paralelo

El hardware y los compiladores detectan principalmente el ILP. La segmentación, la emisión múltiple y la ejecución fuera de orden solapan instrucciones y conservan los resultados requeridos por el programa. Las dependencias y los saltos limitan el solapamiento disponible.

El DLP aparece cuando muchos elementos necesitan el mismo cálculo. Las instrucciones SIMD, los procesadores vectoriales y las GPU aprovechan esta regularidad. El TLP requiere que el código, una biblioteca o un compilador dividan el trabajo en hilos. Un hilo tiene su propio contador de programa, registros y pila; los hilos de un proceso comparten su espacio de direcciones. Los procesos separados tienen espacios de direcciones separados.

El trabajo a nivel de solicitudes necesita poca cooperación entre tareas. Por tanto, añadir servidores puede aumentar la capacidad casi en proporción a los recursos añadidos. Ejecutar varios programas independientes en una computadora portátil también aprovecha núcleos que de otro modo estarían inactivos y aumenta la productividad global incluso cuando ninguno de esos programas está paralelizado internamente.

Tareas concurrentes y ejecución simultánea

Concurrencia significa que las tareas avanzan durante periodos que se solapan. Un núcleo puede hacerlo alternando entre ellas. Paralelismo significa que las operaciones se ejecutan en el mismo instante en hardware separado. Un sistema de un solo núcleo puede mantener varios programas en curso sin ejecutar sus instrucciones simultáneamente.

Un programa con un solo hilo secuencial no se divide entre ocho núcleos por el mero hecho de que existan. Los núcleos adicionales pueden ejecutar otro trabajo, pero acortar este programa requiere que tenga trabajo paralelo. Incluso después de dividir el trabajo, cualquier parte secuencial restante sigue limitando la ganancia.

Un procesador puede contener muchas unidades aritméticas sin seguir muchos flujos de instrucciones independientes. La taxonomía de Flynn clasifica el hardware según sus flujos de instrucciones y de datos, por lo que el primer paso es elegir el nivel de la máquina que se describe.

Las cuatro clases de hardware

Un procesador convencional de un solo núcleo es SISD incluso cuando su cauce de segmentación solapa varias instrucciones. La emisión superescalar no crea por sí sola contadores de programa independientes ni convierte el núcleo en hardware MIMD.

Una instrucción SIMD podría sumar ocho pares de números de coma flotante de 32 bits en un registro de 256 bits. Tiene ocho carriles aritméticos, pero estos siguen una sola instrucción. Las extensiones SIMD de anchura fija incluyen x86 SSE y AVX y Arm Neon; las arquitecturas vectoriales también encajan en la clase SIMD. Los cálculos regulares sobre arreglos son adecuados porque muchos elementos necesitan la misma operación.

Los procesadores MIMD eligen sus instrucciones de forma independiente. Los chips multinúcleo, los multiprocesadores de memoria compartida y los clústeres encajan en esta clase. Los núcleos pueden ejecutar distintos programas o copias del mismo programa que alcanzan distintas ramas en momentos diferentes.

MISD completa la clasificación de dos por dos. Tiene pocos ejemplos prácticos claros. Algunos sistemas tolerantes a fallos y cauces de procesamiento se describen de esta manera, pero su clasificación depende de cómo se definan sus flujos.

Un programa aún puede tener muchos flujos de instrucciones

SPMD, un programa y múltiples datos, es un estilo de programación. Cada trabajador ejecuta una copia del mismo programa y usa su identificador para seleccionar la parte de los datos que le corresponde. Los trabajadores tienen estados de ejecución independientes, por lo que SPMD suele ejecutarse en hardware MIMD.

Para cuatro núcleos que suman 4000 valores, el núcleo con identificador $i$ procesa los índices desde $1000i$ hasta $1000i+999$. El núcleo 0 procesa 0–999; el núcleo 3 procesa 3000–3999. Cada uno produce una suma parcial y esas cuatro sumas se combinan. El texto compartido del programa no requiere que los cuatro núcleos emitan la misma instrucción en el mismo ciclo.

Clasifica cada nivel por separado

Considera una CPU de ocho núcleos cuyos hilos usan instrucciones AVX. Entre núcleos es MIMD: los núcleos avanzan de forma independiente. Dentro de una operación AVX es SIMD: una instrucción controla varios carriles. Contar juntas todas las unidades aritméticas ocultaría esta estructura.

Un clúster que ejecuta copias de un mismo programa científico también es hardware MIMD que usa software SPMD. Sus nodos se comunican mediante mensajes. Una GPU combina muchos grupos de hilos planificados de forma independiente con ejecución de tipo SIMD dentro de cada grupo; NVIDIA llama SIMT a su estilo de ejecución basado en hilos.

Para clasificar una descripción, pregunta quién elige la siguiente instrucción. Después pregunta si esa instrucción procesa un elemento de datos o varios. El número de archivos fuente, programas instalados o unidades aritméticas por sí solo no puede responder a esas dos preguntas.

Un fallo de caché puede dejar un núcleo esperando cientos de ciclos. El multihilo por hardware mantiene los estados de ejecución de varios hilos dentro de un núcleo para que puedan ejecutarse instrucciones útiles de otro hilo durante esa espera.

Qué se duplica y qué se comparte

Cada hilo de hardware tiene su propio contador de programa y estado de registros. Los hilos comparten las unidades de ejecución del núcleo, las cachés y el acceso al ancho de banda de memoria. Mantener el estado en el hardware hace que el cambio sea mucho más rápido que guardar y restaurar un proceso del sistema operativo, lo que puede costar miles de ciclos. El hardware puede cambiar en un ciclo o menos.

El sistema operativo ve cada hilo de hardware como un procesador lógico. Ocho núcleos físicos con dos hilos de hardware por núcleo presentan 16 procesadores lógicos. Esa cifra describe los contextos de hilo disponibles, no 16 núcleos físicos completos.

Tres enfoques de planificación

La planificación de grano fino puede alternar entre hilos preparados incluso cuando el hilo anterior podría continuar. La planificación de grano grueso sigue ejecutando ese hilo hasta que una parada costosa justifica el cambio. SMT usa un núcleo de emisión múltiple con planificación dinámica: las instrucciones de distintos hilos pueden ocupar diferentes posiciones de emisión libres durante un ciclo. El renombrado de registros mantiene separados sus estados. Hyper-Threading de Intel es una implementación de SMT; algunos procesadores IBM POWER admiten ocho hilos de hardware por núcleo.

Resuelve un ejemplo de ocultación de latencia

Supón que un hilo calcula durante 20 ciclos y luego espera 200 ciclos a la memoria. Su ciclo dura 220 ciclos. Por sí solo, el trabajo útil ocupa $20\mathrm{/}220\approx \mathrm{0,091}$, es decir, el 9,1 % del tiempo.

Con cuatro hilos, trabajo escalonado libremente y sin coste de cambio ni contención adicional, el trabajo útil puede ocupar $4\times 20\mathrm{/}220\approx \mathrm{0,364}$, es decir, el 36,4 %. El núcleo sigue teniendo intervalos inactivos porque cuatro ráfagas de 20 ciclos no pueden cubrir los periodos de espera.

Once hilos proporcionan en total 220 ciclos de ráfagas de cálculo. Mientras uno espera durante 200 ciclos, los otros diez pueden calcular 20 cada uno. Esta planificación ideal mantiene ocupado el núcleo. El rendimiento real también depende de si esos hilos compiten por los recursos de memoria y ejecución.

Productividad y tiempo de finalización de un hilo

El multihilo aumenta principalmente la productividad. Un hilo concreto puede tardar más porque otros hilos usan ciclos y espacio de caché que de otro modo recibiría. Dos hilos de hardware que comparten una unidad aritmética no pueden obtener ambos la capacidad de un segundo núcleo completo.

Si ambos hilos ya requieren las mismas unidades de ejecución totalmente ocupadas, SMT tiene poca capacidad libre que aprovechar. Si uno se detiene mientras el otro puede ejecutarse, compartir resulta útil. Las GPU aplican la ocultación de latencia a mayor escala manteniendo muchos grupos de hilos preparados para sus planificadores.

Una máquina paralela es útil cuando cambia el tiempo transcurrido. El factor de aceleración compara la mejor ejecución secuencial con la ejecución paralela; la eficiencia compara esa ganancia con el número de procesadores usados.

Empieza por el tiempo medido

Para $p$ procesadores, $S(p)=T_1\mathrm{/}{T}_p$ y $E(p)=S(p)\mathrm{/}p$. Una tarea secuencial de 100 s que termina en 16 s con ocho núcleos tiene un factor de aceleración de $100\mathrm{/}16=\mathrm{6,25}$. Su eficiencia es $\mathrm{6,25}\mathrm{/}8=\mathrm{0,78125}$, aproximadamente el 78 %. Mide el tiempo transcurrido de reloj en ambas ejecuciones, usando la misma tarea de tamaño fijo.

Divide el tiempo en partes mejoradas y sin cambios

En la ley de Amdahl, $f$ es la fracción del tiempo de ejecución original que acelera una mejora. Es una fracción de tiempo, no una fracción de líneas de código fuente. Si esa parte se vuelve $s$ veces más rápida, entonces

La parte sin cambios sigue tardando todo su tiempo original. Para una división paralela ideal entre $p$ procesadores, establece $s=p$. Este modelo excluye los sobrecostes de comunicación, desequilibrio y sincronización; esos costes pueden hacer que el tiempo medido sea mayor.

Con un 90 % de tiempo paralelizable y diez procesadores, el tiempo normalizado es $\mathrm{0,1}+\mathrm{0,9}\mathrm{/}10=\mathrm{0,19}$. El factor de aceleración es $1\mathrm{/}\mathrm{0,19}\approx \mathrm{5,26}$ y la eficiencia es de aproximadamente el 53 %. Con 100 procesadores, el tiempo es $\mathrm{0,1}+\mathrm{0,009}=\mathrm{0,109}$ y el factor de aceleración es aproximadamente 9,17. Multiplicar por diez el número de procesadores no ha duplicado el factor de aceleración.

Encuentra el límite antes de comprar más procesadores

A medida que crece el número de procesadores, el tiempo paralelo se aproxima a cero. La fracción secuencial permanece y establece el techo $S_{max}=1\mathrm{/}(1-f)$. Una fracción secuencial del 10 % limita el factor de aceleración ideal a 10; una del 5 % lo limita a 20. Un número finito de procesadores se aproxima a estos techos sin alcanzarlos.

La ley de Amdahl también evalúa una clase de instrucciones más rápida. Si la multiplicación ocupa el 30 % de una ejecución y se vuelve cuatro veces más rápida, el tiempo normalizado pasa a ser $\mathrm{0,7}+\mathrm{0,3}\mathrm{/}4=\mathrm{0,775}$. El programa completo es solo $1\mathrm{/}\mathrm{0,775}\approx \mathrm{1,29}$ veces más rápido.

Trabaja hacia atrás desde un objetivo

Para obtener un factor de aceleración de 90 con 100 procesadores, escribe $1\mathrm{/}90=(1-f)+f\mathrm{/}100=1-\mathrm{0,99}f$. Por tanto, $f=(1-1\mathrm{/}90)\mathrm{/}\mathrm{0,99}\approx \mathrm{0,99888}$. Solo aproximadamente el 0,11 % del tiempo original puede permanecer secuencial. Un objetivo cercano al número de procesadores exige una fracción sin cambios muy pequeña.

Un factor de aceleración medido puede superar a veces el número de procesadores. Dividir un conjunto de trabajo grande puede hacer que cada parte quepa en la caché, lo que reduce el coste por operación. Esta aceleración superlineal cambia una premisa del modelo sencillo: el trabajo paralelo ya no es simplemente el trabajo original dividido en partes iguales. Comprueba el algoritmo, el tamaño de los datos y el comportamiento de la caché antes de interpretar una medición así.

Añadir procesadores puede acortar la misma tarea o permitir que una máquina gestione una tarea mayor. La escalabilidad fuerte y la escalabilidad débil miden estos usos distintos, y ambas dependen de cuánto trabajo útil queda después de los costes de coordinación.

Trabajo fijo y trabajo creciente

La escalabilidad fuerte mantiene fijo el tamaño del problema. La escalabilidad débil aumenta el trabajo en proporción al número de procesadores y mantiene constante el trabajo por procesador. Una escalabilidad débil perfecta mantiene constante el tiempo transcurrido mientras crece el trabajo total.

Considera diez sumas secuenciales seguidas de una suma elemento a elemento de dos matrices. Una matriz de 10 por 10 necesita 100 sumas paralelas. El tiempo total es de 110 unidades con un procesador, 20 con diez y 12 con cincuenta: factores de aceleración de 5,5 y aproximadamente 9,2. Una matriz de 40 por 40 necesita 1600 sumas paralelas. Los tiempos pasan a ser 1610, 170 y 42 unidades: factores de aceleración de aproximadamente 9,5 y 38,3. El problema mayor da más peso al trabajo paralelo útil con respecto a las mismas diez sumas secuenciales.

El punto de referencia diferente de Gustafson

La ley de Gustafson usa la fracción de tiempo secuencial medida en la ejecución paralela. Si llamamos $s$ a esa fracción, el factor de aceleración escalado es $S_G=s+(1-s)p$. Para $s=\mathrm{0,05}$ y 100 procesadores, $S_G=\mathrm{0,05}+\mathrm{0,95}(100)=\mathrm{95,05}$.

La ley de Amdahl con un 5 % de tiempo secuencial en la ejecución original con un procesador da solo aproximadamente 16,8 con 100 procesadores. Estas fracciones usan distintos denominadores y responden a preguntas diferentes. Un factor de aceleración escalado de 95,05 no significa que la tarea original de tamaño fijo terminara 95,05 veces antes.

El trabajador más lento determina el tiempo de finalización

Si 400 unidades de trabajo iguales se reparten entre ocho núcleos, la parte equilibrada es de 50 para cada uno. Supón que uno recibe 120 y los otros siete reciben 40 cada uno. La etapa dura 120 unidades de tiempo, por lo que el factor de aceleración es $400\mathrm{/}120\approx \mathrm{3,33}$. Dividir por la carga media no tendría en cuenta la espera al núcleo más ocupado.

La creación y planificación de hilos, los mensajes, las barreras y la contención por el ancho de banda compartido también consumen tiempo. La granularidad es la cantidad de cálculo entre eventos de comunicación o sincronización. Las partes más grandes reducen el coste de coordinación por operación útil, pero un número demasiado pequeño de partes puede dejar inactivos a algunos trabajadores.

Más procesadores pueden aumentar el tiempo

Para una tarea totalmente paralela de 100 s con un sobrecoste de $\mathrm{0,5}p$ segundos, $T_p=100\mathrm{/}p+\mathrm{0,5}p$. Diez procesadores tardan 15 s. Catorce tardan aproximadamente 14,14 s, cerca del mínimo en torno a $\sqrt{200}$ procesadores. Cuarenta tardan 22,5 s porque sus 20 s de sobrecoste superan el ahorro del cálculo útil más corto.

Al presentar un resultado, indica si el trabajo permaneció fijo o aumentó y compáralo con el tiempo del mejor programa secuencial. Usar como referencia una implementación paralela lenta ejecutada en un procesador puede inflar el factor de aceleración comunicado.

La tasa aritmética anunciada de un procesador es solo uno de los límites. El modelo de techo de rendimiento también pregunta si la memoria puede proporcionar datos con suficiente rapidez para sostener esa tasa. Ofrece un límite superior que ayuda a identificar una dirección útil para la optimización.

Cuenta las operaciones por byte de DRAM

La intensidad aritmética es el número de operaciones de coma flotante dividido por los bytes transferidos entre la DRAM y el procesador. El trabajo original sobre el modelo de techo de rendimiento llama intensidad operacional a esta medida basada en la DRAM. Cuenta el tráfico en ese límite, incluidas las lecturas y escrituras.

DAXPY calcula $y_i=a{x}_i+y_i$ con números de doble precisión. Cada elemento necesita una multiplicación y una suma: dos FLOP. Leer un valor de 8 bytes de cada arreglo y escribir 8 bytes de vuelta transfiere 24 bytes. La intensidad es $I=2\mathrm{/}24\approx \mathrm{0,0833}$ FLOP por byte. El coeficiente escalar se reutiliza; en este modelo de tráfico no se carga de nuevo desde la DRAM para cada elemento.

Aplica ambos límites

Si la capacidad máxima de cálculo es $P$ y el ancho de banda máximo de memoria es $B$, el techo es $\min (P,BI)$. El ancho de banda multiplicado por los FLOP por byte tiene unidades de FLOP por segundo. En un gráfico con escala logarítmica en ambos ejes, el límite de ancho de banda asciende y el límite de cálculo es horizontal.

Para 1000 GFLOP/s y 100 GB/s, el punto de cresta es $P\mathrm{/}B=1000\mathrm{/}100=10$ FLOP por byte. Por debajo de esta intensidad, el techo de ancho de banda es menor; por encima, lo es el techo de cálculo. DAXPY está limitado a $100(2\mathrm{/}24)\approx \mathrm{8,33}$ GFLOP/s, menos del 1 % del máximo de cálculo de la máquina. Un núcleo de cálculo con intensidad 2 está limitado a 200 GFLOP/s.

Un núcleo de cálculo limitado por la memoria aún puede beneficiarse de más núcleos o de SIMD más ancho mientras tenga muy pocas solicitudes en curso para usar el ancho de banda disponible. Una vez saturado ese ancho de banda, la capacidad aritmética adicional no eleva su techo. Sí lo hacen aumentar el ancho de banda o realizar más cálculo útil por byte transferido.

La reutilización cambia la intensidad

Multiplicar dos matrices de doble precisión de 1000 por 1000 realiza aproximadamente $2(1000{)}^3=2\times {10}^9$ FLOP. Si cada elemento de las dos entradas y de la salida cruza una vez el límite de la DRAM, el tráfico total es de 24 MB, lo que da aproximadamente 83 FLOP por byte. Esto está por encima de la cresta de la máquina del ejemplo.

Una implementación ingenua puede volver a leer repetidamente valores de las matrices desde la DRAM. El procesamiento por bloques organiza los bucles en torno a submatrices que caben en la caché, de modo que los valores sirven para muchas operaciones antes de ser reemplazados. El algoritmo sigue siendo una multiplicación de matrices, pero la implementación transfiere menos bytes de DRAM por operación.

Un techo no es un resultado medido

Un núcleo de cálculo puede funcionar por debajo del límite debido a dependencias, sobrecoste de instrucciones, patrones de acceso deficientes o trabajo paralelo insuficiente. Los techos de rendimiento inferiores muestran esas restricciones: la falta de SIMD puede reducir el techo de cálculo, mientras que los patrones de acceso deficientes reducen el ancho de banda utilizable. Un punto por debajo de un techo requiere investigación; el techo por sí solo no predice su tasa de ejecución exacta.

Una extensión SIMD divide un registro ancho en carriles. Una instrucción realiza la misma operación en cada carril, por lo que los bucles regulares sobre elementos independientes son adecuados para ella.

Cuenta carriles e iteraciones

El número de carriles es la anchura del registro dividida por la anchura del elemento. Un registro de 256 bits contiene ocho números de coma flotante de 32 bits, cuatro de doble precisión de 64 bits o 32 elementos de un byte. SSE usa registros XMM de 128 bits; AVX y AVX2 usan registros YMM de 256 bits. En modo de 64 bits hay 16 registros YMM. AVX-512 proporciona 32 registros ZMM de 512 bits, cada uno con capacidad para 16 números de coma flotante. Arm Neon usa registros de 128 bits.

Para c[i] = a[i] + b[i] sobre 1000 números de coma flotante, las instrucciones de ocho carriles procesan el arreglo en 125 iteraciones vectoriales. Cada iteración carga dos vectores, suma sus carriles y almacena un vector. Con 1003 elementos, 125 iteraciones completas dejan tres elementos. Un bucle escalar para el resto o una operación con máscara procesa esa parte final corta sin acceder fuera de los arreglos.

Ocho carriles representan una capacidad aritmética, no una garantía de aceleración del programa por un factor de ocho. La preparación, el tratamiento del resto, el trabajo secuencial y el ancho de banda de memoria siguen consumiendo tiempo.

Elige una disposición que llene un registro

Las cargas vectoriales sencillas funcionan bien con elementos contiguos, con paso de una unidad. Un arreglo de puntos {x, y, z} con valores de 4 bytes sitúa los campos x consecutivos a 12 bytes de distancia. Una estructura de arreglos coloca juntos los valores de x, después los de y y después los de z. Ahora, al procesar solo x, se puede llenar un vector con una carga contigua. Las instrucciones de recopilación y dispersión admiten direcciones dispersas, pero normalmente con un mayor coste de acceso.

Mantén el trabajo condicional dentro de los carriles

Para c[i] = (a[i] > 0) ? a[i] : 0, una comparación crea una máscara por carril. Una mezcla elige entre los resultados candidatos, o las instrucciones con máscara actualizan solo los carriles seleccionados. Los carriles inactivos conservan o reciben valores según el comportamiento de máscara de la instrucción.

Si distintos carriles necesitan ramas largas y diferentes, las instrucciones de esos caminos siguen teniendo que emitirse, con solo los carriles pertinentes activos. El grupo no puede dar a cada carril un flujo de instrucciones separado. Una máscara preserva la corrección, pero no puede hacer desaparecer todas esas instrucciones de los caminos.

Comprueba la independencia de las iteraciones

Los compiladores pueden vectorizar bucles automáticamente; los programadores también pueden usar bibliotecas o funciones intrínsecas como _mm256_add_ps. El compilador debe determinar que las iteraciones simultáneas preservan el resultado. La recurrencia a[i] = a[i-1] + b[i] depende del nuevo valor de la iteración anterior y no puede vectorizarse directamente como elementos independientes. El posible solapamiento de punteros, llamado aliasing, también puede requerir una comprobación de solapamiento en tiempo de ejecución o impedir la vectorización.

Una reducción mantiene varias sumas parciales en un registro y después combina los carriles. Reordenar las sumas de coma flotante puede cambiar los últimos bits porque la suma no es asociativa. Las sumas de enteros coinciden cuando la aritmética elegida no tiene desbordamiento o usa aritmética modular definida.

SIMD y la ejecución multinúcleo pueden combinarse. Ocho núcleos que emiten cada uno una suma de ocho carriles por ciclo pueden realizar hasta 64 sumas de coma flotante por ciclo. Siguen compartiendo límites como el ancho de banda de memoria.

Una arquitectura vectorial expresa una operación sobre una secuencia de elementos y almacena la longitud activa del vector en un registro. El mismo programa puede ejecutarse en implementaciones con distintas capacidades de registro vectorial.

Separa capacidad, longitud y carriles

La versión 1.0 de la extensión vectorial de RISC-V, RVV, se ratificó en 2021. Proporciona 32 registros vectoriales, de v0 a v31. Cada implementación elige la anchura de sus registros, VLEN, como una potencia de dos. La anchura del elemento y la agrupación de registros determinan cuántos elementos caben.

La longitud activa, vl, es el número de elementos que procesan las siguientes instrucciones vectoriales. vsetvli configura la operación vectorial a partir del número de elementos restantes y del formato de elemento deseado, y devuelve la vl seleccionada. El código avanza según ese valor devuelto. Esto importa porque el código portable debe usar la longitud real elegida por la implementación.

Los carriles son los cauces de segmentación paralelos que ejecutan la operación vectorial. Una suma de 32 elementos en cuatro carriles tarda unos ocho ciclos después del inicio del cauce. Un vector de 32 elementos no requiere 32 unidades aritméticas. Los vectores más largos y un mayor número de carriles son decisiones de diseño separadas.

Divide un bucle en tramos

La partición de bucles en tramos divide un bucle largo en partes del tamaño de un vector. Para 100 elementos y un máximo de 32 por operación, una secuencia válida de longitudes es 32, 32, 32 y 4. Cada pasada carga la siguiente parte, la calcula, la almacena y reduce el número restante en su vl.

DAXPY sobre 1000 números de doble precisión puede usar de manera similar 31 pasadas de 32 seguidas de una pasada de ocho, para un total de 32 pasadas. RVV puede elegir otras longitudes válidas cerca del final, por lo que el bucle usa la vl devuelta en lugar de suponer una división final concreta. Establecer la longitud activa permite procesar la parte final corta sin un bucle escalar separado para el resto.

El patrón de control del bucle es:

1. Solicita una longitud para los elementos restantes.
2. Carga y calcula esa cantidad de elementos.
3. Almacena los resultados.
4. Avanza los punteros y resta la longitud devuelta.

Una instrucción vectorial describe muchas operaciones sobre elementos, lo que reduce el trabajo de búsqueda y decodificación frente a un cuerpo escalar repetido para cada elemento.

Alimenta operaciones dependientes y datos no contiguos

El encadenamiento permite que una operación vectorial consumidora empiece con los primeros resultados antes de que la operación productora haya terminado los elementos posteriores. Para una multiplicación seguida de una suma, el primer producto puede entrar en el cauce de suma mientras los productos posteriores aún se están formando.

Una máscara, habitualmente en el registro v0 de RVV, selecciona qué elementos se actualizan. Una carga con paso constante accede a elementos separados por una distancia fija en bytes. En una matriz de doble precisión de 100 por 100 almacenada por filas, bajar una columna avanza 100 elementos, u 800 bytes. Las cargas y almacenamientos indexados usan direcciones explícitas para datos irregulares.

Tanto las arquitecturas vectoriales como las extensiones de anchura fija son SIMD en la taxonomía de Flynn. Las extensiones de anchura fija codifican anchuras concretas; el código RVV expresa longitudes que se adaptan al hardware disponible. Ambas siguen necesitando un orden de ejecución que respete las dependencias de datos del bucle.

Una CPU concentra recursos en una baja latencia para unos pocos hilos. Una GPU concentra recursos en una alta productividad entre muchos hilos con paralelismo de datos. Elegir entre ellas requiere examinar toda la tarea, incluido el movimiento de datos.

Los hilos se ejecutan en multiprocesadores de flujos

Una GPU de NVIDIA contiene muchos multiprocesadores de flujos, o SM. Un SM tiene carriles aritméticos, planificadores de grupos de hilos, un banco de registros grande y memoria compartida rápida en el chip. Un «núcleo CUDA» designa un carril aritmético, no un núcleo completo e independiente como el de una CPU. AMD llama unidad de cómputo al grupo de procesamiento correspondiente.

NVIDIA agrupa los hilos en grupos de hilos de 32. Una instrucción emitida opera sobre los hilos activos del grupo, cada uno con sus propios valores de registro y datos. Esto es SIMT, una instrucción y múltiples hilos. AMD usa frentes de onda, con 32 o 64 hilos según la arquitectura.

Un SM mantiene residentes muchos grupos de hilos. Cuando uno espera a la memoria, el planificador selecciona otro que esté preparado. Tener más hilos preparados que carriles oculta la latencia; no reduce la latencia de un acceso individual a la DRAM.

La divergencia deja carriles inactivos

Si los hilos de un grupo toman ramas diferentes, el grupo ejecuta los caminos necesarios con los demás hilos desactivados mediante máscaras. Un if-else dividido por igual, con ramas de igual coste, puede tardar aproximadamente el doble del tiempo de un camino porque ambos deben ejecutarse. Un salto puede no tener coste por divergencia cuando su condición es uniforme dentro de cada grupo, aunque distintos grupos elijan caminos diferentes.

Haz que los accesos a memoria trabajen juntos

Los registros de cada hilo contienen valores privados. La memoria compartida por bloque es almacenamiento en el chip gestionado por el programa. Las cachés L1 y L2 permiten la reutilización automática, mientras que la memoria global es la DRAM de la GPU, como GDDR o HBM.

Cuando 32 hilos leen palabras consecutivas de 4 bytes, su intervalo de 128 bytes puede atenderse con un pequeño número de transacciones anchas. Esta coalescencia de accesos a memoria usa el ancho de banda de forma eficiente. Las direcciones dispersas pueden requerir muchas transacciones para los mismos datos útiles. La reutilización en memoria compartida puede reducir aún más el tráfico repetido de memoria global.

Incluye el tiempo de transferencia

En una GPU discreta, las entradas y los resultados atraviesan un enlace como PCIe o NVLink. Enviar 800 MB y recibir 400 MB a una velocidad efectiva de 20 GB/s transfiere 1,2 GB en 0,06 s, es decir, 60 ms. Añadir un núcleo de cálculo de 10 ms da 70 ms en total. Una CPU que termina en 50 ms gana esta comparación pese al cálculo mucho más rápido de la GPU.

Mantener los datos en la GPU durante varios núcleos de cálculo evita transferencias repetidas. Las tareas grandes y regulares también pueden proporcionar suficiente trabajo aritmético útil para compensar los costes de movimiento y lanzamiento. Las tareas pequeñas, secuenciales y con muchos saltos suelen favorecer a una CPU.

Especializa aún más cuando el trabajo lo permita

Un sistema heterogéneo usa la CPU para ejecutar el programa y el sistema operativo y un acelerador para las partes adecuadas. Los aceleradores de dominio específico, como las TPU y las NPU, dedican hardware a una tarea más concreta, a menudo la multiplicación de matrices con enteros de 8 bits o coma flotante de 16 bits. La especialización puede mejorar el rendimiento por vatio en ese dominio, al tiempo que reduce la variedad de trabajos que el hardware maneja bien.

Un núcleo de cálculo de GPU se ejecuta una vez por cada hilo lanzado. El sistema anfitrión lanza una malla de bloques de hilos y cada hilo calcula qué parte de los datos le corresponde. CUDA llama sistema anfitrión a la CPU y dispositivo a la GPU; OpenCL usa los términos relacionados elemento de trabajo y grupo de trabajo.

Calcula un índice único

Para un lanzamiento unidimensional, el índice del elemento es blockIdx.x * blockDim.x + threadIdx.x. Con 256 hilos por bloque, el hilo 5 del bloque 2 procesa el elemento 517: los dos bloques anteriores cubren 512 elementos y el hilo añade un desplazamiento de cinco. Los índices de hilos y bloques empiezan en cero.

Un núcleo de cálculo SAXPY aplica una multiplicación y una suma a cada número de coma flotante:

__global__ void saxpy(int n, float a, float *x, float *y) {
    int i = blockIdx.x * blockDim.x + threadIdx.x;
    if (i < n) {
        y[i] = a * x[i] + y[i];
    }
}

La malla sustituye al bucle habitual sobre los elementos. Cada hilo activo actualiza su propio y[i]; los hilos vecinos usan direcciones vecinas, lo que facilita la coalescencia.

Redondea hacia arriba el número de bloques

Para 1 000 000 de elementos y 256 hilos por bloque, la malla necesita $\lceil 1000000\mathrm{/}256\rceil =3907$ bloques. Estos lanzan 1 000 192 hilos. Los últimos 192 tienen índices fuera del arreglo, por lo que la condición i < n impide sus accesos a memoria. Redondear hacia abajo lanzaría muy pocos hilos y dejaría elementos válidos sin procesar.

Un bloque de 256 hilos forma ocho grupos de hilos. Los bloques pueden asignarse a cualquier SM y ejecutarse en cualquier orden. La corrección del programa no debe depender de que el bloque 0 termine antes que el bloque 1.

Organiza el trabajo del sistema anfitrión y del dispositivo

Un sistema anfitrión típico reserva almacenamiento en el dispositivo, copia las entradas, lanza saxpy<<<3907, 256>>>(n, 2.0f, d_x, d_y) y obtiene los resultados. El lanzamiento es asíncrono: la CPU puede continuar mientras se ejecuta el núcleo de cálculo. El sistema anfitrión debe esperar mediante sincronización o una copia bloqueante adecuada de los resultados antes de usar los datos terminados.

Coopera dentro de un bloque

Los hilos de un bloque pueden intercambiar valores mediante memoria compartida y reunirse en __syncthreads(). Todos los hilos que participan en esa barrera de bloque deben alcanzarla. Colocar la barrera dentro de if (i < n) no es seguro cuando solo algunos hilos cumplen la condición.

Para una reducción de 1024 valores en memoria compartida, 512 hilos suman pares, luego 256 combinan los resultados, después 128, y así sucesivamente. Diez etapas de reducción a la mitad dejan una suma. Una barrera entre etapas impide que un hilo consuma un resultado parcial antes de que su productor lo escriba.

Un lanzamiento normal no tiene una barrera para toda la malla. Los bloques separados pueden escribir sumas parciales y un segundo núcleo de cálculo puede combinarlas, o bien operaciones atómicas adecuadas pueden actualizar un resultado global. Una barrera de bloque por sí sola no puede coordinar distintos bloques. Un bucle con paso de malla es otro patrón de asignación: cada hilo procesa varios elementos y avanza según el tamaño total de la malla.

Un multiprocesador de memoria compartida proporciona a sus procesadores un espacio de direcciones físico. Los hilos se comunican con cargas y almacenamientos sobre variables compartidas, al tiempo que mantienen valores privados como las sumas parciales locales.

Las direcciones compartidas pueden tener costes diferentes

En UMA, acceso uniforme a memoria, el tiempo de acceso a memoria es aproximadamente el mismo desde cada procesador. En NUMA, acceso no uniforme a memoria, un zócalo accede a su memoria local más rápido que a la memoria de otro zócalo. El espacio de direcciones es compartido aunque la memoria física esté distribuida.

Con un 70 % de accesos locales a 80 ns y un 30 % de accesos remotos a 140 ns, la media ponderada es $\mathrm{0,7}(80)+\mathrm{0,3}(140)=98$ ns. Mover los datos cerca de su usuario principal reduce la proporción de accesos remotos. Contar todos los accesos como locales subestimaría el tiempo.

Una disposición habitual de caché proporciona a cada núcleo cachés L1 privadas de instrucciones y datos, a menudo una L2 privada y una caché de último nivel compartida. Un anillo o una malla conecta los núcleos y las cachés. La memoria compartida describe el direccionamiento; no requiere que todos los núcleos usen una misma caché común.

Divide, calcula y reduce

Para sumar 64 000 valores en 64 núcleos, cada núcleo procesa 1000 valores. Las 64 sumas parciales pueden combinarse en un árbol de reducción. El número de sumadores activos se reduce a la mitad en cada etapa: 32, 16, 8, 4, 2 y 1. Seis etapas combinan los resultados parciales.

Usar aproximadamente 1000 pasos de suma local más seis pasos de combinación da unos 1006 pasos en el camino más largo, antes del sobrecoste. El árbol evita que cada entrada actualice un contador compartido. Cada etapa depende de los valores completados de la etapa anterior, por lo que los trabajadores se reúnen en barreras entre etapas.

OpenMP puede expresar esto con #pragma omp parallel for reduction(+:sum). Divide las iteraciones, da a los hilos sumas parciales privadas y las combina. Los hilos POSIX ofrecen un control más explícito sobre la gestión de hilos.

Haz que una actualización sea indivisible

Una operación de lectura, modificación y escritura atómicas hace que una actualización sea indivisible desde el punto de vista de los demás procesadores. El intercambio atómico y la lectura y suma atómicas son ejemplos. Una carga seguida de un almacenamiento normal son dos operaciones separadas, por lo que otro hilo puede intervenir.

RISC-V proporciona lr.w y sc.w. La carga con reserva lee una palabra y establece una reserva. El almacenamiento condicional intenta la escritura e informa de si tuvo éxito o falló. Una escritura intermedia en la posición reservada hace que el intento falle; el software vuelve a intentarlo. La reserva no bloquea a otros procesadores y el fallo también puede ocurrir por otras razones permitidas. Estas primitivas permiten construir mecanismos de sincronización.

Vigila los cuellos de botella compartidos

Si cada núcleo puede procesar un flujo de 15 GB/s pero el zócalo proporciona 60 GB/s, unos cuatro flujos de este tipo saturan el ancho de banda. Más núcleos no pueden aumentar la tasa de datos del zócalo. La comunicación mediante cachés también requiere trabajo: quien escribe sin permiso de escritura debe obtener la propiedad e invalidar las demás copias. Quien ya tiene un bloque en estado modificado puede seguir escribiendo localmente; los lectores posteriores pueden necesitar buscar una copia nueva.

Las cachés privadas mejoran la latencia, pero pueden contener varias copias de una misma posición de memoria. La coherencia de caché evita que esas copias presenten historiales contradictorios de las escrituras en esa posición.

Por qué actualizar la memoria no basta

Empieza con X = 0 en memoria. El núcleo A lee y guarda cero en caché; el núcleo B hace lo mismo. A escribe uno en su caché de escritura diferida. Sin un protocolo de coherencia, B puede acertar en su propia caché y seguir leyendo cero. Escribir directamente en memoria no corregiría la copia que B ya tiene en caché.

La coherencia funciona con granularidad de bloque de caché, normalmente de 64 bytes. Un controlador registra el estado de cada bloque y sigue las reglas del protocolo cuando los procesadores lo leen o escriben. La migración mueve datos útiles a la caché de su usuario actual. La replicación permite que varios lectores tengan copias limpias. La coherencia debe preservar ambos beneficios mientras controla las escrituras.

Tres propiedades requeridas

Si una posición recibe una escritura de uno seguida de una escritura de dos, los lectores no pueden discrepar sobre cuál ocurrió después. Observar la escritura posterior y luego la anterior invertiría ese historial. Por supuesto, una nueva escritura posterior podría almacenar de nuevo el valor uno; la serialización se refiere a eventos de escritura, no a si un valor numérico puede volver a aparecer.

Controla la propiedad y las copias

En un protocolo de invalidación en escritura, quien escribe obtiene permiso exclusivo de escritura e invalida las demás copias en caché. Una lectura posterior de un bloque invalidado falla y busca los datos actuales. Este es un fallo de coherencia, además de los fallos obligatorios, de capacidad y de conflicto.

Un protocolo de actualización en escritura envía los valores nuevos a las copias existentes. Las escrituras repetidas pueden hacer que esto resulte costoso. El espionaje de bus difunde solicitudes de coherencia para que las cachés puedan reaccionar. Un directorio registra qué cachés comparten el bloque y dirige los mensajes a las pertinentes.

Coherencia, orden y atomicidad

La coherencia se refiere a una posición. Un modelo de consistencia de memoria define las ordenaciones y los resultados observables permitidos de lecturas y escrituras, incluidas las operaciones sobre posiciones diferentes. La consistencia secuencial exige un resultado que coincida con una intercalación que conserve el orden de programa de cada procesador. Los modelos relajados permiten más reordenaciones; las instrucciones de barrera de memoria imponen el orden requerido cuando es necesario.

Ni las copias coherentes ni un orden consistente hacen atómico un incremento de varias instrucciones. Supón que dos hilos incrementan un contador compartido inicialmente igual a cinco. Una secuencia posible es: A lee cinco, B lee cinco, A escribe seis, B escribe seis. Cada lectura y escritura puede ser coherente y, aun así, el contador final es seis en lugar de siete. El programa necesita una actualización atómica o una sincronización adecuada para conservar ambos incrementos.

Un controlador de caché con espionaje observa las solicitudes de coherencia en una interconexión de difusión. Para seguir un protocolo, mantén un estado para la copia de un bloque de cada núcleo y actualiza todas las copias afectadas después de cada acceso.

Interpreta los estados como permisos

En MSI básico, un fallo de lectura envía una lectura por el bus y carga el bloque en S. Escribir un bloque en S requiere una promoción para invalidar las demás copias. Escribir desde I necesita una solicitud de lectura exclusiva para buscar los datos y obtener la propiedad. Quien escribe termina en M. Un acierto en M no requiere ninguna transacción de coherencia.

Sigue cinco accesos

Empieza con X = 0 en memoria y tanto A como B en estado inválido.

1. A lee X. Una lectura por el bus proporciona cero. Estados: A = S, B = I.
2. B lee X. Otra lectura por el bus proporciona cero. Estados: A = S, B = S.
3. A escribe uno. Su promoción invalida B. Estados: A = M, B = I.
4. B lee X. B falla; A proporciona uno y pasa a S. En MSI básico, la memoria también se actualiza. Estados: A = S, B = S.
5. B escribe dos. Su promoción invalida A. Estados: A = I, B = M.

Cada acceso de esta traza requiere una transacción de bus. El cuarto acceso es la comprobación de propiedad importante: la memoria por sí sola aún tenía el valor antiguo antes de que A proporcionara sus datos modificados.

Qué ahorra el estado exclusivo

MESI añade E para una única copia limpia en caché. Si A lee un bloque que no está en caché y ninguna otra caché lo tiene, A recibe E. Una escritura posterior cambia E a M silenciosamente, porque no hay otras copias que invalidar. MSI cargaría primero S y después enviaría una promoción para esa escritura.

Si otro núcleo lee mientras A tiene E, ambos pasan a S. Tanto M como E tienen un solo propietario válido, pero solo M contiene datos más recientes que la memoria.

Escrituras repetidas y escala

Quien escribe y ha obtenido M puede actualizar el bloque diez veces sin diez invalidaciones nuevas. Un sistema de actualización en escritura enviaría los valores modificados a quienes comparten el bloque.

El espionaje por difusión se vuelve costoso a medida que más núcleos observan cada solicitud. Las estructuras de directorio reducen esa distribución. Protocolos más elaborados añaden estados útiles: el estado propietario de MOESI permite una copia modificada compartida, y MESIF designa a un participante con estado de reenvío para responder a las solicitudes.

Difundir cada solicitud de coherencia resulta costoso en máquinas grandes. Un directorio registra qué cachés podrían tener cada bloque para que las solicitudes puedan dirigirse a ellas. Ese mismo seguimiento por bloques también explica un problema de rendimiento habitual: la falsa compartición.

Consulta el nodo de origen de un bloque

Cada bloque tiene una entrada de directorio en su nodo de origen que registra si no está en caché, está compartido o está modificado, y qué cachés lo tienen. Los nodos de origen se distribuyen entre nodos o partes del directorio, repartiendo el almacenamiento y la gestión de solicitudes.

Un fallo de lectura se dirige al nodo de origen. Si la memoria tiene los datos actuales, puede proporcionarlos y el directorio registra la nueva caché que comparte el bloque. Si otra caché posee una copia en estado modificado, el nodo de origen le reenvía la solicitud para que pueda proporcionar los datos actuales. En un protocolo de directorio básico, esto también vuelve a actualizar la memoria.

Para escribir sin tener ya la propiedad en estado modificado, un núcleo pide permiso al nodo de origen. El directorio envía invalidaciones a las cachés registradas, espera las confirmaciones y concede la propiedad exclusiva. Los aciertos de escritura repetidos en M ya no necesitan más mensajes de coherencia. La intermediación del directorio añade latencia, pero el tráfico punto a punto evita consultar a todas las cachés sobre cada bloque. Los filtros de espionaje en el chip cumplen una función relacionada al limitar las solicitudes a los posibles poseedores.

Estima el almacenamiento del directorio

Un vector de presencia completo tiene un bit por núcleo y por bloque. Para 64 núcleos, son 64 bits, u ocho bytes. Con respecto a un bloque de datos de 64 bytes, solo los bits de presencia cuestan $8\mathrm{/}64=\mathrm{0,125}$, es decir, un 12,5 %. Con 256 núcleos, el vector de 32 bytes cuesta un 50 %. Los bits de estado añaden más. Las listas limitadas de participantes, los vectores más generales y el seguimiento de solo los bloques almacenados en caché reducen esta carga de almacenamiento.

Reconoce la falsa compartición

La compartición verdadera ocurre cuando los núcleos intercambian datos mediante la misma palabra. La falsa compartición ocurre cuando acceden a distintas variables dentro de un bloque de caché y al menos uno escribe. Las variables son independientes en el programa, pero la unidad de coherencia es mayor que cualquiera de ellas.

Dos hilos incrementan contadores separados de 8 bytes en 0x1000 y 0x1008. Con bloques de 64 bytes, sus números de bloque son $\lfloor 4096\mathrm{/}64\rfloor =64$ y $\lfloor 4104\mathrm{/}64\rfloor =64$. Cada cambio de propiedad transfiere el permiso para ambos contadores a la vez. Las escrituras alternas frecuentes pueden hacer que el bloque vaya de una caché a otra aunque ningún hilo necesite el valor del otro.

Mover el segundo contador a 0x1040 lo sitúa en el bloque 65. El relleno o la alineación pueden separar los datos de cada hilo; agrupar los valores según quien los escribe también ayuda. Un acumulador local que se escribe una sola vez reduce el tráfico de propiedad sin añadir relleno a cada valor.

Quien escribe y quien lee una variable vecina también pueden sufrir falsa compartición: la escritura invalida el bloque del lector, que de otro modo sería útil. Dos lectores por sí solos no la causan. La falsa compartición añade tráfico y demora; por sí misma no hace que las actualizaciones de variables separadas produzcan valores incorrectos. Mide los patrones de acceso y la ubicación de las líneas de caché antes de cambiar una disposición de datos.

Un clúster conecta sistemas informáticos completos, cada uno con su propia memoria y sistema operativo. Los nodos cooperan mediante mensajes explícitos. Por ello, la ubicación de los datos y el coste de comunicación pasan a formar parte del modelo de rendimiento del programa.

Reparte los datos y combina los resultados

MPI, la interfaz de paso de mensajes, asigna a cada proceso un rango y proporciona operaciones como envío, recepción, difusión y reducción. Un programa SPMD puede usar los rangos para seleccionar los datos de cada proceso. Un puntero en el espacio de direcciones privado de un nodo no es una referencia normal de memoria compartida a los datos de otro nodo.

Si un millón de valores ya están distribuidos entre 100 nodos, cada nodo suma 10 000 localmente. Una reducción en árbol combina las sumas parciales en siete rondas porque $\lceil {\log }_{2}100\rceil =7$. Esas rondas implican mensajes de red, no solo sumas locales. Mantener los datos cerca del trabajo que los usa reduce las transferencias.

Los clústeres escalan con componentes estándar y el hardware averiado puede sustituirse. Una aplicación aún puede necesitar recuperarse o reiniciarse después de que falle un nodo; el mero hecho de poder sustituir nodos no conserva el progreso de una tarea interrumpida.

Mide más que la velocidad del enlace

La latencia es el tiempo que tarda en llegar un mensaje. El ancho de banda del enlace es la tasa de datos de un enlace. El ancho de banda total de la red suma la capacidad de los enlaces y describe un agregado ideal con todos los enlaces ocupados. El ancho de banda de bisección suma la capacidad que cruza el corte de menor capacidad que divide los nodos en mitades iguales.

Para enlaces de igual capacidad con ancho de banda $B$, compara redes de 64 nodos usando una misma convención de recuento de enlaces:

La malla tiene ocho filas de siete enlaces horizontales y ocho columnas de siete enlaces verticales, lo que da 112. Conectar los bordes en ambas dimensiones produce los 128 de la red toroidal. Cada nodo del hipercubo tiene seis vecinos, lo que da $64(6)\mathrm{/}2=192$ enlaces porque cada enlace se cuenta en sus dos extremos.

Sigue el corte y después considera el coste

Un corte que divide un anillo en dos mitades atraviesa solo dos enlaces. Por tanto, muchos mensajes pueden competir en ese límite pese a los 64 enlaces totales del anillo. Una red completamente conectada tiene $32(32)=1024$ enlaces entre sus dos mitades, pero necesita $64(63)\mathrm{/}2=2016$ enlaces en total.

Más enlaces pueden mejorar el ancho de banda y reducir los saltos, al tiempo que aumentan los puertos de conmutador, los cables y la potencia. Los buses compartidos tienen un único recurso de comunicación compartido; las mallas y las redes toroidales distribuyen los enlaces por el espacio. Los grandes clústeres suelen usar redes conmutadas de varias etapas, como los árboles gruesos. Su utilidad depende del patrón de tráfico y de su capacidad agregada. Para la comunicación entre las mitades de una máquina, la bisección revela un límite que el total oculta.

Un sistema informático a escala de centro de datos combina decenas de miles de servidores con alimentación, refrigeración y una red para prestar servicios de internet. Las solicitudes independientes proporcionan trabajo paralelo, mientras que los entornos de procesamiento por lotes como MapReduce dividen grandes tareas de procesamiento de datos entre máquinas.

Adapta el diseño al servicio

Los sistemas a escala de centro de datos dan prioridad al coste por solicitud, la eficiencia energética y la disponibilidad. El software vuelve a intentar el trabajo, replica datos y dirige las solicitudes por rutas que evitan las máquinas averiadas. Un supercomputador suele dar más prioridad a un programa científico fuertemente acoplado y a una interconexión rápida.

Los servidores se conectan a conmutadores situados en la parte superior de los bastidores, que se conectan a través de niveles superiores de conmutación. Los niveles adicionales añaden latencia de comunicación. Los enlaces ascendentes suelen estar sobresuscritos, lo que significa que su capacidad es menor que la capacidad agregada de los enlaces de los servidores. Algunas redes no bloqueantes de estilo Clos proporcionan suficiente capacidad superior para evitar esta restricción.

Cuarenta servidores con enlaces de 10 Gbit/s ofrecen 400 Gbit/s a un conmutador de bastidor. Cuatro enlaces ascendentes de 25 Gbit/s proporcionan 100 Gbit/s, por lo que la proporción es 4:1. Si todos los servidores envían datos fuera del bastidor a la vez y comparten la capacidad por igual, cada uno alcanza una media de 2,5 Gbit/s. Un servidor con poca carga puede usar más cuando los demás están inactivos.

Separa el sobrecoste de la instalación del cálculo útil

La eficacia en el uso de la energía, PUE, es la energía total de la instalación dividida por la energía de los equipos informáticos durante el mismo periodo. Una carga informática constante de diez MW más 1,5 MW de sobrecoste de refrigeración y distribución da $PUE=\mathrm{11,5}\mathrm{/}10=\mathrm{1,15}$. El valor ideal es 1,0. Google informó de una PUE anual de 1,09 para el conjunto de sus centros en 2025.

La PUE mide el sobrecoste de la instalación, no los cálculos útiles por julio. Los servidores inactivos o ineficientes pueden desperdiciar energía dentro de los equipos informáticos incluso cuando la instalación tiene una PUE excelente.

Para 50 000 servidores con una media de 300 W, la potencia informática es de 15 MW. Con una PUE de 1,2, la potencia de la instalación es de 18 MW. Mantenida durante 8760 horas, consume 157 680 MWh; solo el sobrecoste consume 26 280 MWh. Los equipos de alimentación, la refrigeración, la electricidad, los servidores y los edificios contribuyen al coste de propiedad.

Una carga baja aún puede consumir mucha potencia

La proporcionalidad energética significa que la potencia debería aumentar en proporción a la carga. Un servidor con 150 W de potencia en reposo y 300 W de potencia máxima, cuyo consumo aumenta linealmente, consume $150+\mathrm{0,3}(150)=195$ W al 30 % de carga. Usa el 65 % de la potencia máxima para el 30 % del trabajo máximo. Mediciones históricas a escala de centro de datos encontraron muchos servidores que funcionaban con una utilización de entre aproximadamente el 10 % y el 50 %, lo que hace importante la potencia en reposo.

Planifica para fallos y respuestas lentas

Si cada uno de 50 000 servidores registra de media un fallo cada diez años, se esperan 5000 fallos al año en el conjunto, unos 14 al día. Esa expectativa justifica la redundancia y los reintentos; no implica exactamente 14 fallos cada día.

Una solicitud que necesita respuestas de muchos servidores espera la respuesta requerida más lenta. Si cada uno de 100 servidores tiene de forma independiente una probabilidad del 1 % de ser lento, la probabilidad de que ninguno lo sea es ${\mathrm{0,99}}^{100}$. Por tanto, la probabilidad de que al menos uno sea lento es $1-{\mathrm{0,99}}^{100}\approx \mathrm{0,634}$. La latencia de cola de la distribución de un servidor se convierte en una demora habitual de la solicitud cuando esta se distribuye entre muchos servidores.