FLAME GPU starter: de NetLogo a millones de agentes en una GPU

Los modelos basados en agentes prosperan gracias al paralelismo. La GPU FLAME ejecuta las funciones de los agentes como núcleos CUDA, por lo que una GPU del tipo de una estación de trabajo puede simular millones de agentes en tiempo real, si estructura el modelo de forma limpia. Esta guía muestra una ruta práctica y compatible con la GPU desde NetLogo/Mesa hasta FLAME GPU.

Qué cubriremos

• Elegir un Plantilla preparada para CUDA y crear una GPU FLAME
• Mínimo diseño del proyecto que es fácil de mantener
• Un diminuto función de agente esqueleto y patrón de mensajería
• Validación contra tu modelo de CPU
• Un sencillo punto de referencia de rendimiento (agente/s y coste por millón de pasos de agente)
• Elaboración de perfiles y cuellos de botella comunes

Nota de precisión: la mayoría de los ABM funcionan bien en FP32. Si su modelo es sensible, ver el Lista de verificación del FP64.

Start in seconds with the fastest, most affordable cloud GPU clusters.

Launch an instance in under a minute. Enjoy flexible pricing, powerful hardware, and 24/7 support. Scale as you grow—no long-term commitment needed.

Try Compute now

1) Elige tu imagen en tu servicio de GPU

Tu trabajo funciona dentro de un contenedor. Dos opciones que funcionan bien:

A) Tiempo de ejecución de CUDA + compilación desde la fuente (portátil)

• Plantilla: Ubuntu 24.04 LTS (CUDA 12.6)
• Añade herramientas de compilación y Python si vas a usar la API de Python.

# Dockerfile (boceto)
DESDE nvidia/cuda:12.4.1 - runtime-ubuntu22.04
ARG DEBIAN_FRONTEND=No interactivo
EJECUTE apt-get update && apt-get install -y --no-install-recommends\
cmake git python3 python3-pip\
&& rm -rf /var/lib/apt/lists/ *
ENV NVIDIA_VISIBLE_DEVICES=Todos\
NVIDIA_DRIVER_CAPABILITIES=Computación, utilidad


B) Utilice una imagen de GPU FLAME mantenida (la más rápida)

• Dirija la plantilla a la imagen privada de su laboratorio que ya incluye la GPU FLAME y las dependencias.

De cualquier manera, confirma la visibilidad de la GPU dentro del contenedor:

nvidia-smi


2) Diseño del proyecto

/trabajo
├── CMakeLists.txt
├── src/
│ ├── agents.cu # funciones de agente
│ ├── model.cu # descripción del modelo y capas
│ ── main.cu # punto de entrada
├── python/ # controlador Python opcional
── datos/ # entradas, semillas, puntos de control


Inicializa CMake y compila a partir de un árbol:

cmake -S. -B build -DCMAKE_BUILD_TYPE=Lanzamiento
cmake --build build -j


3) Función de agente y mensajería (esqueleto)

Se ejecuta FLAME GPU funciones de agente sobre matrices de agentes en la GPU. Usa mensajes para las interacciones locales.

//agents.cu
#include <flamegpu/flamegpu.h>

//Cada agente lee los mensajes en su vecindario y actualiza la velocidad
FLAMEGPU_AGENT_FUNCTION (paso, flamegpu: :messageSpatial2D, flamegpu: :messageSpatial2D) {
<float>const float x = flameGPU->getVariable («x»);
<float>const float y = flameGPU->getVariable («y»);
<float>float vx = flameGPU->getVariable («vx»);
<float>float vy = flameGPU->getVariable («vy»);

//cohesión simple
flotante cx = 0.f, cy = 0.f; int n = 0;
for (const auto &m: flameGPU->message_in (x, y)) {//iteración espacial
x += m.getVariable <float>(«x»);
cy += m.getVariable <float>(«y»);
n++;
}
if (n) {cx /= n; cy /= n; vx += 0.05f * (cx - x); vy += 0.05f * (cy - y);}

//escribir el estado y la posición de la salida
FlameGPU-> Establecer variable <float>(«vx», vx);
flameGPU->setVariable <float>(«vy», vy);
FlameGPU-> Establecer variable <float>(«x», x + vx);
FlameGPU-> Establecer variable <float>(«y», y + vy);

//emitir un mensaje para los vecinos en el siguiente paso
<float>flameGPU-> message_out.setVariable («x», x);
<float>flameGPU-> message_out.setVariable («y», y);
devuelve flamegpu: :ALIVE;
}


Descripción del modelo (patrón)

