Massively Parallel GPU ODE Solver

Solucionador de GPU-ODE massivamente paralelo

Integrador acelerado por GPU para um grande número de sistemas independentes de equações diferenciais ordinárias

Módulos:

Sistema único por thread v3.1

Ele resolve um grande número de instâncias do mesmo sistema EDO com diferentes condições iniciais e/ou conjuntos de parâmetros.

Sistemas acoplados por bloco v1.0

Resolve um grande número de instâncias de um sistema acoplado (composto por vários subsistemas) com diferentes condições iniciais e/ou conjuntos de parâmetros.

Notas de lançamento:

18 de agosto de 2020.

Sistema único por thread v3.1:

• Suporte para precisão simples e dupla.
• Manual melhorado/retrabalhado, por exemplo, um guia de instalação mais detalhado para usuários do Windows.
• Inclusão do arquivo batch make.bat para simplificar o processo de compilação no Windows.
• Um novo tutorial (Tutorial 5) é adicionado para testar um exemplo com instâncias com diferenças de escala de tempo muito grandes. A curva de desempenho do MPGOS é comparada com os pacotes de programas odeint (C++) e DifferentialEquations.jl (Julia). MPGOS é superior a esses pacotes.
• O Tutorial 6 (dinâmica de impacto) também é estendido com curvas de desempenho, veja o ponto anterior. Neste caso, MPGOS é o único pacote de programas capaz de lidar com sistemas com dinâmica de impacto (em GPUs). Portanto, as comparações de desempenho foram feitas apenas com versões de CPU do odeint e do DifferentialEquations.jl.
• Pequenas alterações: Separação clara das variáveis ​​TimeDomain e ActualState.

Sistemas acoplados por bloco v1.0:

• Este primeiro módulo MPGOS está pronto. O código é projetado para resolver um grande número de instâncias de um sistema acoplado (composto por vários subsistemas chamados unidades) com diferentes condições iniciais e/ou conjuntos de parâmetros.
• O módulo herda quase todos os recursos do módulo Single System Per-Thread v3.1. Existem poucas especialidades, por exemplo, o tratamento de eventos só é possível em nível de unidade; apenas o acoplamento explícito pode ser tratado em forma de matriz; para detalhes, o leitor interessado deve consultar o manual.
• Dois exemplos de tutoriais são fornecidos.

14 de fevereiro de 2020.

Sistema único por thread v3.0:

• Grandes melhorias de desempenho. A técnica de metaprogramação de modelo introduzida nos permitiu produzir um código altamente otimizado. A infiltração média é de 3x, enquanto para sistemas de baixa dimensão pode ser até uma ordem de grandeza.

10 de outubro de 2019.

Sistema único por thread v2.1:

• Com Template Metaprogramming, o código é totalmente modelizado para gerar código de resolução altamente especializado durante o tempo de compilação (em função do algoritmo e da necessidade de manipulação de eventos e saída densa). Conseqüentemente, o sistema de arquivos foi retrabalhado.
• Extensão pequena: possibilidade de usar parâmetros inteiros compartilhados e acessórios inteiros para poder obter técnicas de indexação complexas de forma eficiente para sistemas complicados.

13 de agosto de 2019.

Sistema único por thread v2.0:

• A saída densa agora é suportada com poucas limitações, consulte o manual. Este é um pré-requisito, por exemplo, para resolver equações diferenciais de atraso.
• O código e sua interface são bastante simplificados e claros. Por exemplo, o Pool de Problemas foi completamente omitido do código (foi mantido por motivos históricos), e muitas opções possíveis agora estão vinculadas ao Objeto Solver, que pode ser configurado com uma única função de membro.
• O manual também é reestruturado e simplificado de acordo com os feedbacks.

9 de abril de 2019.

Sistema único por thread v1.1:

• Um dispositivo (GPU) pode ser associado a cada objeto Solver. Assim, a seleção do dispositivo agora é feita automaticamente.
• Um fluxo CUDA é criado automaticamente para cada objeto do Solver.
• Novo conjunto de funções de membro para sobrepor cálculos CPU-GPU e distribuir facilmente a carga de trabalho para diferentes GPUs em um único nó. Isso inclui memória assíncrona e operações de kernel, além de possibilidades de sincronização entre threads de CPU e fluxos de GPU.
• Um número ativo de variáveis ​​​​de threads pode ser especificado em cada fase de integração para lidar confortavelmente com o efeito de cauda.
• Dois novos exemplos de tutorial foram adicionados: a) sobreposição de cálculos de CPU e GPU usando vários objetos Solver b) usando várias GPUs disponíveis em uma única máquina/nó.

14 de fevereiro de 2019.

Sistema único por thread v1.0:

• Este primeiro módulo MPGOS está pronto. O código é projetado para resolver um grande número de sistemas ODE independentes, mas idênticos (os conjuntos de parâmetros e as condições iniciais podem ser diferentes) em GPUs.
• Facilidade de uso. Mesmo para quem é novo na programação C++, apenas um breve curso é mais que suficiente para utilizar o pacote do programa.
• Existe um manual detalhado com exemplos de tutoriais. Portanto, o usuário pode facilmente construir seu próprio projeto copiando e colando blocos de código.
• Tratamento de eventos eficiente e robusto.
• Ação definida pelo usuário após cada intervalo de tempo para flexibilidade.
• "Interações" definidas pelo usuário após cada intervalo de tempo ou manipulação de evento bem-sucedido (muito útil, por exemplo, para dinâmica de impacto, consulte os exemplos do tutorial no manual).
• Possibilidade de utilizar a hierarquia de memória da GPU sem conhecimento explícito dos detalhes.
• Parâmetro programável pelo usuário para implementações flexíveis e armazenamento de propriedades especiais de uma trajetória.
• Apenas solucionadores explícitos: Runge-Kutta de 4ª ordem com passo de tempo fixo e método Runge-Kutta-Cash-Karp de 4ª ordem com estimativa de erro incorporada de 5ª ordem. (devido ao complexo fluxo de controle dos solucionadores implícitos, o solucionador explícito às vezes tem um desempenho melhor do que os implícitos, mesmo para problemas rígidos).
• Somente operações aritméticas de precisão dupla são suportadas.
• Armazenando apenas os endpoints de cada fase de integração (para melhorar a velocidade). No entanto, isso raramente é um problema, pois os parâmetros programáveis ​​pelo usuário e as interações definidas pelo usuário acima mencionadas permitem armazenar as propriedades mais complexas de uma trajetória, consulte a documentação.