Eu tenho um kernel OpenCL que calcula a força total em uma partícula exercida por outras partículas no sistema e, em seguida, outra que integra a posição / velocidade da partícula. Eu gostaria de paralelizar esses kernels em várias GPUs, basicamente atribuindo uma certa quantidade de partículas a cada GPU. No entanto, eu tenho que rodar este kernel várias vezes, e o resultado de cada GPU é usado em todos os outros. Deixe-me explicar isso um pouco mais:

Digamos que você tenha a partícula 0 na GPU 0 e a partícula 1 na GPU 1. A força na partícula 0 é alterada, assim como a força na partícula 1, e então suas posições e velocidades são alteradas de acordo com o integrador. Então, essas novas posições precisam ser colocadas em cada GPU (ambas as GPUs precisam saber onde a partícula 0 e a partícula 1 estão) e essas novas posições são usadas para calcular as forças em cada partícula na próxima etapa, que é usada pela integrador, cujos resultados são usados ​​para calcular forças, etc, etc.Essencialmente, todos os buffers precisam conter a mesma informação no momento em que os cálculos de força rolam.

Então, a questão é:Qual é a melhor maneira de sincronizar buffers entre GPUs, dado que cada GPU tem um buffer diferente? Eles não podem ter um único buffer compartilhado se eu quiser manter o paralelismo,como por minha última pergunta (embora, se houver uma maneira de criar um buffer compartilhado e ainda manter várias GPUs, sou tudo para isso). Eu suspeito que copiar os resultados em cada etapa cause mais lentidão do que vale a pena paralelizar o algoritmo entre as GPUs.

Eu encontreiesta discussão, mas a resposta não foi muito definitiva e aplicada apenas a um único buffer em todas as GPUs. Eu gostaria de saber, especificamente, para GPUs da Nvidia (mais especificamente, o Tesla M2090).

EDITAR: Na verdade, conformeesta discussão nos fóruns Khronos, um representante do grupo de trabalho OpenCL diz que um único buffer em um contexto compartilhado de fato se espalha por várias GPUs, com cada um garantindo que ele tenha as últimas informações na memória. No entanto, não estou vendo esse comportamento nas GPUs da Nvidia; quando eu usowatch -n .5 nvidia-smi Enquanto meu programa está sendo executado em segundo plano, vejo o uso da memória de uma GPU aumentar por um tempo e, em seguida, diminuía enquanto o uso de memória da outra GPU aumentava. Existe alguém aí que possa me apontar na direção certa com isso? Talvez seja apenas a implementação deles?