小编Jac*_*ern的帖子

在CUDA程序中,我最近从使用的测试转换为无限性

return x==INFINITY || x==-INFINITY;

其中INFINITY是从math.h中,至

return !isfinite(x);

得到不同的结果,我感到非常惊讶.gnu.org建议他们实际应该表现得相似.我错过了什么吗？是不允许INFINITY在CUDA内核中使用？

编辑: 我刚发现isinf并注意到使用检查

return isinf(x);

给出与INFINITY检查相同的结果.为什么不 isfinite(x)==!isinf(x)呢？

我正在使用CUDA进行图像处理,我对像素处理有疑问.

应用m x m卷积滤波器时,通常使用图像的边界像素做什么？

在3 x 3卷积内核中,忽略1图像的像素边界更容易处理,尤其是在使用共享内存改进代码时.实际上,在这种情况下,不需要检查给定像素是否具有所有可用的(0, 0)邻域(即,在coord处的像素没有离开,左上,上邻居).但是,删除1原始图像的像素边界可能会产生部分结果.

与此相反,我想处理图像中的所有像素,也就是在使用共享内存改进时,即加载16 x 16像素,但计算内部14 x 14.同样在这种情况下,忽略边界像素会产生更清晰的代码.

在这种情况下通常做什么？

是否有人通常使用我的方法忽略边界像素？

当然,我知道答案取决于问题的类型,即以像素方式添加两个图像没有这个问题.

提前致谢.

