FluidX3D
v2.19 (camera splines)
O software Boltzmann CFD de treliça mais rápido e com maior eficiência de memória, rodando em todas as GPUs via OpenCL. Gratuito para uso não comercial.
(clique nas imagens para exibir vídeos no YouTube)
alterações v1.0 (04.08.2022) (lançamento público)
lançamento público
Mudanças na v1.1 (29.09.2022) (voxelização da GPU)
adicionada voxelização sólida na GPU (algoritmo lento)
ferramenta adicionada para imprimir a posição atual da câmera (tecla G )
pequena correção de bug (solução alternativa para bug do driver Intel iGPU com renderização de triângulo)
alterações v1.2 (24.10.2022) (cálculo de força/torque)
funções adicionadas para calcular força/torque em objetos
função adicionada para traduzir Mesh
adicionada configuração de validação de arrasto Stokes
Mudanças na v1.3 (10.11.2022) (pequenas correções de bugs)
funções de conversão de unidade adicionadas para torque
FORCE_FIELD e VOLUME_FORCE agora podem ser usados independentemente
pequena correção de bug (solução alternativa para bug de driver legado AMD com números binários literais)
Mudanças na v1.4 (14.12.2022) (gráficos Linux)
reescrita completa da biblioteca gráfica C++ para minimizar dependências de API
adicionado modo gráfico interativo no Linux com X11
corrigido bug de visualização simplificada em 2D
Mudanças v2.0 (09.01.2023) (atualização multi-GPU)
suporte multi-GPU adicionado (de vários fornecedores) em um único nó (PC/laptop/servidor)
alterações v2.1 (15.01.2023) (voxelização rápida)
tornou a voxelização sólida na GPU extremamente rápida (novo algoritmo, de minutos a milissegundos)
v2.2 (20.01.2023) alterações (voxelização de velocidade)
opção adicional para voxelizar geometria móvel/rotativa na GPU, com inicialização automática de velocidade para cada ponto da grade com base no centro de rotação, velocidade linear e velocidade rotacional
células que são convertidas de sólido->fluido durante a re-voxelização agora têm seus DDFs devidamente inicializados
opção adicionada para não dimensionar automaticamente a malha durante read_stl(...) , com parâmetro size negativo
kernel adicionado para renderização de limites sólidos com cubos de marcha
v2.3 (30.01.2023) alterações (partículas)
partículas adicionadas com método de limite imerso (passivo ou acoplado bidirecional, compatível apenas com GPU único)
pequena otimização do algoritmo de voxelização da GPU (threads de grupo de trabalho fora da caixa delimitadora da malha retornam após as interseções da malha de raios terem sido encontradas)
o tamanho de alocação de memória da GPU exibido agora é totalmente preciso
bug corrigido na função write_line() em src/utilities.hpp
extensão de arquivo .exe removida para Linux/macOS
Mudanças na v2.4 (11.03.2023) (melhorias na interface do usuário)
adicionado um menu de ajuda com a tecla H que mostra controles de teclado/mouse, configurações de visualização e estatísticas de simulação
melhorias no controle do teclado/mouse ( +/- para zoom, o clique do mouse libera/bloqueia o cursor)
sugestão adicionada da maior resolução de grade possível se a resolução for maior do que a memória permite
pequenas otimizações na comunicação multi-GPU (diferença insignificante de desempenho)
bug corrigido na função de equilíbrio de temperatura para extensão de temperatura
corrigido literal duplo incorreto para iGPUs Intel em funções de cores skybox
bug corrigido em make.sh onde IDs de dispositivos multi-GPU não eram encaminhados para o executável
pequenas correções de bugs no mecanismo gráfico (cursor livre não centralizado durante a rotação, rótulos no modo VR)
bug corrigido na inicialização padrão do parâmetro de tamanho LBM::voxelize_stl()
Mudanças na v2.5 (11.04.2023) (revisão do raytracing)
implementação de absorção de luz em fluido para gráficos de raytracing (sem impacto no desempenho)
taxa de quadros de traçado de raio aprimorada quando a câmera está dentro do fluido
artefatos cintilantes de poste de skybox fixo
bug corrigido onde objetos em movimento durante a re-voxelização deixavam um rastro errôneo de células sólidas da grade para trás
Alterações v2.6 (16.04.2023) (patch Intel Arc)
problemas de OpenCL corrigidos de GPUs Intel Arc: agora alocações de VRAM> 4 GB são possíveis e a capacidade correta de VRAM é relatada
Mudanças na v2.7 (29.05.2023) (atualização de visualização)
visualização de fatia adicionada (modos de tecla 2 / tecla 3 , depois alterne entre os modos de fatia com a tecla T , mova a fatia com as teclas Q / E )
tornou os kernels de visualização de wireframe de bandeira / superfície sólida alternáveis com a chave 1
visualização de pressão de superfície adicionada (chave 1 quando FORCE_FIELD está habilitado e lbm.calculate_force_on_boundaries(); é chamado)
adicionada função de exportação binária .vtk para malhas com lbm.write_mesh_to_vtk(Mesh* mesh);
adicionado time_step_multiplicator para integrate_particles() na extensão PARTICLES
tornou a correção de relatórios de memória incorretos no Intel Arc mais robusta
bug corrigido nas funções do modelo write_file()
revertido para cl::Context separado para cada dispositivo OpenCL, pois o contexto compartilhado alocaria VRAM extra em todas as outras GPUs Nvidia não utilizadas
removeu configurações de depuração e x86 do arquivo de solução do Visual Studio (uma complicação a menos para compilação)
bug corrigido em que as partículas poderiam chegar muito perto das paredes e ficar presas ou deixar a fase fluida (força de limite adicionada)
v2.8 (24.06.2023) alterações (documentação + polimento)
finalmente adicionei mais documentação
limpei todas as configurações de amostra em setup.cpp para maior facilidade para iniciantes e adicionei extensões necessárias em defines.hpp como comentários para todas as configurações
carregamento aprimorado de geometrias .stl compostas, adicionando uma opção para omitir o reposicionamento automático de malha, adicionou mais funcionalidade à estrutura Mesh em utilities.hpp
adicionada função de uint3 resolution(float3 box_aspect_ratio, uint memory) para calcular a resolução da caixa de simulação com base na proporção da caixa e na ocupação de VRAM em MB
função bool lbm.graphics.next_frame(...) adicionada para exportar imagens para uma duração de vídeo especificada no loop de computação main_setup
adicionadas macros VIS_... para facilitar a configuração dos modos de visualização no modo gráfico headless em lbm.graphics.visualization_modes
as dimensões da caixa de simulação agora são automaticamente divisíveis igualmente por domínios para simulações multi-GPU
formatação de mensagem de informação/aviso/erro corrigida para carregar arquivos e rótulos de mensagens de informação/aviso/erro coloridos
adicionou a configuração do corpo de Ahmed como um exemplo de como as forças do corpo e o coeficiente de arrasto são calculados
adicionou configurações Cessna 172 e Bell 222 para mostrar o carregamento de geometrias .stl compostas e revoxelização de peças móveis
adicionado modo de renderização semitransparente opcional ( #define GRAPHICS_TRANSPARENCY 0.7f em defines.hpp )
cintilação fixa de visualização simplificada em gráficos interativos
posicionamento suave aprimorado de linhas de fluxo no modo de fatia
bug corrigido onde mass e massex na extensão SURFACE também eram alocados na CPU RAM (não obrigatório)
bug corrigido na renderização do critério Q de dados halo no modo multi-GPU, largura reduzida do intervalo entre domínios
removeu a otimização de memória compartilhada do kernel de voxelização de malha, pois ele trava em GPUs Nvidia com novos drivers de GPU e é incompatível com GPUs OpenCL 1.0 antigas
cor fixa de atenuação do traçado de raio quando não há superfície nas paredes da caixa de simulação com limites periódicos
alterações v2.9 (31.07.2023) (multithreading)
adicionada implementação de plataforma cruzada parallel_for em utilities.hpp usando std::threads
inicialização de simulação significativamente (>4x) mais rápida com inicialização de geometria multithread e verificações de integridade
funções calculate_force_on_object() e calculate_torque_on_object() mais rápidas com multithreading
adicionado tempo de execução total e tempo de execução LBM para lbm.write_status()
bug corrigido na direção do raio de voxelização para revoxelizar objetos giratórios
bug corrigido em Mesh::get_bounding_box_size()
bug corrigido na função print_message() em utilities.hpp
v2.10 (05.11.2023) alterações (seleção de frustração)
melhor desempenho de rasterização por meio de seleção de tronco quando apenas parte da caixa de simulação está visível
alternância aprimorada entre o modo de câmera centralizado/livre
biblioteca de renderização OpenCL refatorada
fatores de conversão de unidades agora são impressos automaticamente no console quando units.set_m_kg_s(...) é usado
tempo de inicialização mais rápido para benchmark FluidX3D
correção de bug do minerador no kernel voxelize_mesh(...)
bug corrigido no shading(...)
substituiu a função lenta (em multithreading) std::rand() pelo padrão C99 LCG
correção mais robusta de relatórios incorretos de capacidade de VRAM em GPUs Intel Arc
corrigidos alguns pequenos avisos do compilador
Mudanças na v2.11 (07.12.2023) (gráficos Linux aprimorados)
gráficos interativos no Linux agora também estão em modo de tela cheia, correspondendo totalmente ao Windows
tornou a inicialização do buffer de CPU/GPU significativamente mais rápida com std::fill e enqueueFillBuffer (inicialização de simulação geral ~ 8% mais rápida)
adicionadas informações do sistema operacional à impressão da versão do driver de dispositivo OpenCL
cintilação fixa com seleção de tronco em campo de visão muito pequeno
bug corrigido onde o quadro renderizado/exportado não era atualizado quando visualization_modes eram alterados
Mudanças na v2.12 (18.01.2024) (inicialização mais rápida)
Compilação de código-fonte ~3x mais rápida no Linux usando vários núcleos de CPU se make estiver instalado
inicialização de simulação significativamente mais rápida (~40% de GPU único, ~15% de multi-GPU)
pequena correção de bug na função Memory_Container::reset()
Mudanças na v2.13 (11.02.2024) (exportação .vtk aprimorada)
os dados em arquivos .vtk exportados agora são convertidos automaticamente em unidades SI
Exportação .vtk ~2x mais rápida com multithreading
funções de conversão de unidade adicionadas para extensão TEMPERATURE
artefatos gráficos corrigidos com câmera alinhada ao eixo em raytracing
get_exe_path() corrigido para macOS
problemas de vários monitores X11 corrigidos no Linux
solução alternativa para bug do driver Nvidia: enqueueFillBuffer está quebrado para buffers grandes em GPUs Nvidia
corrigidos problemas de desvio numérico lento causados por -cl-fast-relaxed-math
corrigido o relatório errado de tamanho máximo de alocação em LBM::write_status()
corrigida a falta de escala de coordenadas para unidades SI em LBM::write_mesh_to_vtk()
Mudanças na v2.14 (03.03.2024) (atualização de visualização)
a coloração agora pode ser alternada entre velocidade/densidade/temperatura com a tecla Z
paletas de cores melhoradas e uniformes para visualização de velocidade/densidade/temperatura
escala de cores com conversão automática de unidades agora pode ser mostrada com a tecla H
modo de fatia para visualização de campo agora desenha fatias totalmente preenchidas em vez de apenas linhas para vetores de velocidade
o sombreamento nos modos VIS_FLAG_SURFACE e VIS_PHI_RASTERIZE é mais suave agora
make.sh agora detecta automaticamente o sistema operacional e o suporte X11 no Linux e só executa o FluidX3D se a última compilação tiver sido bem-sucedida
avisos de compilador corrigidos no Android
corrigida a falha make.sh em alguns sistemas devido ao caminho do interpretador fora do padrão
corrigido que make não compilava com múltiplos núcleos em alguns sistemas
Mudanças na v2.15 (09.04.2024) (aumento da taxa de quadros)
eliminou uma cópia de memória de quadro e uma operação de quadro limpo na cadeia de renderização, para uma taxa de quadros 20-70% maior no Windows e no Linux
habilitou otimizações do compilador g++ para inicialização mais rápida e maior taxa de quadros de renderização
bug corrigido em verificações de integridade multithread
corrigida conversão de unidade errada para coeficiente de expansão térmica
densidade fixa para conversão de pressão em unidades LBM
bug corrigido que o kernel de raytracing poderia travar a simulação
pequenos artefatos visuais corrigidos com raytracing
corrigido que o console às vezes não era limpo antes do início da renderização INTERACTIVE_GRAPHICS_ASCII
alterações v2.16 (02.05.2024) (correções de bugs)
implementação simplificada de cubos de marcha 10% mais rápida com interpolação 1D nas bordas em vez de interpolação 3D, permitindo eliminar a tabela de bordas
adicionada variante de cubos de marcha mais rápida e simplificada para renderização de superfícies sólidas onde as bordas estão sempre a meio caminho entre as células da grade
refatoração em kernels de renderização OpenCL
corrigido que a voxelização falhava no Intel OpenCL CPU Runtime devido ao acesso fora dos limites do array
corrigido que a voxelização nem sempre produzia resultados binários idênticos em multi-GPU em comparação com GPU único
corrigido que a voxelização de velocidade falhava em simulações de superfície livre
corrigiu o péssimo desempenho em GPUs ARM substituindo macro-fused-multiply-add ( fma ) por a*b+c
corrigido que as teclas Y / Z estavam incorretas para o layout do teclado QWERTY no Linux
corrigido que a velocidade de movimento livre da câmera na sobreposição de ajuda não era atualizada na imagem estacionária ao rolar
corrigido que o cursor às vezes piscava ao rolar em trackpads com gráficos interativos Linux-X11
cintilação fixa da renderização interativa com multi-GPU quando a câmera não é movida
corrigida a chamada XInitThreads() ausente que poderia travar gráficos interativos do Linux em alguns sistemas
Corrigida luta z entre os kernels graphics_rasterize_phi() e graphics_flags_mc()
Alterações v2.17 (05.06.2024) (resolução de domínio ilimitada)
os domínios não estão mais limitados a 4,29 bilhões (2³², 1624³) de células de grade ou 225 GB de memória; se mais forem usados, o código OpenCL será compilado automaticamente com indexação de 64 bits
nova visualização de campo baseada em raytracing mais rápida para simulações de GPU única
adicionadas instruções de instalação do driver GPU e OpenCL Runtime à documentação
INTERACTIVE_GRAPHICS_ASCII refatorado
vazamento de memória corrigido em destruidores de floatN , floatNxN , doubleN , doubleNxN (todos não utilizados)
tornou o movimento/rotação/comportamento de zoom da câmera independente da taxa de quadros
corrigido que smart_device_selection() imprimiria um aviso errado se o dispositivo relatasse velocidade de clock de 0 MHz
Mudanças na v2.18 (21.07.2024) (mais correções de bugs)
adicionado suporte para monitores de alta taxa de atualização no Linux
scripts de instalação OpenCL Runtime mais compactos na documentação
as instruções de instalação do driver/tempo de execução agora serão impressas no console se nenhum dispositivo OpenCL estiver disponível
adicionou informações de domínio a LBM::write_status()
adicionada função LBM::index para o parâmetro de entrada uint3
corrigido que simulações muito grandes às vezes não eram renderizadas corretamente, aumentando a distância máxima de renderização de 10k para 2,1M
correção de travamento na entrada do mouse em alta taxa de atualização da tela no Linux
artefatos gráficos corrigidos no raytracing de superfície livre no Intel CPU Runtime para OpenCL
estimativa de tempo de execução fixa impressa no console para configurações com múltiplas chamadas lbm.run(...)
oscilações de densidade fixa em configurações de amostra (muito grande lbm_u )
corrigidos pequenos artefatos gráficos em raytrace_phi()
corrigidos pequenos artefatos gráficos em ray_grid_traverse_sum()
corrigida a contagem incorreta de passos de tempo impressos na configuração da amostra de gota de chuva
v2.19 (07.09.2024) alterações (splines da câmera)
a câmera agora pode voar ao longo de um caminho suave através de uma lista de posicionamentos de câmera de quadro-chave fornecidos, usando splines Catmull-Rom
estimativa de tempo de execução restante mais precisa que inclui o tempo gasto na renderização
habilitou a compactação de memória FP16S por padrão
o posicionamento da câmera impressa usando a tecla G agora está formatado para facilitar copiar/colar
adicionado gráfico de benchmark no Leiame usando o gráfico de Gantt da sereia
colocou informações de alocação de memória durante a inicialização da simulação em um local melhor
conflito de threading corrigido entre INTERACTIVE_GRAPHICS e lbm.graphics.write_frame();
limite máximo de tamanho de alocação de buffer fixo para GPUs AMD e em Intel CPU Runtime para OpenCL
corrigida impressão incorreta de informações Re<Re_max para simulações 2D
pequena correção em bandwidth_bytes_per_cell_device()
Leia a documentação do FluidX3D!
streaming (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]
colisão
ρ ( x , t ) = (Σ i f i temp ( x , t )) + 1
você ( x , t ) = 1 ∕ ρ ( x , t ) Σ i c i f i temp ( x , t )
f i eq-deslocado ( x , t ) = w i ρ · ( ( u ° c i ) 2 ∕ (2 c 4 ) - ( u ° u ) ∕ (2c 2 ) + ( u ° c i ) ∕ c 2 ) + w eu ( ρ -1)
f i temp ( x , t +Δ t ) = f i temp ( x , t ) + Ω i ( f i temp ( x , t ), f i eq-shifted ( x , t ), τ )
streaming (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 ) = fi temp ( x , t +Δ t ) para eu ∈ [1, q -1]
| variável | Unidades SI | definindo equação | descrição |
|---|---|---|---|
| x | eu | x = (x,y,z) T | Posição 3D em coordenadas cartesianas |
| t | é | - | tempo |
| ρ | kg ∕ m³ | ρ = (Σ i f i )+1 | densidade de massa do fluido |
| p | kg ∕ m s² | p = c²ρ | pressão do fluido |
| você | m ∕ s | você = 1 ∕ ρ Σ eu c eu f eu | velocidade do fluido |
| você | m² ∕ s | ν = μ ∕ ρ | viscosidade de cisalhamento cinemático do fluido |
| μ | kg ∕ m·s | μ = ρν | viscosidade dinâmica do fluido |
| e eu | kg ∕ m³ | - | funções de distribuição de densidade deslocadas (DDFs) |
| Δ x | eu | Δ x = 1 | constante de rede (em unidades LBM) |
| Δ t | é | Δ t = 1 | intervalo de tempo de simulação (em unidades LBM) |
| c | m ∕ s | c = 1 ∕ √3 Δ x ∕ Δ t | velocidade reticular do som (em unidades LBM) |
| eu | 1 | 0 ≤ eu < q | Índice de direção de streaming LBM |
| q | 1 | q ∈ { 9,15,19,27 } | número de direções de streaming LBM |
| e eu | eu | D2Q9/D3Q15/19/27 | Direções de streaming LBM |
| c eu | m ∕ s | c eu = e eu ∕ Δ t | Velocidades de streaming LBM |
| eu | 1 | Σ eu w eu = 1 | Pesos definidos de velocidade LBM |
| Ah, eu | kg ∕ m³ | SRT ou TRT | Operador de colisão LBM |
| τ | é | τ = ν ∕ c ² + Δ t ∕ 2 | Tempo de relaxamento LBM |
conjuntos de velocidade: D2Q9, D3Q15, D3Q19 (padrão), D3Q27
operadores de colisão: tempo de relaxamento único (SRT/BGK) (padrão), tempo de relaxamento duplo (TRT)
Deslocamento DDF e outras otimizações algébricas para minimizar erros de arredondamento
??????????????????????????????????????????????????????? ?????
(densidade?, velocidade?, sinalizadores?, DDFs?; cada quadrado = 1 byte)
permite 19 milhões de células por 1 GB de VRAM
streaming in-loco com Esoteric-Pull: elimina cópia redundante de funções de distribuição de densidade (DDFs) na memória; quase reduz a demanda de memória pela metade e aumenta ligeiramente o desempenho devido aos limites implícitos de recuperação; oferece padrões ideais de acesso à memória para streaming local de célula única
precisão aritmética dissociada (FP32) e precisão de memória (FP32 ou FP16S ou FP16C): toda aritmética é feita em FP32 para compatibilidade em todo o hardware, mas DDFs na memória podem ser compactados para FP16S ou FP16C: quase reduz a demanda de memória pela metade novamente e quase dobra o desempenho, sem afetar a precisão geral para a maioria das configurações
Limites sólidos TYPE_S (estacionários ou móveis)
Limites de equilíbrio TYPE_E (entrada/saída)
Limites de temperatura TYPE_T
Superfície livre TYPE_F (fluido)
Superfície livre TYPE_I (interface)
Superfície livre TYPE_G (gás)
TYPE_X restante para uso personalizado ou outras extensões
TYPE_Y restante para uso personalizado ou outras extensões
(densidade ?, velocidade ?, sinalizadores ?, 2 cópias de DDFs ?/?; cada quadrado = 1 Byte)
permite 3 milhões de células por 1 GB VRAM
LBM tradicional (D3Q19) com FP64 requer ~344 bytes/célula
FluidX3D (D3Q19) requer apenas 55 Bytes/célula com Esoteric-Pull+FP16
grande economia de custos: comparação da resolução máxima de grade de GPU única para D3Q19 LBM
| Capacidade VRAM da GPU | 1 GB | 2GB | 3GB | 4GB | 6GB | 8GB | 10GB | 11GB | 12GB | 16 GB | 20 GB | 24 GB | 32 GB | 40 GB | 48 GB | 64GB | 80 GB | 94GB | 128GB | 192GB | 256GB |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| preço aproximado da GPU | US$ 25 GT 210 | US$ 25 GTX 950 | US$ 12 GTX 1060 | US$ 50 GT730 | US$ 35 GTX 1060 | US$ 70 RX 470 | US$ 500 RTX3080 | US$ 240 GTX 1080Ti | US$ 75 Tesla M40 | US$ 75 Instinto MI25 | US$ 900 RX 7900 XT | US$ 205 Tesla P40 | US$ 600 Instinto MI60 | US$ 5.500 A100 | US$ 2.400 RTX 8000 | US$ 10 mil Instinto MI210 | US$ 11 mil A100 | >US$ 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³ |
a decomposição de domínio permite agrupar VRAM de várias GPUs para uma resolução de grade muito maior
As GPUs não precisam ser idênticas (nem mesmo do mesmo fornecedor), mas recomenda-se capacidade/largura de banda de VRAM semelhantes
arquitetura de comunicação de domínio (simplificada)
++.---------------------------------------------------------- ------------------. ++++ | GPU 0 | ++++ | Domínio LBM 0 | ++++ '----------------------------------------------------------- --------------------'++++ | seletivo /| ++++ |/ cópia na VRAM | ++++.----------------------------------------------------------- ----------. ++++ | GPU 0 - Buffer de transferência 0 | ++++ '----------------------------------------------------------- ----------'++!! | PCIe /| !!!! |/ copiar | !!@@ .--------------. .-------------------------. @@@@ | CPU - Buffer de transferência 0 | | CPU - Buffer de transferência 1 | @@@@ '------------------------' /'----------------- --------' @@@@ ponteiro X swap @@@@ .----------------------------./ .- ------------------------. @@@@ | CPU - Buffer de transferência 1 | | CPU - Buffer de transferência 0 | @@@@ '------------------------' '----------------- -------'@@!! /| PCIe | !!!! | copiar |/ !!++ .------------------------------------------ -------------. ++++ | GPU 1 - Buffer de transferência 1 | ++++ '----------------------------------------------------------- ----------'++++ /| seletivo | ++++ | cópia na VRAM |/ ++++ .-------------------------------------- --------------------------. ++++ | GPU 1 | ++++ | Domínio LBM 1 | ++++ '----------------------------------------------------------- --------------------' ++## | #### barreira de sincronização de domínio #### | ##|| -------------------------------------------------- -----------> hora ||
arquitetura de comunicação de domínio (detalhado)
++.---------------------------------------------------------- ------------------. ++++ | GPU 0 | ++++ | Domínio LBM 0 | ++++ '----------------------------------------------------------- --------------------'++++ | seletivo em- /| | seletivo em- /| | seletivo em- /| ++++ |/ Cópia VRAM (X) | |/ Cópia VRAM (Y) | |/ Cópia 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 | !!@@ .---------. .--------.---------. .--------.---------. .---------. @@@@ | CPU0X+ | | CPU 1X- | CPU 0Y+ | | CPU 3Y- | CPU 0Z+ | | CPU 5Z- | @@@@ | CPU 0X- | | CPU 2X+ | CPU 0Y- | | CPU 4 anos + | CPU 0Z- | | Processador 6Z+ | @@@@ '--------- /---------'--------- /---------'----- ---- /---------' @@@@ ponteiro X swap (X) ponteiro X swap (Y) ponteiro X swap (Z) @@@@ .-------- -/ ---------.---------/ ---------.---------/ -------- -. @@@@ | CPU 1X- | | CPU0X+ | CPU 3Y- | | CPU 0Y+ | CPU 5Z- | | CPU 0Z+ | @@@@ | CPU 2X+ | | CPU 0X- | CPU 4 anos + | | CPU 0Y- | Processador 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 4Y+ || GPU 6 -TB 6Z+ | ++++ '-------------------''---------------------'' --------------------'++++ /| seletivo em- | /| seletivo em- | /| seletivo em- | ++++ | Cópia VRAM (X) |/ | Cópia VRAM (Y) |/ | Cópia VRAM (Z) |/ ++++ .----------------------------------..---------------- ---------------------------. ++++ | GPU 1 || GPU3 || GPU 5 | ++++ | Domínio LBM 1 || Domínio LBM 3 || Domínio LBM 5 | ++++ :====================::=====================:: ====================:++++ | GPU 2 || GPU 4 || GPU 6 | ++++ | Domínio LBM 2 || Domínio LBM 4 || Domínio LBM 6 | ++++ '-------------------''---------------------'' --------------------' ++## | | | #### | barreiras de sincronização de domínio | #### | | | ##|| -------------------------------------------------- -----------> hora ||
benchmarks de GPU/CPU único
benchmarks multi-GPU
Sub-rede D3Q7 para DDFs térmicos
streaming no local com Esoteric-Pull para DDFs térmicos
compressão FP16S ou FP16C opcional para DDFs térmicos com deslocamento de DDF
modelo de volume de fluido
PLIC totalmente analítico para cálculo eficiente de curvatura
conservação de massa melhorada
implementação ultraeficiente com apenas 4 kernels adicionais ao kernel stream_collide()
cálculo opcional de forças do fluido em limites sólidos
limites estacionários de recuperação da grade intermediária (limites sólidos estacionários)
movendo limites de recuperação da grade intermediária (movendo limites sólidos)
limites de equilíbrio (entrada/saída não reflexiva)
limites de temperatura (temperatura fixa)
tipos de limite
força global por volume (forçamento Guo), pode ser modificada instantaneamente
força local por volume (campo de força)
Implementação de LBM de superfície livre de última geração (FSLBM):
LBM térmico para simular convecção térmica
Modelo LES de turbulência da subrede Smagorinsky-Lilly para manter estáveis simulações com números de Reynolds muito grandes
Π αβ = Σ i e iα e iβ ( f i - f i eq-shifted )
Q = Σ αβ Π αβ 2
______________________
τ = ½ (τ 0 + √ τ 0 2 + (16√2) ∕ ( 3π 2 ) √Q ∕ ρ )
partículas com método de limite imerso (passivo ou acoplado de 2 vias, apenas GPU único)
O FluidX3D pode fazer simulações tão grandes que o armazenamento de dados volumétricos para renderização posterior se torna incontrolável (como 120 GB para um único quadro, centenas de TeraBytes para um vídeo)
em vez disso, o FluidX3D permite renderizar dados brutos de simulação diretamente na VRAM, de modo que nenhum arquivo volumétrico grande precise ser exportado para o disco rígido (veja minha palestra técnica)
a renderização é tão rápida que funciona interativamente em tempo real tanto para rasterização quanto para traçado de raio
rasterização e raytracing são feitos em OpenCL e funcionam em todas as GPUs, mesmo aquelas sem núcleos de raytracing RTX/DXR ou sem qualquer hardware de renderização (como A100, MI200, ...)
se nenhum monitor estiver disponível (como em um servidor Linux remoto), existe um modo de renderização ASCII para visualizar interativamente a simulação no terminal (mesmo em WSL e/ou através de SSH)
a renderização é totalmente paralelizada por multi-GPU por meio de rasterização de decomposição de domínio contínua
com o modo gráfico interativo desativado, a resolução da imagem pode ser tão grande quanto a VRAM permitir (4K/8K/16K e superior)
modos de visualização (interactivos):
sinalizar wireframe / superfície sólida (e vetores de força em células sólidas ou pressão de superfície se a extensão for usada)
campo de velocidade (com modo de fatia)
simplifica (com modo de fatia)
isosuperfície de critério Q colorida com velocidade
superfície livre rasterizada com cubos em marcha
superfície livre traçada por raios com travessia rápida de grade de raios e cubos de marcha, de 1 a 4 raios/pixel ou de 1 a 10 raios/pixel
FluidX3D é escrito em OpenCL 1.2, portanto roda em todos os hardwares de todos os fornecedores (Nvidia, AMD, Intel, ...):
GPUs de datacenter mais rápidas do mundo: MI300X, H100 (NVL), A100, MI200, MI100, V100(S), GPU Max 1100, ...
GPUs para jogos (desktop/laptop): Nvidia GeForce, AMD Radeon, Intel Arc
GPUs profissionais/estações de trabalho: Nvidia Quadro, AMD Radeon Pro/FirePro, Intel Arc Pro
GPUs integradas
CPUs (requer instalação do Intel CPU Runtime para OpenCL)
Intel Xeon Phi (requer instalação do Intel CPU Runtime para OpenCL)
GPUs ARM para smartphones
implementação nativa de multi-GPU entre fornecedores
usa comunicação PCIe, portanto não é necessário SLI/Crossfire/NVLink/InfinityFabric
paralelização de nó único, portanto, não é necessária instalação de MPI
As GPUs nem precisam ser do mesmo fornecedor, mas são recomendadas capacidades de memória e largura de banda semelhantes
funciona em Windows e Linux com C++17, com suporte limitado também para macOS e Android
suporta importação e voxelização de malhas triangulares de arquivos binários .stl , com rápida voxelização de GPU
suporta a exportação de dados volumétricos como arquivos binários .vtk
suporta a exportação de malhas triangulares como arquivos binários .vtk
suporta a exportação de imagens renderizadas como arquivos .png / .qoi / .bmp ; a codificação é executada em paralelo na CPU enquanto a simulação na GPU pode continuar sem demora
Aqui estão os benchmarks de desempenho em vários hardwares em MLUPs/s, ou quantos milhões de células de rede são atualizadas por segundo. As configurações usadas para o benchmark são D3Q19 SRT sem extensões habilitadas (apenas LBM com limites implícitos de recuperação da grade intermediária) e a configuração consiste em uma caixa cúbica vazia com tamanho suficiente (normalmente 256³). Sem extensões, uma única célula de rede requer:
uma capacidade de memória de 93 (FP32/FP32) ou 55 (FP32/FP16) Bytes
uma largura de banda de memória de 153 (FP32/FP32) ou 77 (FP32/FP16) bytes por intervalo de tempo
363 (FP32/FP32) ou 406 (FP32/FP16S) ou 1275 (FP32/FP16C) FLOPs por intervalo de tempo (operações FP32+INT32 contadas combinadas)
Em consequência, a intensidade aritmética desta implementação é 2,37 (FP32/FP32) ou 5,27 (FP32/FP16S) ou 16,56 (FP32/FP16C) FLOPs/Byte. Portanto, o desempenho é limitado apenas pela largura de banda da memória. A tabela nas 3 colunas à esquerda mostra as especificações de hardware encontradas nas folhas de dados (pico teórico de desempenho de computação FP32, capacidade de memória, pico teórico de largura de banda de memória). As três colunas à direita mostram o desempenho medido do FluidX3D para configurações de precisão de ponto flutuante FP32/FP32, FP32/FP16S, FP32/FP16C, com (eficiência do modelo Roofline) entre colchetes, indicando quanto% da largura de banda de memória de pico teórica está sendo usada .
Se sua GPU/CPU ainda não estiver na lista, você pode relatar seus benchmarks aqui.