//modelo.cu
#include <flamegpu/flamegpu.h>
usando el espacio de nombres flamegpu;

modelo de descripción del modelo («abm»);
agentDescription agent = model.newAgent («A»);
<float>agent.newVariable <float>(«x»); agent.newVariable («y»);
<float>agent.newVariable <float>(«vx»); agent.newVariable («vy»);

MessageSpatial2D: :Mensaje de descripción (modelo);
msg.setBounds (0, 100, 0, 100);//límites de dominio
msg.setRadius (1.0f);//radio de interacción
msg.Nueva variable <float>(«x»);
msg.NewVariable <float>(«y»);

capa LayerDescription = Model.newLayer («L»);
Layer.addAgent Function (paso);


Esto refleja los patrones comunes de NetLogo (tortugas y radio de visión), pero en un diseño de estructura de matrices compatible con la GPU.

4) Ejecutar, sembrar y poner punto de control

. /build/abm --agents 5_000_000 --steps 1000 --seed 42\
--datos de salida/puntos de control --intervalo de punto de control 100


• Mantener semillas deterministas para su validación.
• Escriba menos puntos de control y de mayor tamaño para reducir la sobrecarga de E/S.

5) Valide en comparación con su modelo de CPU

• Elige un mundo pequeño y reglas idénticas.
• Corre Referencia de CPU (NetLogo/Mesa) y GPU para un horizonte corto.
• Compara las métricas agregadas: recuentos, posiciones medias, tamaños de clústeres o estadísticas específicas de un dominio.
• Las diferencias deben estar dentro de la varianza estocástica para la misma semilla.

Si los resultados no coinciden, compruebe el radio del mensaje, las condiciones de los límites y el orden de actualización.

6) Punto de referencia de rendimiento y costo

Usa números que sean importantes para la planificación.

métricas:
agentes: <N>
pasos: <T>
wall_seconds: <... >
agent_pasos_por_segundo: N*T/wall_seconds
cost_per_millon_agent_steps: (precio_por_hora * wall_seconds/3600)/1e6 * (N*T)


Registra el modelo de GPU o VRAM, el controlador, la versión de CUDA, la GPU FLAME y la línea de comandos exacta.

7) Perfiles y cuellos de botella

• nvidia-smi: utilización del reloj y VRAM.
• nsys/ncu: identifique los núcleos con poca ocupación o con acceso no unificado.
• Mensajería: los mensajes espaciales se escalan mejor que los de todos los pares de fuerza bruta; mantenga los radios realistas.
• Copias del dispositivo Host ↔: evite las transferencias por pasos; las salidas por lotes.
• Ramificación: divide los agentes por estado en funciones o capas separadas cuando las sucursales están calientes.

8) Solución de problemas

GPU inactiva
Muy pocos agentes o mucho trabajo del lado del anfitrión. Aumente N, reduzca la E/S por paso o transfiera la configuración al código del dispositivo.

Sin memoria
Reduzca las variables de agente, fragmente las salidas o elija un perfil de VRAM más grande.

Resultados no deterministas
Arregla las semillas y evita las reducciones desordenadas del lado del huésped. Documento RNG.

Errores de compilación
Haga coincidir CUDA con su imagen base y con la cadena de herramientas de CMake. Limpiar y reconstruir.

Fragmento de métodos (copiar y pegar)

hardware:
gpu: "<model>(<VRAM>GB)»
conductor: "<NVIDIA driver>»
<CUDA version>cuda: "»
software:
<version>flameGPU: "»
imagen: «Ubuntu 24.04 LTS (CUDA 12.6)»
modelo:
domínio: «[0,100] x [0,100]»
agentes: <N>
reglas: «demostración exclusiva de cohesión»
correr:
cmd:». <N><T>/build/abm --agents --steps --seed 42»
puntos de control: «cada 100 pasos»
salidas:
wall_seconds: «<... >»
agent_steps_per_segundo: «<... >»
cost_per_millon_agent_steps: «<... >»


Lectura relacionada

• Modelado científico de GPU en la nube: qué funciona y qué no

Prueba Compute hoy

Inicia una instancia de GPU con una plantilla preparada para CUDA (p. ej., Ubuntu 24.04 LTS/CUDA 12.6) o tu propia imagen de GROMACS. Disfrute de una facturación flexible por segundo con plantillas personalizadas y la posibilidad de iniciar, detener y reanudar las sesiones en cualquier momento. ¿No está seguro de los requisitos de FP64? Póngase en contacto con el servicio de asistencia para que le ayuden a seleccionar el perfil de hardware ideal para sus necesidades informáticas.