让我困惑一段时间的是分配的CUDA记忆的对齐要求。我知道如果它们对齐，访问行元素会更有效率。
首先是一个小背景：
根据CUDA C编程指南（第5.3.2节）：
全局内存驻留在设备内存中，访问设备内存 通过32,64或128字节的内存事务。这些记忆 事务必须自然地对齐，只有32,64或128字节 设备存储器的各个部分与它们的大小对齐（即，它们的大小） 第一个地址是其大小的倍数）可以读取或写入 记忆交易。
我的理解是，对于T类型的2D交错数组，（比如R，G，B顺序的像素值），如果numChannels * sizeof(T)是4,8或16，那么数组如果必须提高性能，则必须使用cudaMallocPitch进行分配。到目前为止，这对我来说一直很好。我在分配2D数组之前检查numChannels * sizeof(T)，如果它是4,16或32，我使用cudaMallocPitch分配它，一切正常。
现在的问题是：
我意识到在使用NVIDIA的NPP库时，有一系列分配器功能（nppiMalloc ...如nppiMalloc_32f_C1等等）。 NVIDIA建议使用这些功能来提高性能。我的问题是，这些功能如何保证对齐？更具体地说，他们使用什么样的数学来为pitch提供合适的值？
对于单通道512x512像素图像（浮点像素值在[0,1]范围内）我同时使用cudaMallocPitch和nppiMalloc_32f_C1。
cudaMallocPitch给了我一个2048的音高值，而nppiMalloc_32f_C1给了我2560.后一个号码来自哪里以及它究竟是什么？
为什么我关心这个
我正在编写一个同步的内存类模板，用于同步GPU和CPU上的值。本课程应该是在引擎盖下分配音调记忆（如果可能的话）。由于我希望这个类可以与NVIDIA的NPP互操作，我想以一种能够为CUDA内核和NPP操作提供良好性能的方式处理所有分配。
我的印象是nppiMalloc正在调用cudaMallocPitch，但似乎我错了。
答案 0 :(得分：3)
一个有趣的问题。但是，由于以下几个原因，可能根本没有确定的答案：这些方法的实施尚未公开。人们不得不假设NVIDIA在内部使用了一些特殊的技巧和调整。此外：结果音高不是指定的。因此，必须假设它可能在多个CUDA / NPP版本之间发生变化。特别是，实际音高不一定取决于执行该方法的设备的硬件版本（＆＃34; 计算能力＆＃34;）。
尽管如此，我对此感到好奇并写下了以下测试：
#include <stdio.h>
#include <npp.h>
template <typename T>
void testStepBytes(const char* name, int elementSize, int numComponents,
T (*allocator)(int, int, int*))
{
printf("%s\n", name);
int dw = 1;
int prevStepBytes = 0;
for (int w=1; w<2050; w+=dw)
{
int stepBytes;
void *p = allocator(w, 1, &stepBytes);
nppiFree(p);
if (stepBytes != prevStepBytes)
{
printf("Stride %5d is used up to w=%5d (%6d bytes)\n",
prevStepBytes, (w-dw), (w-dw)*elementSize*numComponents);
prevStepBytes = stepBytes;
}
}
}
int main(int argc, char *argv[])
{
testStepBytes("nppiMalloc_8u_C1", 1, 1, &nppiMalloc_8u_C1);
testStepBytes("nppiMalloc_8u_C2", 1, 2, &nppiMalloc_8u_C2);
testStepBytes("nppiMalloc_8u_C3", 1, 3, &nppiMalloc_8u_C3);
testStepBytes("nppiMalloc_8u_C4", 1, 4, &nppiMalloc_8u_C4);
testStepBytes("nppiMalloc_16u_C1", 2, 1, &nppiMalloc_16u_C1);
testStepBytes("nppiMalloc_16u_C2", 2, 2, &nppiMalloc_16u_C2);
testStepBytes("nppiMalloc_16u_C3", 2, 3, &nppiMalloc_16u_C3);
testStepBytes("nppiMalloc_16u_C4", 2, 4, &nppiMalloc_16u_C4);
testStepBytes("nppiMalloc_32f_C1", 4, 1, &nppiMalloc_32f_C1);
testStepBytes("nppiMalloc_32f_C2", 4, 2, &nppiMalloc_32f_C2);
testStepBytes("nppiMalloc_32f_C3", 4, 3, &nppiMalloc_32f_C3);
testStepBytes("nppiMalloc_32f_C4", 4, 4, &nppiMalloc_32f_C4);
return 0;
}
音高（stepBytes）似乎完全取决于图像的 width 。因此，该程序为不同类型的图像分配内存，增加宽度，并打印有关导致特定步幅的最大图像大小的信息。目的是得出一种模式或规则 - 即数学类型＆＃34;那你问的问题。
结果......有些令人困惑。例如，对于nppiMalloc_32f_C1电话，在我的机器上（CUDA 6.5，GeForce GTX 560 Ti，计算能力2.1），它打印：
nppiMalloc_32f_C1
Stride 0 is used up to w= 0 ( 0 bytes)
Stride 512 is used up to w= 120 ( 480 bytes)
Stride 1024 is used up to w= 248 ( 992 bytes)
Stride 1536 is used up to w= 384 ( 1536 bytes)
Stride 2048 is used up to w= 504 ( 2016 bytes)
Stride 2560 is used up to w= 640 ( 2560 bytes)
Stride 3072 is used up to w= 768 ( 3072 bytes)
Stride 3584 is used up to w= 896 ( 3584 bytes)
Stride 4096 is used up to w= 1016 ( 4064 bytes)
Stride 4608 is used up to w= 1152 ( 4608 bytes)
Stride 5120 is used up to w= 1280 ( 5120 bytes)
Stride 5632 is used up to w= 1408 ( 5632 bytes)
Stride 6144 is used up to w= 1536 ( 6144 bytes)
Stride 6656 is used up to w= 1664 ( 6656 bytes)
Stride 7168 is used up to w= 1792 ( 7168 bytes)
Stride 7680 is used up to w= 1920 ( 7680 bytes)
Stride 8192 is used up to w= 2040 ( 8160 bytes)
确认对于宽度= 512的图像，它将使用2560的步幅。预期的2048步幅将用于宽度= 504的图像。
数字似乎有点奇怪，所以我为nppiMalloc_8u_C1运行了另一个测试，以覆盖所有可能的图像行大小（以字节为单位），图像尺寸更大，并注意到一个奇怪的模式：第一次增加当图像大于480字节时，发生间距大小（从512到1024），480 = 512-32。当图像大于992字节，并且992 = 480 + 512时，发生下一步（从1024到1536）。当图像大于1536字节，并且1536 = 992 + 512 + 32时，发生下一步（从1536到2048）。从那里开始，它似乎大多数以512的步长运行，除了它们之间的几个大小。进一步的步骤总结如下：
nppiMalloc_8u_C1
Stride 0 is used up to w= 0 ( 0 bytes, delta 0)
Stride 512 is used up to w= 480 ( 480 bytes, delta 480)
Stride 1024 is used up to w= 992 ( 992 bytes, delta 512)
Stride 1536 is used up to w= 1536 ( 1536 bytes, delta 544)
Stride 2048 is used up to w= 2016 ( 2016 bytes, delta 480) \
Stride 2560 is used up to w= 2560 ( 2560 bytes, delta 544) | 4
Stride 3072 is used up to w= 3072 ( 3072 bytes, delta 512) |
Stride 3584 is used up to w= 3584 ( 3584 bytes, delta 512) /
Stride 4096 is used up to w= 4064 ( 4064 bytes, delta 480) \
Stride 4608 is used up to w= 4608 ( 4608 bytes, delta 544) |
Stride 5120 is used up to w= 5120 ( 5120 bytes, delta 512) |
Stride 5632 is used up to w= 5632 ( 5632 bytes, delta 512) | 8
Stride 6144 is used up to w= 6144 ( 6144 bytes, delta 512) |
Stride 6656 is used up to w= 6656 ( 6656 bytes, delta 512) |
Stride 7168 is used up to w= 7168 ( 7168 bytes, delta 512) |
Stride 7680 is used up to w= 7680 ( 7680 bytes, delta 512) /
Stride 8192 is used up to w= 8160 ( 8160 bytes, delta 480) \
Stride 8704 is used up to w= 8704 ( 8704 bytes, delta 544) |
Stride 9216 is used up to w= 9216 ( 9216 bytes, delta 512) |
Stride 9728 is used up to w= 9728 ( 9728 bytes, delta 512) |
Stride 10240 is used up to w= 10240 ( 10240 bytes, delta 512) |
Stride 10752 is used up to w= 10752 ( 10752 bytes, delta 512) |
Stride 11264 is used up to w= 11264 ( 11264 bytes, delta 512) |
Stride 11776 is used up to w= 11776 ( 11776 bytes, delta 512) | 16
Stride 12288 is used up to w= 12288 ( 12288 bytes, delta 512) |
Stride 12800 is used up to w= 12800 ( 12800 bytes, delta 512) |
Stride 13312 is used up to w= 13312 ( 13312 bytes, delta 512) |
Stride 13824 is used up to w= 13824 ( 13824 bytes, delta 512) |
Stride 14336 is used up to w= 14336 ( 14336 bytes, delta 512) |
Stride 14848 is used up to w= 14848 ( 14848 bytes, delta 512) |
Stride 15360 is used up to w= 15360 ( 15360 bytes, delta 512) |
Stride 15872 is used up to w= 15872 ( 15872 bytes, delta 512) /
Stride 16384 is used up to w= 16352 ( 16352 bytes, delta 480) \
Stride 16896 is used up to w= 16896 ( 16896 bytes, delta 544) |
Stride 17408 is used up to w= 17408 ( 17408 bytes, delta 512) |
... ... 32
Stride 31232 is used up to w= 31232 ( 31232 bytes, delta 512) |
Stride 31744 is used up to w= 31744 ( 31744 bytes, delta 512) |
Stride 32256 is used up to w= 32256 ( 32256 bytes, delta 512) /
Stride 32768 is used up to w= 32736 ( 32736 bytes, delta 480) \
Stride 33280 is used up to w= 33280 ( 33280 bytes, delta 544) |
Stride 33792 is used up to w= 33792 ( 33792 bytes, delta 512) |
Stride 34304 is used up to w= 34304 ( 34304 bytes, delta 512) |
... ... 64
Stride 64512 is used up to w= 64512 ( 64512 bytes, delta 512) |
Stride 65024 is used up to w= 65024 ( 65024 bytes, delta 512) /
Stride 65536 is used up to w= 65504 ( 65504 bytes, delta 480) \
Stride 66048 is used up to w= 66048 ( 66048 bytes, delta 544) |
Stride 66560 is used up to w= 66560 ( 66560 bytes, delta 512) |
Stride 67072 is used up to w= 67072 ( 67072 bytes, delta 512) |
.... ... 128
Stride 130048 is used up to w=130048 (130048 bytes, delta 512) |
Stride 130560 is used up to w=130560 (130560 bytes, delta 512) /
Stride 131072 is used up to w=131040 (131040 bytes, delta 480) \
Stride 131584 is used up to w=131584 (131584 bytes, delta 544) |
Stride 132096 is used up to w=132096 (132096 bytes, delta 512) |
... | guess...
显然是模式。节距与512的倍数有关。对于512 * 2 n 的大小，n为整数，大小限制有一些奇数-32和+32偏移会导致更大的音高要使用的。
也许我会对此有另一种看法。我非常确定可以得出一个涵盖这个奇怪的音高进展的公式。但同样：这可能取决于底层的CUDA版本，NPP版本，甚至是所用卡的计算能力。
并且，仅仅为了完整性：可能也是这种奇怪的音高大小只是NPP中的错误的情况。你永远都不会知道。
答案 1 :(得分：0)
我以为我会提供其他几种分配类型的列表。我正在使用带有cuda 7.5版的GTX 860M。
cudaMallocPitch与textureAlignment属性对齐，而不是像我怀疑的那样与texturePitchAlignment对齐。 nppi mallocs也与textureAlignment边界对齐，但有时会过早地分配并跳转到接下来的512个字节。
由于所有这些函数都将每一行与textureAlignment对齐而不是较小的texturePitchAlignment，因此使用了更多的空间，但是纹理应该能够绑定到任何起始行，而不必使用字节偏移量来进行地址计算。文档可能不清楚纹理，但它的结果是它们需要的行间距是32的倍数（在这一代硬件上，texturePitchAlignment属性），起点的地址必须是128的倍数， 256或512取决于硬件和cuda版本（textureAlignment）。纹理可以绑定到一个较小的倍数，在找到正确的属性之前我自己的经验是256字节对齐似乎工作正常。
512字节对齐相当大，但是使用texturePitchAlignment值可能会增加纹理和非纹理的性能。我还没有做过任何测试。为了将来验证，我建议使用cudaMallocPitch或nppiMalloc，但如果内存空间很紧，如果使用纹理，可以使用texturePitchAlignment手动分配。如果您使用的是cudaMemcpy2D或类似功能，则PCI总线上的内存带宽应保持较大的间距。我建议使用Nvidia函数在PCI总线上复制带内存的内存。如果它们尚未高度优化并使用DMA控制器，它们最终将实现它。对于较小的间距，在批量传输中通过PCI总线上的填充进行复制可能更具存储器效率，但这需要在另一侧进行测试和潜在的CPU去填充。我想知道在转移之前Nvidia功能是否会在GPU上解除填充？还是逐行DMA传输？也许最终如果他们还没有。
int main(int argc, char **argv)
{
void *dmem;
int pitch, pitchOld = 0;
size_t pitch2;
int iOld = 0;
int maxAllocation = 5000;
cudaDeviceProp prop;
cudaGetDeviceProperties(&prop, 0);
printf("%s%d%s%d%s", "textureAlignment ", prop.textureAlignment, " texturePitchAlignment ", prop.texturePitchAlignment, "\n");
printf("%s", "cudaMallocPitch\n");
for (int i=0;i<maxAllocation;++i) {
cudaMallocPitch(&dmem, &pitch2, i, 1);
if (pitch2 != pitchOld && i!= 0) {
printf("%s%d%s%d%s%d%s", "width ", iOld, "to", i-1, " -> pitch ", pitchOld, "\n");
pitchOld = pitch2;
iOld = i;
}
cudaFree(dmem);
}
pitchOld = 0;
printf("%s", "nppiMalloc_8u_C1\n");
for (int i=0;i<maxAllocation/sizeof(Npp8u);++i) {
dmem = nppiMalloc_8u_C1(i, 1, &pitch);
if (pitch != pitchOld && i!= 0) {
printf("%s%d%s%d%s%d%s", "width ", iOld, "to", i-1, " -> pitch ", pitchOld, "\n");
pitchOld = pitch;
iOld = i;
}
cudaFree(dmem);
}
pitchOld = 0;
printf("%s", "nppiMalloc_32f_C1\n");
for (int i=0;i<maxAllocation/sizeof(Npp32f);++i) {
dmem = nppiMalloc_32f_C1(i, 1, &pitch);
if (pitch != pitchOld && i!= 0) {
printf("%s%d%s%d%s%d%s", "width ", iOld, "to", i-1, " -> pitch ", pitchOld, "\n");
pitchOld = pitch;
iOld = i;
}
cudaFree(dmem);
}
pitchOld = 0;
return 0;
}
输出
textureAlignment 512 texturePitchAlignment 32
cudaMallocPitch
width 0to0 -> pitch 0
width 1to512 -> pitch 512
width 513to1024 -> pitch 1024
width 1025to1536 -> pitch 1536
width 1537to2048 -> pitch 2048
width 2049to2560 -> pitch 2560
width 2561to3072 -> pitch 3072
width 3073to3584 -> pitch 3584
width 3585to4096 -> pitch 4096
width 4097to4608 -> pitch 4608
nppiMalloc_8u_C1
width 0to0 -> pitch 0
width 1to480 -> pitch 512
width 481to992 -> pitch 1024
width 993to1536 -> pitch 1536
width 1537to2016 -> pitch 2048
width 2017to2560 -> pitch 2560
width 2561to3072 -> pitch 3072
width 3073to3584 -> pitch 3584
width 3585to4064 -> pitch 4096
width 4065to4608 -> pitch 4608
nppiMalloc_32f_C1
width 0to0 -> pitch 0
width 1to120 -> pitch 512
width 121to248 -> pitch 1024
width 249to384 -> pitch 1536
width 385to504 -> pitch 2048
width 505to640 -> pitch 2560
width 641to768 -> pitch 3072
width 769to896 -> pitch 3584
width 897to1016 -> pitch 4096
width 1017to1152 -> pitch 4608