FluidX3D
v2.19 (camera splines)
El software CFD de Boltzmann de celosía más rápido y con mayor eficiencia de memoria, que se ejecuta en todas las GPU a través de OpenCL. Gratis para uso no comercial.
(haga clic en las imágenes para mostrar videos en YouTube)
Cambios v1.0 (08.04.2022) (lanzamiento público)
lanzamiento público
v1.1 (29.09.2022) cambios (voxelización de GPU)
voxelización sólida agregada en GPU (algoritmo lento)
herramienta agregada para imprimir la posición actual de la cámara (tecla G )
corrección de errores menores (solución alternativa para el error del controlador Intel iGPU con representación triangular)
Cambios v1.2 (24.10.2022) (cálculo de fuerza/par)
funciones agregadas para calcular fuerza/torque en objetos
función agregada para traducir Mesh
Se agregó la configuración de validación de arrastre de Stokes.
Cambios en la v1.3 (11.10.2022) (correcciones de errores menores)
Se agregaron funciones de conversión de unidades para torque.
FORCE_FIELD y VOLUME_FORCE ahora se pueden usar de forma independiente
corrección de errores menores (solución alternativa para el error del controlador heredado de AMD con literales de números binarios)
Cambios v1.4 (14.12.2022) (gráficos Linux)
Reescritura completa de la biblioteca de gráficos C++ para minimizar las dependencias de API.
añadido modo de gráficos interactivos en Linux con X11
Se corrigió el error de visualización optimizada en 2D.
Cambios v2.0 (01.09.2023) (actualización de múltiples GPU)
Se agregó soporte para múltiples GPU (entre proveedores) en un solo nodo (PC/portátil/servidor).
v2.1 (15.01.2023) cambios (voxelización rápida)
hizo una voxelización sólida en GPU a la velocidad del rayo (nuevo algoritmo, de minutos a milisegundos)
v2.2 (20.01.2023) cambios (voxelización de velocidad)
Opción agregada para voxelizar la geometría en movimiento/rotación en la GPU, con inicialización automática de la velocidad para cada punto de la cuadrícula según el centro de rotación, la velocidad lineal y la velocidad de rotación.
las células que se convierten de sólido->fluido durante la revoxelización ahora tienen sus DDF correctamente inicializados
Opción agregada para no escalar automáticamente la malla durante read_stl(...) , con parámetro size negativo.
núcleo agregado para renderizado de límites sólidos con cubos de marcha
v2.3 (30.01.2023) cambios (partículas)
partículas agregadas con método de límite sumergido (ya sea pasivo o acoplado en 2 vías, solo compatible con GPU única)
optimización menor del algoritmo de voxelización de GPU (los subprocesos del grupo de trabajo fuera del cuadro delimitador de malla regresan después de que se han encontrado las intersecciones de la malla de rayos)
El tamaño de asignación de memoria de GPU mostrado ahora es completamente preciso
error corregido en la función write_line() en src/utilities.hpp
Se eliminó la extensión de archivo .exe para Linux/macOS.
Cambios v2.4 (03.11.2023) (mejoras en la interfaz de usuario)
Se agregó un menú de ayuda con la tecla H que muestra los controles del teclado/ratón, configuraciones de visualización y estadísticas de simulación.
mejoras en el control del teclado/ratón ( + / - para hacer zoom, el clic del mouse libera/bloquea el cursor)
Se agregó la sugerencia de la resolución de cuadrícula más grande posible si la resolución se establece mayor de lo que permite la memoria.
optimizaciones menores en la comunicación multi-GPU (diferencia de rendimiento insignificante)
error corregido en la función de equilibrio de temperatura para la extensión de temperatura
Se corrigió el doble literal erróneo para las iGPU Intel en las funciones de color del skybox.
Se corrigió un error en make.sh donde los ID de dispositivos con múltiples GPU no se reenviaban al ejecutable.
correcciones de errores menores en el motor gráfico (cursor libre no centrado durante la rotación, etiquetas en modo VR)
error corregido en la inicialización estándar del parámetro de tamaño LBM::voxelize_stl()
Cambios v2.5 (04.11.2023) (revisión del trazado de rayos)
absorción de luz implementada en fluido para gráficos de trazado de rayos (sin impacto en el rendimiento)
velocidad de fotogramas de trazado de rayos mejorada cuando la cámara está dentro del líquido
artefactos parpadeantes en el poste del palco fijo
Se corrigió el error por el cual los objetos en movimiento durante la re-voxelización dejaban un rastro erróneo de celdas de cuadrícula sólidas detrás.
Cambios v2.6 (16.04.2023) (parche Intel Arc)
Se corrigieron problemas de OpenCL de las GPU Intel Arc: ahora son posibles asignaciones de VRAM >4 GB y se informa la capacidad de VRAM correcta
Cambios v2.7 (29.05.2023) (actualización de visualización)
visualización de corte agregada (modos de tecla 2 /tecla 3 , luego cambie entre los modos de corte con la tecla T , mueva el corte con las teclas Q / E )
Núcleos de visualización de estructura alámbrica / superficie sólida de bandera hechos conmutables con la tecla 1
visualización de presión superficial agregada (tecla 1 cuando FORCE_FIELD está habilitado y se llama lbm.calculate_force_on_boundaries(); )
se agregó la función de exportación binaria .vtk para mallas con lbm.write_mesh_to_vtk(Mesh* mesh);
se agregó time_step_multiplicator para la función integrate_particles() en la extensión PARTICLES
hizo que la corrección de informes de memoria incorrectos en Intel Arc fuera más sólida
error corregido en las funciones de plantilla write_file()
se revirtió a cl::Context separado para cada dispositivo OpenCL, ya que, de lo contrario, el contexto compartido asignaría VRAM adicional en todas las demás GPU Nvidia no utilizadas.
se eliminaron las configuraciones de depuración y x86 del archivo de solución de Visual Studio (una complicación menos para la compilación)
Se corrigió el error que causaba que las partículas pudieran acercarse demasiado a las paredes y quedarse atascadas, o abandonar la fase fluida (fuerza límite agregada).
v2.8 (24.06.2023) cambios (documentación + pulido)
finalmente agregué más documentación
Se limpiaron todas las configuraciones de muestra en setup.cpp para que sean más amigables para los principiantes y se agregaron las extensiones requeridas en defines.hpp como comentarios a todas las configuraciones.
carga mejorada de geometrías .stl compuestas, al agregar una opción para omitir el reposicionamiento automático de la malla, se agregó más funcionalidad a la estructura Mesh en utilities.hpp
Se agregó la función de uint3 resolution(float3 box_aspect_ratio, uint memory) para calcular la resolución de la caja de simulación en función de la relación de aspecto de la caja y la ocupación de VRAM en MB.
Se agregó la función bool lbm.graphics.next_frame(...) para exportar imágenes para una duración de video específica en el bucle de cálculo main_setup
Se agregaron macros VIS_... para facilitar la configuración de modos de visualización en modo de gráficos sin cabeza en lbm.graphics.visualization_modes
Las dimensiones de la caja de simulación ahora se hacen automáticamente divisibles por igual por dominios para simulaciones de múltiples GPU.
Se corrigió el formato de los mensajes de información/advertencia/error para cargar archivos y se colorearon las etiquetas de los mensajes de información/advertencia/error.
Se agregó la configuración del cuerpo de Ahmed como ejemplo de cómo se calculan las fuerzas del cuerpo y el coeficiente de resistencia.
Se agregaron configuraciones de Cessna 172 y Bell 222 para mostrar la carga de geometrías .stl compuestas y la revoxelización de piezas móviles.
Se agregó el modo de renderizado semitransparente opcional ( #define GRAPHICS_TRANSPARENCY 0.7f en defines.hpp ).
Se corrigió el parpadeo de la visualización optimizada en gráficos interactivos.
posicionamiento suave mejorado de las líneas de corriente en el modo de corte
Se corrigió el error por el cual mass y massex en la extensión SURFACE también se asignaban en la RAM de la CPU (no es necesario)
error corregido en la representación de criterios Q de datos de halo en modo multi-GPU, ancho de espacio reducido entre dominios
Se eliminó la optimización de la memoria compartida del kernel de voxelización en malla, ya que falla en las GPU Nvidia con nuevos controladores de GPU y es incompatible con las GPU OpenCL 1.0 antiguas.
Color de atenuación del trazado de rayos fijo cuando no hay ninguna superficie en las paredes de la caja de simulación con límites periódicos.
v2.9 (31.07.2023) cambios (multithreading)
Se agregó implementación multiplataforma parallel_for en utilities.hpp usando std::threads
Inicio de simulación significativamente (>4x) más rápido con inicialización de geometría multiproceso y controles de cordura
Funciones calculate_force_on_object() y calculate_torque_on_object() más rápidas con subprocesos múltiples
se agregó tiempo de ejecución total y tiempo de ejecución de LBM a lbm.write_status()
Se corrigió el error en la dirección del rayo de voxelización para volver a voxelizar objetos giratorios.
error corregido en Mesh::get_bounding_box_size()
error corregido en la función print_message() en utilities.hpp
v2.10 (11.05.2023) cambios (selección de frutos)
rendimiento de rasterización mejorado mediante selección frustrante cuando solo una parte del cuadro de simulación es visible
cambio mejorado entre el modo de cámara centrada/libre
biblioteca de renderizado OpenCL refactorizada
Los factores de conversión de unidades ahora se imprimen automáticamente en la consola cuando se usa units.set_m_kg_s(...)
tiempo de inicio más rápido para el punto de referencia FluidX3D
Corrección de errores de minero en el kernel voxelize_mesh(...)
error corregido en shading(...)
reemplazó la función std::rand() lenta (en subprocesos múltiples) con el estándar C99 LCG
Corrección más sólida de informes incorrectos de capacidad de VRAM en las GPU Intel Arc
Se corrigieron algunas advertencias menores del compilador.
Cambios v2.11 (12.07.2023) (gráficos de Linux mejorados)
Los gráficos interactivos en Linux ahora también están en modo de pantalla completa, coincidiendo completamente con Windows.
hizo que la inicialización del buffer de CPU/GPU fuera significativamente más rápida con std::fill y enqueueFillBuffer (en general, un inicio de simulación ~8% más rápido)
Se agregó información del sistema operativo a la impresión de la versión del controlador del dispositivo OpenCL.
Se corrigió el parpadeo con selección de frustrum en un campo de visión muy pequeño.
Se corrigió el error por el cual el marco renderizado/exportado no se actualizaba cuando se cambiaban visualization_modes .
Cambios v2.12 (18.01.2024) (inicio más rápido)
~ Compilación de código fuente 3 veces más rápida en Linux usando múltiples núcleos de CPU si make está instalado
Inicialización de simulación significativamente más rápida (~40% de GPU única, ~15% de GPU múltiple)
corrección de errores menores en la función Memory_Container::reset()
Cambios v2.13 (02.11.2024) (exportación .vtk mejorada)
los datos en archivos .vtk exportados ahora se convierten automáticamente a unidades SI
Exportación .vtk ~2 veces más rápida con subprocesos múltiples
Se agregaron funciones de conversión de unidades para la extensión TEMPERATURE
Se corrigieron artefactos gráficos con cámara alineada con ejes en trazado de rayos.
fijo get_exe_path() para macOS
Se corrigieron problemas de monitores múltiples X11 en Linux.
Solución alternativa para el error del controlador de Nvidia: enqueueFillBuffer no funciona para buffers grandes en GPU de Nvidia
Se corrigieron problemas de deriva numérica lenta causados por -cl-fast-relaxed-math
Se corrigió el informe incorrecto de tamaño máximo de asignación en LBM::write_status()
Se corrigió la falta de escala de coordenadas a unidades SI en LBM::write_mesh_to_vtk()
Cambios v2.14 (03.03.2024) (actualización de visualización)
La coloración ahora se puede cambiar entre velocidad/densidad/temperatura con la tecla Z.
Paletas de colores uniformes mejoradas para visualización de velocidad/densidad/temperatura.
La escala de colores con conversión automática de unidades ahora se puede mostrar con la tecla H.
El modo de corte para visualización de campo ahora dibuja cortes completamente rellenos en lugar de solo líneas para vectores de velocidad.
El sombreado en los modos VIS_FLAG_SURFACE y VIS_PHI_RASTERIZE ahora es más suave
make.sh ahora detecta automáticamente el sistema operativo y la compatibilidad con X11 en Linux y solo ejecuta FluidX3D si la última compilación fue exitosa
Advertencias fijas del compilador en Android.
Se corrigió el error make.sh en algunos sistemas debido a una ruta de intérprete no estándar.
Se corrigió que make no se compilara con múltiples núcleos en algunos sistemas.
cambios v2.15 (04.09.2024) (aumento de velocidad de fotogramas)
Se eliminó una copia de memoria de fotograma y una operación de borrado de fotograma en la cadena de renderizado, para una velocidad de fotogramas entre un 20% y un 70% mayor tanto en Windows como en Linux.
Habilitó optimizaciones del compilador g++ para un inicio más rápido y una mayor velocidad de fotogramas de renderizado.
error corregido en comprobaciones de cordura multiproceso
Se corrigió la conversión de unidades incorrecta para el coeficiente de expansión térmica.
Conversión de densidad fija a presión en unidades LBM
Se corrigió el error que hacía que el kernel de trazado de rayos pudiera bloquear la simulación.
Se corrigieron artefactos visuales menores con trazado de rayos.
Se corrigió que a veces la consola no se borraba antes de que comenzara el procesamiento INTERACTIVE_GRAPHICS_ASCII
v2.16 (05.02.2024) cambios (corrección de errores)
Implementación simplificada de cubos de marcha un 10% más rápida con interpolación 1D en los bordes en lugar de interpolación 3D, lo que permite deshacerse de la tabla de bordes.
Se agregó una variante de cubos de marcha más rápida y simplificada para renderizado de superficies sólidas donde los bordes siempre están a medio camino entre las celdas de la cuadrícula.
refactorización en núcleos de renderizado OpenCL
Se corrigió que la voxelización fallara en Intel OpenCL CPU Runtime debido al acceso fuera de límites de la matriz.
Se corrigió que la voxelización no siempre producía resultados binarios idénticos en múltiples GPU en comparación con una sola GPU.
Se corrigió que la voxelización de velocidad fallara en simulaciones de superficie libre.
Se corrigió un rendimiento terrible en las GPU ARM mediante la sustitución de macros de fusión-multiplicación ( fma ) por a*b+c
Se corrigió que las teclas Y / Z fueran incorrectas para la distribución del teclado QWERTY en Linux.
Se corrigió que la velocidad de movimiento libre de la cámara en la superposición de ayuda no se actualizaba en la imagen estacionaria al desplazarse.
Se corrigió que el cursor a veces parpadeara al desplazarse en trackpads con gráficos interactivos Linux-X11.
Se corrigió el parpadeo del renderizado interactivo con múltiples GPU cuando la cámara no se mueve.
Se corrigió la llamada faltante de XInitThreads() que podía bloquear los gráficos interactivos de Linux en algunos sistemas.
Se corrigió la lucha z entre los núcleos graphics_rasterize_phi() y graphics_flags_mc()
cambios v2.17 (06.05.2024) (resolución de dominio ilimitada)
los dominios ya no están limitados a 4,29 mil millones (2³², 1624³) celdas de cuadrícula o 225 GB de memoria; si se usan más, el código OpenCL se compilará automáticamente con indexación de 64 bits
Nueva visualización de campo basada en trazado de rayos más rápida para simulaciones de una sola GPU.
Se agregaron instrucciones de instalación del controlador GPU y OpenCL Runtime a la documentación.
refactorizado INTERACTIVE_GRAPHICS_ASCII
Se corrigió la pérdida de memoria en los destructores de floatN , floatNxN , doubleN , doubleNxN (todos sin usar)
hizo que el movimiento/rotación/zoom de la cámara fuera independiente de la velocidad de fotogramas
Se corrigió que smart_device_selection() imprimiera una advertencia incorrecta si el dispositivo informaba una velocidad de reloj de 0 MHz.
Cambios v2.18 (21.07.2024) (más correcciones de errores)
soporte agregado para monitores de alta frecuencia de actualización en Linux
scripts de instalación de OpenCL Runtime más compactos en Documentación
Las instrucciones de instalación del controlador/tiempo de ejecución ahora se imprimirán en la consola si no hay dispositivos OpenCL disponibles.
se agregó información de dominio a LBM::write_status()
se agregó la función LBM::index para el parámetro de entrada uint3
Se corrigió que las simulaciones muy grandes a veces no se renderizaran correctamente al aumentar la distancia máxima de renderizado de 10k a 2,1M.
Se corrigió la tartamudez de la entrada del mouse a una frecuencia de actualización de pantalla alta en Linux.
Se corrigieron artefactos gráficos en el trazado de rayos de superficie libre en Intel CPU Runtime para OpenCL.
estimación de tiempo de ejecución fija impresa en la consola para configuraciones con múltiples llamadas lbm.run(...)
oscilaciones de densidad fija en configuraciones de muestra ( lbm_u demasiado grande)
Se corrigieron artefactos gráficos menores en raytrace_phi()
Se corrigieron artefactos gráficos menores en ray_grid_traverse_sum()
Se corrigió el recuento incorrecto de pasos de tiempo impresos en la configuración de la muestra de gotas de lluvia.
v2.19 (09.07.2024) cambios (splines de cámara)
la cámara ahora puede volar a lo largo de una ruta suave a través de una lista de ubicaciones de cámara de fotogramas clave proporcionadas, utilizando splines Catmull-Rom
estimación del tiempo de ejecución restante más precisa que incluye el tiempo dedicado a la renderización
habilitada la compresión de memoria FP16S de forma predeterminada
La ubicación de la cámara impresa usando la tecla G ahora está formateada para copiar y pegar más fácilmente.
Se agregó un gráfico de referencia en el archivo Léame usando el diagrama de Gantt de sirena.
colocó la información de asignación de memoria durante el inicio de la simulación en una mejor ubicación
Se corrigió el conflicto de subprocesos entre INTERACTIVE_GRAPHICS y lbm.graphics.write_frame();
Se corrigió el límite máximo de tamaño de asignación de búfer para GPU AMD y en Intel CPU Runtime para OpenCL.
Se corrigió la impresión de información Re<Re_max incorrecta para simulaciones 2D.
corrección menor en bandwidth_bytes_per_cell_device()
¡Lea la documentación de FluidX3D!
transmisión (parte 2/2)
f 0 temperatura ( x , t ) = f 0 ( x , t )
f i temp ( x , t ) = f ( t %2 ? i : ( i %2 ? i +1 : i -1 )) ( i %2 ? x : x - e i , t ) para i ∈ [1 , q -1]
colisión
ρ ( x , t ) = (Σ i f i temp ( x , t )) + 1
u ( x , t ) = 1 ∕ ρ ( x , t ) Σ i c i f i temp ( x , t )
f i eq-desplazado ( x , t ) = w i ρ · ( ( u ° c i ) 2 ∕ (2 c 4 ) - ( u ° u ) ∕ (2c 2 ) + ( u ° c i ) ∕ c 2 ) + w yo ( ρ -1)
f i temp ( x , t +Δ t ) = f i temp ( x , t ) + Ω i ( f i temp ( x , t ), f i eq-desplazado ( x , t ), τ )
transmisión (parte 1/2)
f 0 ( x , t +Δ t ) = f 0 temp ( x , t +Δ t )
f ( t %2 ? ( i %2 ? i +1 : i -1 ) : i ) ( i %2 ? x + e i : x , t +Δ t ) = f i temp ( x , t +Δ t ) para i ∈ [1, q -1]
| variable | unidades SI | definicion de ecuacion | descripción |
|---|---|---|---|
| incógnita | metro | x = (x,y,z) T | Posición 3D en coordenadas cartesianas |
| t | s | - | tiempo |
| ρ | kilogramos ∕ m³ | ρ = (Σ yo f yo )+1 | densidad de masa del fluido |
| pag | kg ∕ m·s² | p = c ² ρ | presión de fluido |
| tu | metro ∕ s | tu = 1 ∕ ρ Σ yo c yo f yo | velocidad del fluido |
| v | m² ∕ s | ν = μ ∕ ρ | viscosidad de corte cinemático del fluido |
| µ | kg ∕ ms | μ = ρ ν | viscosidad dinámica del fluido |
| f yo | kilogramos ∕ m³ | - | funciones de distribución de densidad desplazada (DDF) |
| Δx | metro | Δx = 1 | constante de red (en unidades LBM) |
| Δt | s | Δ t = 1 | paso de tiempo de simulación (en unidades LBM) |
| do | metro ∕ s | c = 1 ∕ √3 Δ x ∕ Δ t | velocidad reticular del sonido (en unidades LBM) |
| i | 1 | 0 ≤ yo < q | Índice de dirección de transmisión de LBM |
| q | 1 | q ∈ { 9,15,19,27 } | número de direcciones de transmisión de LBM |
| y yo | metro | D2T9 / D3T15/19/27 | Direcciones de transmisión de LBM |
| c yo | metro ∕ s | c yo = mi yo ∕ Δ t | Velocidades de transmisión LBM |
| yo | 1 | Σ yo w yo = 1 | Pesos del conjunto de velocidad LBM |
| Ω yo | kilogramos ∕ m³ | SRT o TRT | Operador de colisión LBM |
| τ | s | τ = ν ∕ c ² + Δ t ∕ 2 | tiempo de relajación LBM |
conjuntos de velocidad: D2Q9, D3Q15, D3Q19 (predeterminado), D3Q27
Operadores de colisión: tiempo de relajación único (SRT/BGK) (predeterminado), tiempo de relajación doble (TRT)
Desplazamiento DDF y otras optimizaciones algebraicas para minimizar el error de redondeo
???????????????????????????????????????????????????????? ?????
(¿densidad?, ¿velocidad?, ¿banderas?, ¿DDF?; cada cuadrado = 1 Byte)
permite 19 millones de celdas por 1 GB de VRAM
streaming in situ con Esoteric-Pull: elimina la copia redundante de funciones de distribución de densidad (DDF) en la memoria; casi reduce la demanda de memoria a la mitad y aumenta ligeramente el rendimiento debido a límites de rebote implícitos; ofrece patrones óptimos de acceso a la memoria para la transmisión in situ de una sola celda
Precisión aritmética desacoplada (FP32) y precisión de memoria (FP32 o FP16S o FP16C): toda la aritmética se realiza en FP32 para compatibilidad con todo el hardware, pero los DDF en la memoria se pueden comprimir a FP16S o FP16C: casi reduce la demanda de memoria a la mitad nuevamente y casi duplica el rendimiento, sin afectar la precisión general para la mayoría de las configuraciones
Límites sólidos TYPE_S (estacionarios o móviles)
Límites de equilibrio TYPE_E (entrada/salida)
Límites de temperatura TYPE_T
TYPE_F superficie libre (fluido)
TYPE_I superficie libre (interfaz)
TYPE_G superficie libre (gas)
TYPE_X restantes para uso personalizado o extensiones adicionales
TYPE_Y restante para uso personalizado o extensiones adicionales
(¿densidad?, velocidad?, banderas?, 2 copias de DDF?/?; cada cuadrado = 1 Byte)
permite 3 millones de celdas por 1 GB de VRAM
LBM tradicional (D3Q19) con FP64 requiere ~344 bytes/celda
FluidX3D (D3Q19) requiere solo 55 bytes/celda con Esoteric-Pull+FP16
Gran ahorro de costos: comparación de la resolución máxima de cuadrícula de una sola GPU para D3Q19 LBM
| Capacidad de VRAM de la GPU | 1GB | 2GB | 3GB | 4GB | 6GB | 8GB | 10 GB | 11GB | 12GB | 16GB | 20GB | 24GB | 32GB | 40GB | 48GB | 64GB | 80GB | 94GB | 128GB | 192GB | 256GB |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| precio aproximado de la GPU | $25 GT 210 | $25 GTX 950 | $12 GTX 1060 | $50 GT 730 | $35 GTX 1060 | $70 RX 470 | $500 RTX 3080 | $240 GTX 1080Ti | $75 Tesla M40 | $75 Instinto MI25 | $900 RX 7900 XT | $205 Tesla P40 | $600 Instinto MI60 | $5500 A100 | $2400 RTX 8000 | $10 mil Instinto MI210 | $11 mil A100 | >$40 mil H100 NVL | ? GPU máx. 1550 | ~$10 mil MI300X | - |
| LBM tradicional (FP64) | 144³ | 182³ | 208³ | 230³ | 262³ | 288³ | 312³ | 322³ | 330³ | 364³ | 392³ | 418³ | 460³ | 494³ | 526³ | 578³ | 624³ | 658³ | 730³ | 836³ | 920³ |
| FluidX3D (FP32/FP32) | 224³ | 282³ | 322³ | 354³ | 406³ | 448³ | 482³ | 498³ | 512³ | 564³ | 608³ | 646³ | 710³ | 766³ | 814³ | 896³ | 966³ | 1018³ | 1130³ | 1292³ | 1422³ |
| FluidX3D (FP32/FP16) | 266³ | 336³ | 384³ | 424³ | 484³ | 534³ | 574³ | 594³ | 610³ | 672³ | 724³ | 770³ | 848³ | 912³ | 970³ | 1068³ | 1150³ | 1214³ | 1346³ | 1540³ | 1624³ |
la descomposición del dominio permite agrupar VRAM de múltiples GPU para obtener una resolución de cuadrícula mucho mayor
Las GPU no tienen que ser idénticas (ni siquiera del mismo proveedor), pero se recomienda una capacidad/ancho de banda de VRAM similar
arquitectura de comunicación de dominio (simplificada)
++ .----------------------------------------------- ------------------. ++++ | GPU 0 | ++++ | Dominio LBM 0 | ++++ '------------------------------------------------------ --------------------' ++++ | selectivo //| ++++ |/ copia en VRAM | ++++ .------------------------------------------------------ ----------. ++++ | GPU 0 - Búfer de transferencia 0 | ++++ '------------------------------------------------------ ----------'++!! | PCIe/| !!!! |/ copiar | !!@@ .-------------------------. .---------------------------------. @@@@ | CPU - Búfer de transferencia 0 | | CPU - Búfer de transferencia 1 | @@@@ '-------------------------' /'----------------- --------' @@@@ puntero X intercambio @@@@ .-------------------------./ .- ------------------------. @@@@ | CPU - Búfer de transferencia 1 | | CPU - Búfer de transferencia 0 | @@@@ '-------------------------' '------------------ -------'@@!! /| PCIe | !!!! | copiar |/ !!++ .------------------------------------------ -------------. ++++ | GPU 1 - Búfer de transferencia 1 | ++++ '------------------------------------------------------ ----------' ++++ /| selectivo | ++++ | copia en VRAM |/ ++++ .----------------------------------------------- --------------------------. ++++ | GPU 1 | ++++ | Dominio LBM 1 | ++++ '------------------------------------------------------ --------------------' ++## | #### barrera de sincronización de dominios #### | ##|| -------------------------------------------------- -----------> hora ||
arquitectura de comunicación de dominio (detallada)
++ .----------------------------------------------- ------------------. ++++ | GPU 0 | ++++ | Dominio LBM 0 | ++++ '------------------------------------------------------ --------------------' ++++ | entrada selectiva /| | entrada selectiva /| | entrada selectiva /| ++++ |/ Copia VRAM (X) | |/ Copia VRAM (Y) | |/ Copia VRAM (Z) | ++++ .---------------------.---------------------.- --------------------. ++++ | GPU 0-TB 0X+ | GPU 0 - TB 0Y+ | GPU 0-TB 0Z+ | ++++ | GPU 0-TB 0X- | GPU 0 - TB 0Y- | GPU 0-TB 0Z- | ++++ '---------------------'---------------------'- --------------------'++!! | PCIe/| | PCIe/| | PCIe/| !!!! |/ copiar | |/ copiar | |/ copiar | !!@@ .---------. .---------.---------. .---------.---------. .---------. @@@@ | CPU 0X+ | | CPU 1X- | CPU 0Y+ | | CPU 3 años- | Procesador 0Z+ | | CPU 5Z- | @@@@ | CPU 0X- | | CPU 2X+ | CPU 0Y- | | CPU 4 años+ | CPU 0Z- | | Procesador 6Z+ | @@@@ '--------- /---------'--------- /---------'----- ---- /---------' @@@@ intercambio de puntero X (X) intercambio de puntero X (Y) intercambio de puntero X (Z) @@@@ .-------- -/ ---------.---------/ ---------.---------/ ---------. @@@@ | CPU 1X- | | CPU 0X+ | CPU 3 años- | | CPU 0Y+ | CPU 5Z- | | Procesador 0Z+ | @@@@ | CPU 2X+ | | CPU 0X- | CPU 4 años+ | | CPU 0Y- | Procesador 6Z+ | | CPU 0Z- | @@@@ '---------' '---------'---------' '---------'--- ------' '---------' @@!! /| PCIe | /| PCIe | /| PCIe | !!!! | copiar |/ | copiar |/ | copiar |/ !!++ .--------------------..-------------------- -..--------------------. ++++ | GPU 1 - TB 1X- || GPU 3 - TB 3Y- || GPU 5 - TB 5Z- | ++++ :====================::======================:: =====================: ++++ | GPU 2 - TB 2X+ || GPU 4 - TB 4 años+ || GPU 6 - TB 6Z+ | ++++ '--------------------''---------------------'' --------------------' ++++ /| selectiva en | /| selectiva en | /| selectiva en | ++++ | Copia de VRAM (X) |/ | Copia de VRAM (Y) |/ | Copia VRAM (Z) |/ ++++ .--------------------..---------------- -----..--------------------. ++++ | GPU 1 || GPU 3 || GPU 5 | ++++ | Dominio LBM 1 || Dominio LBM 3 || Dominio LBM 5 | ++++ :====================::======================:: =====================: ++++ | GPU 2 || GPU 4 || GPU 6 | ++++ | Dominio LBM 2 || Dominio LBM 4 || Dominio LBM 6 | ++++ '--------------------''---------------------'' --------------------' ++## | | | #### | barreras de sincronización de dominios | #### | | | ##|| -------------------------------------------------- -----------> hora ||
Puntos de referencia de una sola GPU/CPU
puntos de referencia de múltiples GPU
Subred D3Q7 para DDF térmicos
Transmisión in situ con Esoteric-Pull para DDF térmicos
Compresión opcional FP16S o FP16C para DDF térmicos con cambio de DDF
modelo de volumen de fluido
PLIC totalmente analítico para un cálculo eficiente de la curvatura
conservación masiva mejorada
Implementación ultra eficiente con solo 4 núcleos adicionales al núcleo stream_collide()
Cálculo opcional de fuerzas del fluido en límites sólidos.
límites estacionarios de rebote en la cuadrícula media (límites sólidos estacionarios)
mover límites de rebote en la cuadrícula media (límites sólidos en movimiento)
Límites de equilibrio (entrada/salida no reflectante)
límites de temperatura (temperatura fija)
tipos de límites
fuerza global por volumen (forzamiento Guo), se puede modificar sobre la marcha
fuerza local por volumen (campo de fuerza)
Implementación de LBM de superficie libre (FSLBM) de última generación:
LBM térmico para simular la convección térmica
Modelo LES de turbulencia de subred de Smagorinsky-Lilly para mantener estables las simulaciones con un número de Reynolds muy grande
Π αβ = Σ i e iα e iβ ( f i - f i eq-desplazado )
Q = Σ αβ Π αβ 2
______________________
τ = ½ (τ 0 + √ τ 0 2 + (16√2) ∕ ( 3π 2 ) √Q ∕ ρ )
partículas con método de límite sumergido (ya sea pasivo o acoplado en 2 vías, solo GPU)
FluidX3D puede realizar simulaciones tan grandes que almacenar los datos volumétricos para su posterior renderización se vuelve inmanejable (como 120 GB para un solo cuadro, cientos de TeraByte para un video)
en cambio, FluidX3D permite renderizar datos de simulación sin procesar directamente en VRAM, por lo que no es necesario exportar archivos volumétricos grandes al disco duro (consulte mi charla técnica)
el renderizado es tan rápido que funciona de forma interactiva en tiempo real tanto para rasterización como para trazado de rayos
la rasterización y el trazado de rayos se realizan en OpenCL y funcionan en todas las GPU, incluso aquellas sin núcleos de trazado de rayos RTX/DXR o sin ningún hardware de renderizado (como A100, MI200, ...)
si no hay ningún monitor disponible (como en un servidor Linux remoto), hay un modo de renderizado ASCII para visualizar interactivamente la simulación en la terminal (incluso en WSL y/o mediante SSH)
El renderizado está completamente paralelizado con varias GPU mediante una rasterización perfecta de descomposición del dominio.
Con el modo de gráficos interactivos desactivado, la resolución de la imagen puede ser tan grande como lo permita la VRAM (4K/8K/16K y superior)
Modos de visualización (interactivos):
bandera de estructura alámbrica/superficie sólida (y vectores de fuerza en celdas sólidas o presión superficial si se usa la extensión)
campo de velocidad (con modo de corte)
agiliza (con modo de corte)
isosuperficie de criterio Q de color de velocidad
superficie libre rasterizada con cubos de marcha
Superficie libre con trazado de rayos con recorrido rápido de cuadrícula de rayos y cubos de marcha, ya sea de 1 a 4 rayos/píxel o de 1 a 10 rayos/píxel
FluidX3D está escrito en OpenCL 1.2, por lo que se ejecuta en todo el hardware de todos los proveedores (Nvidia, AMD, Intel,...):
Las GPU para centros de datos más rápidas del mundo: MI300X, H100 (NVL), A100, MI200, MI100, V100(S), GPU Max 1100, ...
GPU para juegos (computadora de escritorio/portátil): Nvidia GeForce, AMD Radeon, Intel Arc
GPU profesionales/estación de trabajo: Nvidia Quadro, AMD Radeon Pro / FirePro, Intel Arc Pro
GPU integradas
CPU (requiere instalación de Intel CPU Runtime para OpenCL)
Intel Xeon Phi (requiere instalación de Intel CPU Runtime para OpenCL)
GPU ARM para teléfonos inteligentes
Implementación nativa de múltiples GPU entre proveedores
utiliza comunicación PCIe, por lo que no se requiere SLI/Crossfire/NVLink/InfinityFabric
paralelización de un solo nodo, por lo que no se requiere instalación MPI
Las GPU ni siquiera tienen que ser del mismo proveedor, pero se recomiendan capacidades de memoria y ancho de banda similares.
funciona en Windows y Linux con C++17, con soporte limitado también para macOS y Android
admite la importación y voxelización de mallas triangulares desde archivos binarios .stl , con voxelización rápida de GPU
admite la exportación de datos volumétricos como archivos binarios .vtk
admite la exportación de mallas triangulares como archivos binarios .vtk
admite la exportación de imágenes renderizadas como archivos .png / .qoi / .bmp ; la codificación se ejecuta en paralelo en la CPU mientras que la simulación en la GPU puede continuar sin demora
Aquí hay puntos de referencia de rendimiento en varios hardware en MLUP/s, o cuántos millones de celdas de celosía se actualizan por segundo. Las configuraciones utilizadas para el punto de referencia son D3Q19 SRT sin extensiones habilitadas (solo LBM con límites de rebote implícitos en la cuadrícula media) y la configuración consiste en una caja cúbica vacía con un tamaño suficiente (normalmente 256³). Sin extensiones, una sola celda de celosía requiere:
una capacidad de memoria de 93 (FP32/FP32) o 55 (FP32/FP16) Bytes
un ancho de banda de memoria de 153 (FP32/FP32) o 77 (FP32/FP16) bytes por paso de tiempo
363 (FP32/FP32) o 406 (FP32/FP16S) o 1275 (FP32/FP16C) FLOP por paso de tiempo (operaciones FP32+INT32 contadas combinadas)
En consecuencia, la intensidad aritmética de esta implementación es 2,37 (FP32/FP32) o 5,27 (FP32/FP16S) o 16,56 (FP32/FP16C) FLOP/Byte. Por tanto, el rendimiento sólo está limitado por el ancho de banda de la memoria. La tabla en las 3 columnas de la izquierda muestra las especificaciones de hardware que se encuentran en las hojas de datos (rendimiento informático máximo teórico de FP32, capacidad de memoria, ancho de banda de memoria máximo teórico). Las 3 columnas de la derecha muestran el rendimiento medido de FluidX3D para FP32/FP32, FP32/FP16S, FP32/FP16C con configuraciones de precisión de punto flotante, con (eficiencia del modelo de línea de techo) entre paréntesis, lo que indica cuánto porcentaje del ancho de banda de memoria máximo teórico se está utilizando. .
Si su GPU/CPU aún no está en la lista, puede informar sus puntos de referencia aquí.
