Workstations · Simulación
Simulación CFD/FEA: ancho de banda, FP64, núcleos y licencias
Por qué un solver de CFD o FEA vive limitado por la memoria, qué CPU rinde de verdad (canales, no núcleos), cuándo la GPU sirve (FP64) y cómo las licencias por núcleo cambian la compra.
Un solver de fluidos o de estructuras no multiplica matrices densas: recorre una y otra vez una matriz dispersa enorme que no cabe en ninguna caché. Por cada byte que lee hace una fracción de operación. El resultado es una carga limitada por memoria en la que sobran núcleos y faltan canales de RAM, en la que la precisión doble (FP64) no es negociable y en la que el precio de la licencia, no el del hardware, decide cuántos núcleos merece la pena comprar. Este artículo cubre OpenFOAM, Ansys Fluent y Mechanical, Abaqus, COMSOL y LS-DYNA con esa lente.
Qué hace un solver con el hardware
CFD (volúmenes finitos) y FEA (elementos finitos) terminan en lo mismo: resolver sistemas lineales del tipo A·x = b, donde A es una matriz dispersa con decenas o cientos de millones de filas y solo unas pocas entradas no nulas por fila. Los métodos iterativos (gradiente conjugado, GMRES, multigrid) repiten miles de veces un producto matriz dispersa por vector, el SpMV. Los solvers directos de FEA (Mechanical, Abaqus/Standard) factorizan la matriz y sí tienen fases densas más intensivas, pero el ensamblaje y los frentes pequeños vuelven a ser tráfico de memoria.
El SpMV es el peor caso posible para una CPU moderna: cada entrada no nula se lee una vez, se usa en una sola multiplicación-suma y se desecha. No hay reutilización que la caché pueda aprovechar.
Intensidad aritmética del SpMV (formato CSR, FP64)
FLOP/byte = 2 FLOP por entrada ÷ (8 bytes de valor + 4 bytes de índice)
2 ÷ 12 ≈ 0,17 FLOP/byte
Cada entrada no nula cuesta una FMA (2 FLOP) y obliga a leer su valor en FP64 (8 bytes) y su índice de columna (4 bytes). Un Ryzen 9 9950X con AVX-512 completo hace 32 FLOP FP64 por ciclo y núcleo: 16 × 32 × 4,3 GHz ≈ 2,2TFLOPS de pico. Con 89,6GB/s de RAM, su punto de cruce roofline está en 2 200 ÷ 89,6 ≈ 25 FLOP/byte. El SpMV queda 150 veces por debajo: la CPU sostiene 89,6 × 0,17 ≈ 15GFLOPS, menos del 1 % de su pico. El resto del tiempo los núcleos esperan a la DRAM.
Esa cuenta fija el perfil de la carga: multi-hilo en el reparto (cada hilo toma un trozo del dominio), pero todos los hilos compiten por el mismo grifo de memoria. La GPU solo entra si el solver tiene versión nativa y su FP64 no está capado. Disco y red apenas importan salvo al escribir resultados o en clúster. Puedes comprobar tu caso en la herramienta roofline.
Canales de memoria: el número que manda
Si la carga consume 12 bytes por cada 2 FLOP, lo que escala el rendimiento es el ancho de banda de la RAM, y este sale de dos cifras de la ficha: canales y MT/s. Un Ryzen o Core Ultra de sobremesa tiene dos canales. Un Threadripper 9000 no PRO, cuatro. Un Threadripper PRO o un Xeon W-3500, ocho. Un EPYC Turin, doce.
Ancho de banda de la RAM
GB/s = canales × 8 bytes × MT/s ÷ 1 000
Threadripper PRO 9995WX: 8 × 8 × 6 400 ÷ 1 000 = 409,6 GB/s
El Ryzen 9 9950X con DDR5-5600 en dos canales mueve 2 × 8 × 5 600 ÷ 1 000 = 89,6GB/s. El Threadripper 9980X con cuatro canales DDR5-6400, 204,8GB/s. El PRO 9995WX con ocho, 409,6GB/s. Un EPYC 9575F con doce canales llega a 614GB/s por socket. Entre el sobremesa y el servidor hay un factor 6,9 en ancho de banda; en núcleos, solo 4.
Ancho de banda de RAM por plataforma
Lo que importa para dimensionar es el cociente entre las dos cifras: gigabytes por segundo por núcleo. Con menos de unos 4 GB/s por núcleo, añadir núcleos a un solver iterativo deja de acelerarlo; los hilos nuevos solo se reparten la misma espera.
| Equipo | Núcleos | Base (GHz) | Canales | MT/s | Ancho de banda (GB/s) | L3 (MB) | Lanes PCIe |
|---|---|---|---|---|---|---|---|
| AMD Ryzen 9 9950X | 16 | 4,3 | 2 | 5 600 | 89,6 | 64 | 24 |
| Intel Core Ultra 9 285K | 24 | 3,7 | 2 | 6 400 | 102 | 36 | 20 |
| AMD Ryzen Threadripper 9980X | 64 | 3,2 | 4 | 6 400 | 205 | 256 | 80 |
| AMD Ryzen Threadripper PRO 9995WX | 96 | 2,5 | 8 | 6 400 | 410 | 384 | 128 |
| Intel Xeon w9-3595X | 60 | 2 | 8 | 4 800 | 307 | 113 | 112 |
| AMD EPYC 9575F | 64 | 3,3 | 12 | 6 400 | 614 | 256 | 128 |
Núcleos, canales, ancho de banda y L3 de las CPU citadas (fuente: src/data/cpus.json).
Hay un segundo efecto que favorece a las plataformas grandes: la L3. El vector x del SpMV y los frentes de un solver directo caben mejor en 384 MB (9995WX, EPYC 9965) que en 64 MB (9950X). Los Ryzen X3D con 96–128 MB ayudan en mallas pequeñas, pero no compensan la falta de canales en mallas de decenas de millones de celdas: la matriz A no cabe en ninguna caché.
9950X → 9995WX: ×6 núcleos, ×4,6 ancho de banda, ×6 L3Y un tercero: la frecuencia sostenida. El 9995WX tiene 350 W para 96 núcleos, 2,5 GHz de base. En un solver memory-bound da igual; en las fases densas de un solver directo, cuenta. Por eso, en FEA implícita, un 9970X (32 núcleos, 4,0 GHz base) puede rendir por hilo mejor que un 9980X.
FP64: por qué la GPU gaming no sirve
Un solver implícito acumula sumas largas y resta cantidades casi iguales (residuos, gradientes de presión). En FP32, con 24 bits de mantisa, esos errores de redondeo crecen hasta que el sistema no converge o converge a algo falso. Por eso Mechanical, Abaqus/Standard, COMSOL y la mayor parte de Fluent trabajan en precisión doble. La excepción habitual es la dinámica explícita (LS-DYNA, Abaqus/Explicit, choques y conformado), que avanza en pasos muy pequeños sin resolver sistemas y a menudo se ejecuta en simple precisión.
En la CPU, FP64 va a la mitad del ritmo de FP32 y nadie se preocupa. En la GPU es otra historia. Las GeForce y las RTX PRO reservan el FP64 completo para el datacenter y lo capan a 1/64 del ritmo FP32: una RTX 5090 pasa de 104,8TFLOPS en FP32 a 1,64TFLOPS en FP64. Una H100 SXM, con FP32 de 67TFLOPS, ofrece 33,5TFLOPS FP64 vectorial y 66,9 en Tensor Core. La MI300X de AMD, 81,7TFLOPS vectorial y 163,4 en unidades matriciales, la mejor FP64 de su generación.
FP64 vectorial de pico
- GeForce
- RTX PRO
- Datacenter
Las GPU GeForce y RTX PRO ejecutan FP64 a 1/64 del ritmo FP32; los valores marcados como 1,97 y 1,64 son cálculos, no cifras publicadas.
La consecuencia es contraintuitiva: en FP64, una RTX 5090 de 575 W rinde en pico menos que el Ryzen 9 9950X de la propia máquina (2,2 TFLOPS con AVX-512). Lo que la GPU aporta es su ancho de banda de 1 792GB/s, veinte veces la RAM de un sobremesa, y ahí sí gana en SpMV puro, pero solo si la malla cabe en 32 GB de VRAM y el solver tiene camino nativo. Fluent lo tiene (solver nativo multi-GPU; Ansys cita un caso de Seagate de horas a minutos, unas 50 veces, en un DGX con GPU de datacenter). Mechanical y Abaqus usan la GPU solo para acelerar la factorización.
RAM: celdas, gigabytes y ECC
La malla define la RAM. La regla de trabajo del sector es de 2 a 8 GB por millón de celdas en CFD según el solver, el número de ecuaciones (turbulencia, especies, multifase) y si el solver es acoplado o segregado; en FEA con solver directo la cifra depende del ancho de banda de la matriz y puede ser mayor. Es una regla aproximada, no una cifra de ficha: mide tu propio caso con una malla pequeña y extrapola.
RAM orientativa para CFD
RAM (GB) ≈ celdas (millones) × factor (2 a 8 GB por millón)
50 millones de celdas × 2 GB = 100 GB → 128 GB mínimo; con solver acoplado (×4) → 256 GB
Una malla de 50 millones de celdas con un solver segregado y turbulencia sencilla ronda los 100 GB; el mismo caso acoplado, con más ecuaciones, puede pedir 200 GB o más. Suma un 20–30 % para el sistema operativo, el preproceso y la escritura de resultados. Un sobremesa AM5 se queda en 192 GB con cuatro módulos, y con cuatro módulos el 9950X baja oficialmente a DDR5-3600: ganas capacidad y pierdes ancho de banda. Las plataformas de ocho canales admiten 1–2 TB en RDIMM sin ese castigo.
La segunda razón para RDIMM es la ECC. Una simulación de 40 horas sobre 256 GB sufrirá, estadísticamente, algún bit volteado; sin ECC el error se propaga en silencio a un residuo que quizá converja a algo falso. Threadripper, Xeon W y EPYC activan ECC de sistema con RDIMM. Letra pequeña de DDR5: su ECC on-die corrige dentro del chip, no en el bus ni en el controlador, y no lo reporta al sistema. No es ECC de sistema.
Licencias: el coste que cambia la compra
En OpenFOAM los núcleos son gratis. En Ansys, Abaqus, COMSOL o LS-DYNA cada núcleo adicional se paga, y el precio anual de las licencias supera a menudo al de la máquina. Ansys incluye cuatro incrementos HPC en cada licencia de solver: cuatro núcleos de serie. A partir de ahí se compran HPC Packs, que escalan de forma geométrica: la tabla publicada históricamente por Ansys da unos 12 núcleos con un pack, 36 con dos, 132 con tres y 516 con cuatro (cifras orientativas, confírmalas con tu distribuidor). Los solvers GPU también consumen incrementos HPC.
| Packs | Núcleos aprox. | Lectura |
|---|---|---|
| 0 | 4 | Lo que trae cada solver de serie |
| 1 | 12 | Un sobremesa de 16 núcleos ya sobra |
| 2 | 36 | Threadripper 9970X (32) o PRO de 32 |
| 3 | 132 | Estación de 2 sockets o pequeño clúster |
Esto invierte la lógica de compra. Si tu presupuesto de licencias llega a un pack, un 9995WX de 96 núcleos dejará 84 sin usar. La máquina correcta es la que da el máximo ancho de banda y L3 a los 12–36 núcleos que sí puedes usar: un Threadripper 9970X con cuatro canales, o un PRO 9975WX de 32 núcleos con ocho canales, rinde más por euro de licencia que cualquier CPU de 64 o 96.
Escalado y Amdahl
Aunque la licencia y la memoria te lo permitan, el escalado tiene techo. Todo solver tiene una fracción secuencial: lectura de la malla, particionado, ensamblaje de condiciones de contorno, escritura de resultados, sincronizaciones entre iteraciones.
Ley de Amdahl
Aceleración(N) = 1 ÷ ((1 − p) + p ÷ N)
p = 0,95: 16 núcleos → 9,1×; 64 núcleos → 15,4×; 128 → 17,4×
Con un 95 % del tiempo paralelizable, 16 núcleos rinden como 9,1 y 64 como 15,4: pasar de 16 a 64 cuadruplica el hardware para ganar 1,7 veces. Con p = 0,99 (mallas grandes, MPI bien afinado) 64 núcleos dan 39×. Con p = 0,90 (mallas pequeñas, muchas escrituras) el techo absoluto es 10× por muchos núcleos que añadas. La fracción secuencial crece cuando la malla es pequeña: por debajo de unas 50 000–100 000 celdas por núcleo el coste de comunicación entre particiones se come la ganancia.
Aceleración frente a núcleos
- p = 0,99
- p = 0,95
- p = 0,90
En una carga memory-bound Amdahl no es el único freno: el ancho de banda de los canales se satura antes de que todos los núcleos estén activos. En una plataforma de dos canales, la curva real se aplana entre 6 y 10 núcleos; en una de ocho, entre 32 y 48. Por eso los benchmarks oficiales de Fluent y OpenFOAM se publican por nodo y no por núcleo, y por eso un clúster de varias máquinas modestas con sus propios canales suele escalar mejor que una sola máquina enorme.
2 canales: saturación ~8 núcleos · 8 canales: ~32–48 núcleosTres configuraciones orientativas
Contenida (OpenFOAM, mallas hasta ~10 millones de celdas, sin licencias por núcleo). Ryzen 9 9950X o Core Ultra 9 285K, 96–192 GB DDR5 en dos canales, sin GPU de cálculo. Prioriza dos módulos rápidos (1DPC) antes que cuatro lentos. El techo está en 89,6–102,4 GB/s; el 285K con CUDIMM DDR5-6400 lleva ventaja.
Equilibrada (Fluent/Mechanical con 1–2 HPC Packs, mallas de 20–80 millones). Threadripper 9970X (32 núcleos, 4 canales, 204,8 GB/s, 80 lanes PCIe 5.0) o un PRO de 32 núcleos en WRX90 con 8 canales, 256–512 GB RDIMM ECC: alimenta bien justo los núcleos que la licencia permite. GPU solo con solver nativo; una RTX PRO 6000 de 96 GB tiene sentido por VRAM en Fluent GPU, no por FP64.
Sin límites (varias licencias, mallas de cientos de millones o solver GPU en FP64). Threadripper PRO 9995WX o Xeon w9-3595X con 8 canales y 1 TB, o un nodo EPYC 9575F de dos sockets con 24 canales; para GPU, H100/H200 o MI300X en servidor, con FP64 completo y HBM a 3,35–5,3 TB/s. A partir de aquí la pregunta es cuántos nodos y qué red los une: ver interconexión.
Lo que debes recordar
- CFD y FEA son SpMV: unos 0,17 FLOP por byte en FP64. La CPU sostiene menos del 1 % de su pico; lo que manda es el ancho de banda de la RAM.
- Ancho de banda = canales × 8 × MT/s ÷ 1 000. Dos canales: 90–100 GB/s. Cuatro: 205. Ocho: 307–410. Doce: 614. Mira GB/s por núcleo, no núcleos.
- FP64 en GeForce y RTX PRO va a 1/64 del FP32: una RTX 5090 rinde 1,64 TFLOPS, menos que el Ryzen de la máquina. Para solver GPU en doble precisión, H100/B200/MI300X.
- RAM: 2–8 GB por millón de celdas (aproximado) y ECC de sistema con RDIMM. El ECC on-die de DDR5 no cuenta.
- Las licencias por núcleo (4 de serie, HPC Packs geométricos) deciden cuántos núcleos usarás; compra ancho de banda y L3 para esos núcleos, no núcleos de más.
Para mirar en una ficha técnica
- Canales de memoria y MT/s soportados: multiplica y compara en GB/s. Trampa: «hasta DDR5-6400» solo con dos módulos; con cuatro, el sobremesa baja a 3 600.
- FP64 (TFLOPS): si no aparece en la ficha de la GPU, es 1/32 o 1/64 del FP32. Trampa: «AI TOPS» es FP4 sparse, cuatro formatos por debajo de lo que necesita un solver.
- Tipo de módulo (UDIMM / RDIMM ECC): RDIMM implica plataforma de estación o servidor y ECC de sistema. Trampa: «DDR5 con ECC» en un sobremesa suele ser ECC on-die.
- L3 (MB) y núcleos por CCD: más L3 por núcleo y menos núcleos por canal escalan mejor en memory-bound. Trampa: 64 núcleos con 4 canales.
- Lanes PCIe: 80–128 lanes en Threadripper/Xeon W/EPYC para varias GPU a ×16 más NVMe; 24 en sobremesa.
Fuentes
- Ansys — High-Performance Computing (HPC) licensing — «4 free, built-in HPC increments per solver license» y modelo de HPC Packs combinables; la tabla de núcleos por pack es orientativa y no se ha reconfirmado en esta página.
- Ansys Fluent — página de producto — solver GPU nativo multi-GPU; caso Seagate (reducción de horas a minutos, ~50×, con NVIDIA DGX).
- NVIDIA RTX Blackwell GPU Architecture whitepaper — FP64 a 1/64 del FP32 en GeForce RTX 50; 104,8 TFLOPS FP32 de la RTX 5090.
- NVIDIA H100 Tensor Core GPU — 34 TFLOPS FP64 vectorial, 67 en Tensor Core, 80 GB HBM3 a 3,35 TB/s.
- NVIDIA HGX B200 — 296 TFLOPS FP64 por 8 GPU → 37 por GPU.
- AMD Instinct MI300X — 81,7 TFLOPS FP64 vectorial, 163,4 matricial, 192 GB HBM3 a 5,3 TB/s.
- AMD Ryzen Threadripper PRO 9995WX — 96 núcleos, 8 canales DDR5-6400 RDIMM ECC, 128 lanes PCIe 5.0, 350 W.
- AMD Ryzen Threadripper 9980X — 64 núcleos, 4 canales DDR5-6400, 350 W.
- AMD EPYC 9575F — 64 núcleos, 12 canales DDR5-6400 (614 GB/s), 256 MB de L3.
- Intel Xeon w9-3595X — especificaciones — 60 núcleos, 8 canales DDR5-4800, 112 lanes PCIe 5.0.
- AMD Ryzen 9 9950X — 16 núcleos, DDR5-5600 en dos canales (3 600 con cuatro módulos), AVX-512 de 512 bits.