[英]Cuda, calculate distance matrix between 3d objects
我有一個3D連接的N個對象(原子)的“字符串”(分子)(每個原子都有一個坐標)。 而且我需要計算一個分子中每對原子之間的距離(請參閱下面的偽代碼)。 CUDA怎么做? 我應該傳遞給內核函數2 3D陣列嗎? 還是3個坐標為X [N],Y [N],Z [N]的數組? 謝謝。
結構原子{double x,y,z; }
int main()
{
//N number of atoms in a molecule
double DistanceMatrix[N][N];
double d;
atom Atoms[N];
for (int i = 0; i < N; i ++)
for (int j = 0; j < N; j++)
DistanceMatrix[i][j] = (atoms[i].x -atoms[j].x)*(atoms[i].x -atoms[j].x) +
(atoms[i].y -atoms[j].y)* (atoms[i].y -atoms[j].y) + (atoms[i].z -atoms[j].z)* (atoms[i].z -atoms[j].z;
}
除非您使用非常大的分子,否則可能不會有足夠的工作來保持GPU繁忙,因此使用CPU的計算會更快。
如果要計算歐幾里德距離,則計算不正確。 您需要勾股定理的3D版本。
我將使用SoA來存儲坐標。
您想要生成具有盡可能多的合並讀取和寫入的內存訪問模式。 為此,將每個扭曲中的32個線程生成的地址或索引安排得彼此盡可能近(略有簡化)。
threadIdx
指定塊內的線程索引,而blockIdx
指定網格內的塊索引。 對於扭曲中的所有線程, blockIdx
始終相同。 在塊中的線程中,只有threadIdx
有所不同。 為了可視化如何將threadIdx
的3個維度分配給線程,可以將它們視為嵌套循環,其中x
是內部循環, z
是外部循環。 因此,具有相鄰x
值的線程最有可能在同一扭曲中,並且,如果x
被32整除,則只有共享相同x / 32
值的線程才在同一扭曲中。
我在下面提供了您的算法的完整示例。 在示例中, i
索引是從threadIdx.x
派生的,因此,要檢查扭曲是否會生成合並的讀寫,我將遍歷代碼,同時為i
插入一些連續的值(例如0、1和2)並檢查生成的索引也將是連續的。
從j
索引生成的地址不太重要,因為j
是從threadIdx.y
派生的,因此它在一次扭曲內變化的可能性較小(如果threadIdx.x
被32整除,則永遠不會變化)。
#include "cuda_runtime.h"
#include <iostream>
using namespace std;
const int N(20);
#define check(ans) { _check((ans), __FILE__, __LINE__); }
inline void _check(cudaError_t code, char *file, int line)
{
if (code != cudaSuccess) {
fprintf(stderr,"CUDA Error: %s %s %d\n", cudaGetErrorString(code), file, line);
exit(code);
}
}
int div_up(int a, int b) {
return ((a % b) != 0) ? (a / b + 1) : (a / b);
}
__global__ void calc_distances(double* distances,
double* atoms_x, double* atoms_y, double* atoms_z);
int main(int argc, char **argv)
{
double* atoms_x_h;
check(cudaMallocHost(&atoms_x_h, N * sizeof(double)));
double* atoms_y_h;
check(cudaMallocHost(&atoms_y_h, N * sizeof(double)));
double* atoms_z_h;
check(cudaMallocHost(&atoms_z_h, N * sizeof(double)));
for (int i(0); i < N; ++i) {
atoms_x_h[i] = i;
atoms_y_h[i] = i;
atoms_z_h[i] = i;
}
double* atoms_x_d;
check(cudaMalloc(&atoms_x_d, N * sizeof(double)));
double* atoms_y_d;
check(cudaMalloc(&atoms_y_d, N * sizeof(double)));
double* atoms_z_d;
check(cudaMalloc(&atoms_z_d, N * sizeof(double)));
check(cudaMemcpy(atoms_x_d, atoms_x_h, N * sizeof(double), cudaMemcpyHostToDevice));
check(cudaMemcpy(atoms_y_d, atoms_y_h, N * sizeof(double), cudaMemcpyHostToDevice));
check(cudaMemcpy(atoms_z_d, atoms_z_h, N * sizeof(double), cudaMemcpyHostToDevice));
double* distances_d;
check(cudaMalloc(&distances_d, N * N * sizeof(double)));
const int threads_per_block(256);
dim3 n_blocks(div_up(N, threads_per_block));
calc_distances<<<n_blocks, threads_per_block>>>(distances_d, atoms_x_d, atoms_y_d, atoms_z_d);
check(cudaPeekAtLastError());
check(cudaDeviceSynchronize());
double* distances_h;
check(cudaMallocHost(&distances_h, N * N * sizeof(double)));
check(cudaMemcpy(distances_h, distances_d, N * N * sizeof(double), cudaMemcpyDeviceToHost));
for (int i(0); i < N; ++i) {
for (int j(0); j < N; ++j) {
cout << "(" << i << "," << j << "): " << distances_h[i + N * j] << endl;
}
}
check(cudaFree(distances_d));
check(cudaFreeHost(distances_h));
check(cudaFree(atoms_x_d));
check(cudaFreeHost(atoms_x_h));
check(cudaFree(atoms_y_d));
check(cudaFreeHost(atoms_y_h));
check(cudaFree(atoms_z_d));
check(cudaFreeHost(atoms_z_h));
return 0;
}
__global__ void calc_distances(double* distances,
double* atoms_x, double* atoms_y, double* atoms_z)
{
int i(threadIdx.x + blockIdx.x * blockDim.x);
int j(threadIdx.y + blockIdx.y * blockDim.y);
if (i >= N || j >= N) {
return;
}
distances[i + N * j] =
(atoms_x[i] - atoms_x[j]) * (atoms_x[i] - atoms_x[j]) +
(atoms_y[i] - atoms_y[j]) * (atoms_y[i] - atoms_y[j]) +
(atoms_z[i] - atoms_z[j]) * (atoms_z[i] - atoms_z[j]);
}
聲明:本站的技術帖子網頁,遵循CC BY-SA 4.0協議,如果您需要轉載,請注明本站網址或者原文地址。任何問題請咨詢:yoyou2525@163.com.