FLAME GPU starter: do NetLogo a milhões de agentes em uma GPU

Os modelos baseados em agentes prosperam no paralelismo. A GPU FLAME executa funções de agente como kernels CUDA, para que uma GPU de classe de estação de trabalho possa ser semelhante milhões de agentes em tempo real — se você estruturar o modelo de forma limpa. Este guia mostra um caminho prático e compatível com a GPU NetLogo/Mesa para a GPU FLAME.

O que abordaremos

• Escolhendo um Modelo pronto para CUDA e construindo a GPU FLAME
• Mínimo layout do projeto que é fácil de manter
• Um minúsculo função de agente esqueleto e padrão de mensagens
• Validação em relação ao seu modelo de CPU
• Um simples referência de taxa de transferência (agentes e custo por milhão de etapas do agente)
• Definição de perfil e gargalos comuns

Nota de precisão: a maioria dos ABMs funciona bem no FP32. Se seu modelo for sensível, veja o Lista de verificação do 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) Escolha sua imagem em seu serviço de GPU

Seu trabalho funciona dentro de um contêiner. Duas opções que funcionam bem:

A) Tempo de execução CUDA+compilação a partir da fonte (portátil)

• Modelo: Ubuntu 24.04 LTS (CUDA 12.6)
• Adicione ferramentas de construção e Python se você quiser usar a API Python.

# Dockerfile (esboço)
DE nvidia/cuda: 12.4.1 - tempo de execução - ubuntu22.04
ARG DEBIAN_FRONTEND=Não interativo
EXECUTE apt-get update && apt-get install -y --no-install-recommends\
cmake essencial para construção git python3 python3-pip\
&& rm -rf /var/lib/apt/lists/ *
ENV NVIDIA_VISIBLE_DEVICES=Todos\
nvidia_driver_capabilities=Computação, utilitário


B) Use uma imagem da GPU FLAME mantida (mais rápida)

• Aponte seu modelo para a imagem privada do seu laboratório que já inclui a GPU FLAME e as dependências.

De qualquer forma, confirme a visibilidade da GPU dentro do contêiner:

nvidia-smi


2) Layout do projeto

/work
─ CMakeLists.txt
─ src/
│ ─ agents.cu # funções do agente
│ ─ ─ model.cu # descrição e camadas do modelo
│ ─ main.cu # ponto de entrada
─ driver python/ # Python opcional
─ dados/ # entradas, sementes, pontos de verificação


Inicialize o CMake e crie fora da árvore:

cmake -S. -B build -DCMAKE_BUILD_TYPE=Lançamento
cmake --build build -j


3) Função do agente + mensagens (esqueleto)

A GPU FLAME funciona funções do agente sobre matrizes de agentes na GPU. Use mensagens para interações locais.

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

//Cada agente lê mensagens em sua vizinhança e atualiza a velocidade
FLAMEGPU_AGENT_FUNCTION (etapa, 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”);

//coesão simples
flutuar cx = 0.f, cy = 0.f; int n = 0;
for (const auto &m: FlameGPU->message_in (x, y)) {//iteração espacial
cx += m.GetVariable <float>(“x”);
cy += m.getVariable <float>(“y”);
n++;
}
se (n) {cx /= n; cy /= n; vx += 0,05f * (cx - x); vy += 0,05f * (cy - y);}

//escreve o estado e a posição de saída
FlameGPU -> definir variável <float>(“vx”, vx);
FlameGPU -> definir variável <float>(“vy”, vy);
FlameGPU -> definir variável <float>(“x”, x+ vx);
FlameGPU-> definir variável <float>(“y”, y+ vy);

//emite mensagem para os vizinhos na próxima etapa
<float>FlameGPU-> message_out.setVariável (“x”, x);
<float>FlameGPU->message_out.setVariável (“y”, y);
retornar flamegpu: :ALIVE;
}


Descrição do modelo (padrão)

//model.cu
#include <flamegpu/flamegpu.h>
usando o namespace flamegpu;

modelo de descrição do modelo (“abm”);
agente AgentDescription = Model.newAgent (“A”);
<float>Agent.newVariable <float>(“x”); Agent.newVariable (“y”);
<float>agent.newVariable <float>(“vx”); agent.newVariable (“vy”);

