这是关于如何确定CUDA网格，块和线程大小的问题。这是在此处发布的问题的另一个问题。
在此链接之后，来自爪子的答案包含一个代码段（请参见下文）。我不理解“通常是通过调整和硬件限制选择的值”的注释。
我在CUDA文档中找不到很好的解释或说明来解释这一点。总而言之，我的问题是blocksize给定以下代码，如何确定最佳（线程数）：
const int n = 128 * 1024;
int blocksize = 512; // value usually chosen by tuning and hardware constraints
int nblocks = n / nthreads; // value determine by block size and total work
madd<<<nblocks,blocksize>>>mAdd(A,B,C,n);
Answers:
这个答案有两部分（我写了）。一部分易于量化，而另一部分则更具经验。
这是易于量化的部分。当前CUDA编程指南的附录F列出了许多硬性限制，这些硬性限制限制了内核启动每个块可以拥有多少个线程。如果超过以上任何一项，您的内核将永远无法运行。它们可以大致概括为：
如果您在这些限制之内，则可以成功编译的任何内核都将启动而不会出错。
这是经验部分。在上面概述的硬件限制内选择的每个块的线程数可以并且确实会影响在硬件上运行的代码的性能。每种代码的行为方式将有所不同，并且量化它的唯一真实方法是仔细进行基准测试和性能分析。但是，再次非常概括：
第二点是一个巨大的话题，我怀疑有人会尝试将其覆盖在一个StackOverflow答案中。有人在围绕问题的各个方面进行定量分析时撰写博士学位论文（请参阅UC Berkley的Vasily Volkov的本次演讲以及多伦多大学的Henry Hong的本白皮书，以了解问题的真正复杂性示例）。
在入门级，您应该最了解选择的块大小（在上述约束定义的合法块大小范围内）可以而且确实会影响代码的运行速度，但取决于硬件您拥有和正在运行的代码。通过基准测试，您可能会发现大多数非平凡的代码在每个块范围内的128-512个线程中都有一个“甜蜜点”，但是您需要进行一些分析才能找出问题所在。好消息是，因为您要使用的是扭曲大小的倍数，所以搜索空间非常有限，并且相对容易找到给定代码段的最佳配置。
上面的答案指出了块大小如何影响性能，并建议了基于占用率最大化的常见启发式选择。在不希望提供选择块大小的标准的情况下，值得一提的是CUDA 6.5（现在为Release Candidate版本）包括了几个新的运行时函数，以帮助进行占用率计算和启动配置，请参见
有用的功能之一是cudaOccupancyMaxPotentialBlockSize启发式地计算可达到最大占用率的块大小。然后，该功能提供的值可用作启动参数手动优化的起点。下面是一个小例子。
#include <stdio.h>
/************************/
/* TEST KERNEL FUNCTION */
/************************/
__global__ void MyKernel(int *a, int *b, int *c, int N)
{
int idx = threadIdx.x + blockIdx.x * blockDim.x;
if (idx < N) { c[idx] = a[idx] + b[idx]; }
}
/********/
/* MAIN */
/********/
void main()
{
const int N = 1000000;
int blockSize; // The launch configurator returned block size
int minGridSize; // The minimum grid size needed to achieve the maximum occupancy for a full device launch
int gridSize; // The actual grid size needed, based on input size
int* h_vec1 = (int*) malloc(N*sizeof(int));
int* h_vec2 = (int*) malloc(N*sizeof(int));
int* h_vec3 = (int*) malloc(N*sizeof(int));
int* h_vec4 = (int*) malloc(N*sizeof(int));
int* d_vec1; cudaMalloc((void**)&d_vec1, N*sizeof(int));
int* d_vec2; cudaMalloc((void**)&d_vec2, N*sizeof(int));
int* d_vec3; cudaMalloc((void**)&d_vec3, N*sizeof(int));
for (int i=0; i<N; i++) {
h_vec1[i] = 10;
h_vec2[i] = 20;
h_vec4[i] = h_vec1[i] + h_vec2[i];
}
cudaMemcpy(d_vec1, h_vec1, N*sizeof(int), cudaMemcpyHostToDevice);
cudaMemcpy(d_vec2, h_vec2, N*sizeof(int), cudaMemcpyHostToDevice);
float time;
cudaEvent_t start, stop;
cudaEventCreate(&start);
cudaEventCreate(&stop);
cudaEventRecord(start, 0);
cudaOccupancyMaxPotentialBlockSize(&minGridSize, &blockSize, MyKernel, 0, N);
// Round up according to array size
gridSize = (N + blockSize - 1) / blockSize;
cudaEventRecord(stop, 0);
cudaEventSynchronize(stop);
cudaEventElapsedTime(&time, start, stop);
printf("Occupancy calculator elapsed time: %3.3f ms \n", time);
cudaEventRecord(start, 0);
MyKernel<<<gridSize, blockSize>>>(d_vec1, d_vec2, d_vec3, N);
cudaEventRecord(stop, 0);
cudaEventSynchronize(stop);
cudaEventElapsedTime(&time, start, stop);
printf("Kernel elapsed time: %3.3f ms \n", time);
printf("Blocksize %i\n", blockSize);
cudaMemcpy(h_vec3, d_vec3, N*sizeof(int), cudaMemcpyDeviceToHost);
for (int i=0; i<N; i++) {
if (h_vec3[i] != h_vec4[i]) { printf("Error at i = %i! Host = %i; Device = %i\n", i, h_vec4[i], h_vec3[i]); return; };
}
printf("Test passed\n");
}
编辑
的cudaOccupancyMaxPotentialBlockSize被中定义cuda_runtime.h文件，并定义如下：
template<class T>
__inline__ __host__ CUDART_DEVICE cudaError_t cudaOccupancyMaxPotentialBlockSize(
int *minGridSize,
int *blockSize,
T func,
size_t dynamicSMemSize = 0,
int blockSizeLimit = 0)
{
return cudaOccupancyMaxPotentialBlockSizeVariableSMem(minGridSize, blockSize, func, __cudaOccupancyB2DHelper(dynamicSMemSize), blockSizeLimit);
}
参数的含义如下
minGridSize = Suggested min grid size to achieve a full machine launch.
blockSize = Suggested block size to achieve maximum occupancy.
func = Kernel function.
dynamicSMemSize = Size of dynamically allocated shared memory. Of course, it is known at runtime before any kernel launch. The size of the statically allocated shared memory is not needed as it is inferred by the properties of func.
blockSizeLimit = Maximum size for each block. In the case of 1D kernels, it can coincide with the number of input elements.
请注意，从CUDA 6.5开始，需要根据API建议的1D块大小来计算自己的2D / 3D块尺寸。
还要注意，CUDA驱动程序API包含功能上等效的用于占用率计算的API，因此可以按照cuOccupancyMaxPotentialBlockSize上面示例中针对运行时API所示的相同方式在驱动程序API代码中使用。