我需要在之间0.0和1.0使用之间生成一个随机数的向量Thrust.我能找到的唯一记录的例子会产生非常大的随机数(thrust::generate(myvector.begin(), myvector.end(), rand).我确定答案很简单,但我很感激任何建议.

我想通过BS_x读取(BS_X + 1)*(BS_Y + 1)全局存储器位置*BS_Y线程将内容移动到共享存储器,我开发了以下代码.

int i       = threadIdx.x;
int j       = threadIdx.y;
int idx     = blockIdx.x*BLOCK_SIZE_X + threadIdx.x;
int idy     = blockIdx.y*BLOCK_SIZE_Y + threadIdx.y;

int index1  = j*BLOCK_SIZE_Y+i;

int i1      = (index1)%(BLOCK_SIZE_X+1);
int j1      = (index1)/(BLOCK_SIZE_Y+1);

int i2      = (BLOCK_SIZE_X*BLOCK_SIZE_Y+index1)%(BLOCK_SIZE_X+1);
int j2      = (BLOCK_SIZE_X*BLOCK_SIZE_Y+index1)/(BLOCK_SIZE_Y+1);

__shared__ double Ezx_h_shared_ext[BLOCK_SIZE_X+1][BLOCK_SIZE_Y+1];     

Ezx_h_shared_ext[i1][j1]=Ezx_h[(blockIdx.y*BLOCK_SIZE_Y+j1)*xdim+(blockIdx.x*BLOCK_SIZE_X+i1)];

if ((i2<(BLOCK_SIZE_X+1))&&(j2<(BLOCK_SIZE_Y+1))) 
Ezx_h_shared_ext[i2][j2]=Ezx_h[(blockIdx.y*BLOCK_SIZE_Y+j2)*xdim+(blockIdx.x*BLOCK_SIZE_X+i2)];

根据我的理解,合并是顺序处理的连续内存读取的并行等价物.现在如何检测全局内存访问是否已合并？我注意到从(i1,j1)到(i2,j2)的索引跳转.提前致谢.

我正在使用具有计算能力1.3GPU的CUDA实现一个应用程序,该GPU涉及扫描二维数组以寻找发生较小二维数组的位置.到目前为止,两个阵列都是使用cudaMallocPitch()和转移来分配的,cudaMemcpy2D()以满足合并的内存对齐要求.

在第一个优化步骤中,我试图通过共同将数据读取到共享内存来合并对全局内存的内存访问.如在未优化的代码测试(其中,例如,有发散分支和所述存储器访问所述全局存储器不聚结)我使用分配的更大的阵列cudaMalloc(),发现性能达的因子改进50%.这怎么可能？

我是使用GPU进行并行编程的新手,所以如果问题广泛或模糊,我会道歉.我知道CULA库中有一些并行的SVD功能,但是如果我有大量相对较小的矩阵来分解,应该采取什么策略呢？例如,我有n尺寸矩阵d,n大而d小.如何并行化这个过程？谁能给我一个提示？

我正在尝试编写一个函数,它接受一组未分类的键/值对,例如

<7, 4>
<2, 8>
<3, 1>
<2, 2>
<1, 5>
<7, 1>
<3, 8>
<7, 2>

并按键对它们进行排序,同时使用相同的键减少对的值:

<1, 5>
<2, 10>
<3, 9>
<7, 7>

目前,我正在使用__device__类似下面的一个函数,它本质上是一个bitonic排序,它将组合相同键的值并将旧数据设置为一个无限大的值(仅99用于现在),以便后续的bitonic排序将筛选它们到底部并且数组被int *删除的值切割.

__device__ void interBitonicSortReduce(int2 *sdata, int tid, int recordNum, int *removed) {
  int n = MIN(DEFAULT_DIMBLOCK, recordNum);
  for (int k = 2; k <= n; k *= 2) {
    for (int j = k / 2; j > 0; j /= 2) {
      int ixj = tid …

我正在尝试cl从命令行使用Visual Studio 2010编译器.

由于某些原因,我的Visual Studio 2010安装无法正确配置 INCLUDE和LIB目录,请参阅另一篇关于致命错误C1034的帖子:没有包含路径集.如果我跑

`vcvars32.bat`

我收到以下错误消息:

ERROR: Cannot determine the location of the VS Common Tools folder.

然后我尝试手动设置这些环境变量.所以我创建了一个简单的bat文件如下:

Set INCLUDE="C:\Program Files (x86)\Microsoft Visual Studio 10.0\VC\include;C:\Program Files (x86)\Microsoft Visual Studio 10.0\VC\atlmfc\include;C:\Program Files (x86)\Microsoft SDKs\Windows\v7.0A\Include;"

Set LIB="C:\Program Files (x86)\Microsoft Visual Studio 10.0\VC\lib;C:\Program Files (x86)\Microsoft Visual Studio 10.0\VC\atlmfc\lib;C:\Program Files (x86)\Microsoft SDKs\Windows\v7.0A\Lib;"

cl test.cpp

但我现在收到以下错误

LINK : fatal error LNK1104: cannot open file 'libcpmt.lib'

我不明白为什么会发生这种情况,因为libcpmt.lib它位于上述LIB目录中.

任何解决这个问题的方法？

编辑

我在 …

我目前正在使用CUDA编程,我正在尝试从我在网上找到的工作室学习幻灯片,可以在这里找到.我遇到的问题是幻灯片48.可以在那里找到以下代码:

__global__ void stencil_1d(int *in, int *out) {

    __shared__ int temp[BLOCK_SIZE + 2 * RADIUS];

    int gindex = threadIdx.x + blockIdx.x * blockDim.x;
    int lindex = threadIdx.x + RADIUS;

    // Read input elements into shared memory
    temp[lindex] = in[gindex];
    if (threadIdx.x < RADIUS) {
        temp[lindex - RADIUS] = in[gindex - RADIUS];
        temp[lindex + BLOCK_SIZE] = in[gindex + BLOCK_SIZE];
    }

....

添加一些上下文.我们有一个叫做in长度的数组N.然后,我们有另一个out具有长度的数组N+(2*RADIUS),其中RADIUS具有3此特定示例的值.我们的想法是复制阵列in,到数组out …

我正在尝试用CUDA构造一个并行算法,它采用一个整数数组,并删除所有0的有或没有保持顺序.

例:

全局内存:{0,0,0,0,14,0,0,17,0,0,0,0,13}

主机内存结果:{17,13,14,0,0,...}

最简单的方法是使用主机删除0中的O(n)时间.但考虑到我有各种各样的1000元素,在发送之前将GPU上的所有内容保留并首先压缩它可能会更快.

优选的方法是创建设备上堆栈,使得每个线程可以(以任何顺序)弹出和推送到堆栈上或从堆栈中推出.但是,我不认为CUDA有这个实现.

等效(但速度要慢得多)的方法是继续尝试写入,直到所有线程都写完为止:

kernalRemoveSpacing(int * array, int * outArray, int arraySize) {
    if (array[threadId.x] == 0)
        return;

    for (int i = 0; i < arraySize; i++) {

         array = arr[threadId.x];

         __threadfence();

         // If we were the lucky thread we won! 
         // kill the thread and continue re-reincarnated in a different thread
         if (array[i] == arr[threadId.x])
             return;
    }
}

这种方法的好处在于我们会O(f(x))及时执行,其中f(x)是数组中非零值的平均数(f(x) ~= ln(n)对于我的实现,因此是O(ln(n)) …