Massively Parallel GPU ODE Solver

Solucionador-GPU-ODE-masivamente-paralelo

Integrador acelerado por GPU para una gran cantidad de sistemas de ecuaciones diferenciales ordinarias independientes

Módulos:

Sistema único por subproceso v3.1

Resuelve una gran cantidad de instancias del mismo sistema ODE con diferentes condiciones iniciales y/o conjuntos de parámetros.

Sistemas acoplados por bloque v1.0

Resuelve una gran cantidad de instancias de un sistema acoplado (compuesto por muchos subsistemas) con diferentes condiciones iniciales y/o conjuntos de parámetros.

Notas de la versión:

18 de agosto de 2020.

Sistema único por subproceso v3.1:

• Soporte para precisión simple y doble.
• Manual mejorado/reelaborado, por ejemplo, una guía de instalación más detallada para usuarios de Windows.
• Inclusión del archivo por lotes make.bat para simplificar el proceso de compilación en Windows.
• Se agrega un nuevo tutorial (Tutorial 5) para probar un ejemplo que tiene instancias con diferencias de escala de tiempo muy grandes. La curva de rendimiento de MPGOS se compara con los paquetes de programas odeint (C++) y DifferentialEquations.jl (Julia). MPGOS es superior a estos paquetes.
• El tutorial 6 (dinámica de impacto) también se amplía con curvas de rendimiento, ver el punto anterior. En este caso, MPGOS es el único paquete de programas capaz de manejar sistemas con dinámica de impacto (en GPU). Por lo tanto, las comparaciones de rendimiento se realizaron únicamente con versiones de CPU de odeint y DifferentialEquations.jl.
• Cambios menores: separación clara de las variables TimeDomain y ActualState.

Sistemas acoplados por bloque v1.0:

• Este primer módulo MPGOS está listo. El código está diseñado para resolver una gran cantidad de instancias de un sistema acoplado (compuesto por muchos subsistemas llamados unidades) con diferentes condiciones iniciales y/o conjuntos de parámetros.
• El módulo hereda casi todas las características del módulo Single System Per-Thread v3.1. Hay pocas especialidades; por ejemplo, el manejo de eventos sólo es posible a nivel de unidad; sólo el acoplamiento explícito puede tratarse en forma matricial; para más detalles, se remite al lector interesado al manual.
• Se proporcionan dos ejemplos de tutoriales.

14 de febrero de 2020.

Sistema único por subproceso v3.0:

• Mejoras masivas de rendimiento. La técnica de metaprogramación de plantillas introducida nos permitió producir un código altamente optimizado. La filtración promedio es 3x, mientras que para sistemas de pequeñas dimensiones, puede ser incluso de un orden de magnitud.

10 de octubre de 2019.

Sistema único por subproceso v2.1:

• Con Template Metaprogramming, el código está completamente plantillado para generar código de resolución altamente especializado durante el tiempo de compilación (en función del algoritmo y la necesidad de manejo de eventos y salida densa). En consecuencia, se modifica el sistema de archivos.
• Pequeña extensión: posibilidad de utilizar parámetros compartidos de números enteros y accesorios de números enteros para poder lograr técnicas de indexación complejas de manera eficiente para sistemas complicados.

13 de agosto de 2019.

Sistema único por subproceso v2.0:

• Ahora se admite la salida densa con pocas limitaciones; consulte el manual. Este es un requisito previo, por ejemplo, para resolver ecuaciones diferenciales de retardo.
• El código y su interfaz están enormemente simplificados y claros. Por ejemplo, el grupo de problemas se omite por completo en el código (se mantuvo por razones históricas) y muchas opciones posibles ahora están vinculadas al objeto Solver que se puede configurar todo con una única función miembro.
• El manual también se reestructura y simplifica en función de los comentarios.

9 de abril de 2019.

Sistema único por subproceso v1.1:

• Se puede asociar un dispositivo (GPU) a cada Objeto Solver. Por lo tanto, la selección de dispositivos ahora se realiza automáticamente.
• Se crea automáticamente una secuencia CUDA para cada objeto Solver.
• Nuevo conjunto de funciones miembro para superponer cálculos CPU-GPU y distribuir fácilmente la carga de trabajo a diferentes GPU en un solo nodo. Esto incluye operaciones asincrónicas de memoria y kernel, y posibilidades de sincronización entre subprocesos de CPU y flujos de GPU.
• Se puede especificar un número activo de subprocesos variables en cada fase de integración para manejar cómodamente el efecto de cola.
• Se agregan dos nuevos ejemplos de tutoriales: a) superposición de cálculos de CPU y GPU usando múltiples objetos Solver b) usando múltiples GPU disponibles en una sola máquina/nodo.

14 de febrero de 2019.

Sistema único por subproceso v1.0:

• Este primer módulo MPGOS está listo. El código está diseñado para resolver una gran cantidad de sistemas ODE independientes pero idénticos (los conjuntos de parámetros y las condiciones iniciales pueden ser diferentes) en GPU.
• Facilidad de uso. Incluso aquellos que son nuevos en la programación en C++, sólo un curso corto es más que suficiente para utilizar el paquete del programa.
• Hay un manual detallado con ejemplos de tutoriales. Por lo tanto, el usuario puede crear fácilmente su propio proyecto copiando y pegando bloques de código.
• Manejo de eventos eficiente y robusto.
• Acción definida por el usuario después de cada paso para mayor flexibilidad.
• "Interacciones" definidas por el usuario después de cada paso de tiempo exitoso o manejo de eventos (muy útil, por ejemplo, para dinámicas de impacto, consulte los ejemplos de tutoriales en el manual).
• Posibilidad de utilizar la jerarquía de memoria de la GPU sin conocimiento explícito de los detalles.
• Parámetro programable por el usuario para implementaciones flexibles y almacenamiento de propiedades especiales de una trayectoria.
• Solo solucionadores explícitos: Runge-Kutta de cuarto orden con un paso de tiempo fijo y método Runge-Kutta-Cash-Karp de cuarto orden con estimación de error integrada de quinto orden. (debido al complejo flujo de control de los solucionadores implícitos, los solucionadores explícitos a veces funcionan mejor que los implícitos incluso para problemas difíciles).
• Sólo se admiten operaciones aritméticas de doble precisión.
• Almacenar solo los puntos finales de cada fase de integración (para mejorar la velocidad). Sin embargo, esto rara vez es un problema, ya que los parámetros programables por el usuario y las interacciones definidas por el usuario antes mencionadas permiten almacenar las propiedades más complejas de una trayectoria; consulte la documentación.