messageSpatial2D: :Descrição msg (modelo);
msg.setBounds (0, 100, 0, 100); //limites de domínio
msg.setRadius (1.0f); //raio de interação
msg.Nova variável <float>(“x”);
msg.Nova variável <float>(“y”);

camada LayerDescription = model.newLayer (“L”);
layer.addAgentFunction (etapa);


Isso reflete os padrões comuns do NetLogo (tartarugas + raio de visão), mas em um layout de estrutura de matrizes compatível com GPU.

4) Executar, testar e verificar

. /build/abm --agents 5_000_000 --steps 1000 --seed 42\
--dados de saída/pontos de verificação --intervalo de ponto de verificação 100


• Mantenha sementes determinísticas para validação.
• Escreva pontos de verificação menores e maiores para reduzir a sobrecarga de E/S.

5) Validar versus seu modelo de CPU

• Escolha um mundo pequeno e regras idênticas.
• Corra Referência da CPU (Logotipo net/Mesa) GPU para um horizonte curto.
• Compare métricas agregadas: contagens, posições médias, tamanhos de clusters ou estatísticas específicas do domínio.
• As diferenças devem estar dentro da variância estocástica para a mesma semente.

Se os resultados divergirem, verifique o raio da mensagem, as condições de limite e a ordem de atualização.

6) Taxa de transferência + referência de custo

Use números importantes para o planejamento.

métricas:
agentes: <N>
etapas: <T>
segundos_parede: < ... >
agent_passos_por_segundo: N*t/wall_seconds
custo_per_million_agent_steps: (preço_por_hora * parede_segundos/3600) /1e6 * (N*T)


Registre o modelo de GPU/VRAM, driver, CUDA, versão da GPU FLAME e a linha de comando exata.

7) Perfis e gargalos

• nvidia-smi: uso do relógio e da VRAM.
• nsys/ncu: identifique núcleos com baixa ocupação ou acesso não coalescente.
• Mensagens: as mensagens espaciais escalam melhor do que todos os pares de força bruta; mantenha os raios realistas.
• Cópias do dispositivo Host ↔: evite transferências por etapa; saídas em lote.
• Ramificação: divide os agentes por estado em funções/camadas separadas quando as ramificações estão quentes.

8) Solução de problemas

GPU ociosa
Poucos agentes ou trabalho pesado do lado do anfitrião. Aumente N, reduza para E/S por etapa ou transfira a configuração para o código do dispositivo.

Fora da memória
Limite as variáveis do agente, fragmente as saídas ou escolha um perfil de VRAM maior.

Resultados não determinísticos
Corrija as sementes e evite reduções não ordenadas do lado do hospedeiro. Documento RNG.

Erros de compilação
Combine CUDA com sua imagem base e cadeia de ferramentas CMake. Limpe e reconstrua.

Trecho de métodos (copiar e colar)

hardware:
gpu: "<model>(<VRAM>GB)”
motorista: “<NVIDIA driver>”
<CUDA version>cuda: “”
software:
<version>flamegpu: “”
imagem: “Ubuntu 24.04 LTS (CUDA 12.6)”
modelo:
domínio: “[0,100] x [0,100]”
agentes: <N>
regras: “demonstração somente de coesão”
executar:
cmd:”. <N><T>/build/abm --agents --steps --seed 42"
pontos de verificação: “a cada 100 etapas”
saídas:
wall_seconds: “<... >”
agent_steps_per_second: “<... >”
cust_per_million_agent_steps: “<... >”


Leitura relacionada

• Modelagem científica em GPUs em nuvem — o que funciona e o que não funciona

Experimentos de computação hoje

Inicie uma instância de GPU com um modelo pronto para CUDA (por exemplo, Ubuntu 24.04 LTS/CUDA 12.6) ou sua própria imagem GROMACS. Aproveite o faturamento flexível por segundo com modelos personalizados e a capacidade de iniciar, interromper e retomar suas sessões a qualquer momento. Não tem certeza sobre os requisitos do FP64? Entre em contato com o suporte para ajudar a selecionar o perfil de hardware ideal para suas necessidades computacionais.