相关疑难解决方法(0)

我是CUDA的新手,需要帮助了解一些事情.我需要帮助并行化这两个for循环.具体来说,如何设置dimBlock和dimGrid以使其运行更快.我知道这看起来像sdk中的向量添加示例,但该示例仅适用于方形矩阵,当我尝试修改我的128 x 1024矩阵的代码时,它无法正常工作.

__global__ void mAdd(float* A, float* B, float* C)
{
    for(int i = 0; i < 128; i++)
    {
        for(int i = 0; i < 1024; i++)
        {
            C[i * 1024 + j] = A[i * 1024 + j] + B[i * 1024 + j];
        }
    }
}

这段代码是一个更大的循环的一部分,是代码中最简单的部分,所以我决定尝试并行化thia并同时学习CUDA.我已经阅读了指南,但仍然不明白如何获得正确的号码.网格/块/线程的运行并有效地使用它们.

我需要帮助才能知道我的块和网格的大小.我正在构建一个python应用程序来执行基于scipy的度量计算:Euclidean distance,Manhattan,Pearson,Cosine,加入其他.

该项目是PycudaDistances(https://github.com/vinigracindo/pycudaDistances).

它似乎与小数组一起工作得很好.当我进行更详尽的测试时,不幸的是它没有用.我下载了movielens set(http://www.grouplens.org/node/73).

使用Movielens 100k,我声明了一个有形状的数组(943,1682).也就是说,用户评价了943和1682部电影.不是分类器用户的电影我将值配置为0.

使用更大的阵列算法不再有效.我遇到以下错误:pycuda._driver.LogicError:cuFuncSetBlockShape失败:值无效.

研究这个错误,我找到了一个解释,告诉安德鲁支持512个线程加入和使用更大的块,有必要使用块和网格.

我想要一个帮助,使算法欧几里德距离数组适应从小型到巨型阵列的工作.

def euclidean_distances(X, Y=None, inverse=True):
    X, Y = check_pairwise_arrays(X,Y)
    rows = X.shape[0]
    cols = Y.shape[0]
    solution = numpy.zeros((rows, cols))
    solution = solution.astype(numpy.float32)

    kernel_code_template = """
    #include <math.h>

    __global__ void euclidean(float *x, float *y, float *solution) {

        int idx = threadIdx.x + blockDim.x * blockIdx.x;
        int idy = threadIdx.y + blockDim.y * blockIdx.y;

        float result = 0.0;

        for(int iter = 0; iter < %(NDIM)s; iter++) {

            float x_e = x[%(NDIM)s * idy …

首先我要说的是,我仔细阅读了关于SO的所有类似问题:

1. 确定每个块的线程数和每个网格块数
2. 每个SM的线程数,每个块的线程数
3. CUDA块和线程
4. 变形和最佳块数

我的目的是尝试动态计算(而不是硬编码值)我正在开发的前馈神经网络库.

我的数据不是正方形点阵(矩阵),正如我所看到的大多数例子一样,而是两个向量产生矩阵,行到行的行数不等:

float x[6] {1.f, 1.f, 0.f, 1.f, 1.f, 0.f}; 
thrust::device_vector<float> in_vec( x, x+6 );
float y[9] {1.f, 1.f, 1.f, 1.f, 1.f, 1.f, 1.f, 1.f, 1.f};
thrust::device_vector<float> w_vec( y, y+9 );
thrust::device_vector<float> o_wec(9);
thrust::device_vector<float> mtx_vec( 9 * 6 );

float * i_ptr = thrust::raw_pointer_cast( in_vec.data() );
float * w_ptr = thrust::raw_pointer_cast( w_vec.data() );
float * out_ptr = thrust::raw_pointer_cast( mtx_vec.data() );

dim3 threadsPerBlock(9,6);
dim3 numBlocks(1,1);
prop_mtx<<<numBlocks,threadsPerBlock>>>( w_ptr, i_ptr, out_ptr, 6 );

和内核:

__global__ void …

我有GTX560。我今天买了GTX760。为什么下面的内核在 GTX760 上（~0.031ms）比 GTX560（~0.0232ms）慢。当我将 n 增加到 1000000 时，速度更快（约 25%），但对于较小的 n 则不然。我有两台电脑。第一个（内置 GTX560）是 Intel(R) Core(TM) i5 CPU、P7P55D-E LX、CUDA 5.0、Kubuntu 12.04。第二个（GTX760内），AMD FX(tm)-6300，主板760GA-P43(FX)，CUDA 6.5 Kubuntu 14.04。但我仍然认为，原因不是由于不同的CPU等......

GTX560: nvcc -arch=sm_20 -fmad=false -O3 -o vecc vecc.cu -lm
GTX760: nvcc -arch=sm_30 -fmad=false -O3 -o vecc vecc.cu -lm

我也尝试改变块大小，但没有根本效果。

#include <stdio.h>
#include <stdlib.h>
#include <math.h>

// CUDA kernel. Each thread takes care of one element of c
__global__ void vecAdd(double *a, double *b, double *c, int n)
{
 // Get our global thread ID
 int id = …

亲爱的反对者：请告诉我反对票的原因。我已经接受了一个答案，这意味着该人能够理解问题并且不需要最小的工作示例。其次，我希望它是一个概念问题，而不是一个家庭作业问题。请告诉我您投反对票的原因。

重要提示：我已经阅读了几个关于线程和块的分布的线程（例如this ），但我有一个特定的查询。

我必须unsigned char在 GPU 上处理形式的图像数据。我的图像大小(1080 x 1920)为 3 个通道，每个像素都是unsigned char类型。

GPU详细信息：

NVIDIA Quadro k2000
2 GB of GDDR5 GPU memory
384 5MX CUDA parallel processing cores

由于我是 GPU 处理新手，因此我无法了解在这种特定情况下我的 GPU 卡的每个块的线程数和块分布总数。

问题：当我对图像使用以下配置(1080 x 1920)来调用 GPU 内核时，我得到了所需的结果，但计算时间太多

dim3 numOfBlocks( (108) , (192) ); 
dim3 numOfThreadsPerBlocks( 3*10 , 3*10 ); //multiplied by 3 because we have 3 channel image now

colorTransformation_kernel<<<numOfBlocks, numOfThreadsPerBlocks>>>(numChannels, step_size, iw, …

我的Cuda程序获得了显着的性能提升(平均),具体取决于块的大小和块数; 其中"线程"的总数保持不变.(我不确定线程​​是否是正确的术语......但我将在这里使用它;每个内核的总线程数是(块数)*(块大小)).我制作了一些图表来说明我的观点.

但首先让我先解释一下我的算法是什么,但我不确定它是多么相关,因为我认为这适用于所有GPGPU程序.但也许我错了.

基本上我会遇到逻辑上被视为2D数组的大型数组,其中每个线程从数组中添加一个元素,并将该值的平方添加到另一个变量,然后在最后将值写入另一个数组,其中每个读取所有线程都以某种方式移位.这是我的内核代码:

__global__ void MoveoutAndStackCuda(const float* __restrict__ prestackTraces, float* __restrict__ stackTracesOut,
  float* __restrict__ powerTracesOut, const int* __restrict__ sampleShift,
  const unsigned int samplesPerT, const unsigned int readIns,
  const unsigned int readWidth, const unsigned int defaultOffset) {

  unsigned int globalId = ((blockIdx.x * blockDim.x) + threadIdx.x); // Global ID of this thread, starting from 0 to total # of threads

  unsigned int jobNum = (globalId / readWidth); // Which array within the overall program this thread works on …

我刚刚在CUDA中学习了流技术，并尝试了它。然而，不希望的结果返回，即，流不是并行的。（在GPU Tesla M6，OS Red Hat Enterprise Linux 8上）

我有一个大小为（5,2048）的数据矩阵，还有一个处理矩阵的内核。

我的计划是分解“ nStreams = 4”扇区中的数据，并使用4个流来并行执行内核。

我的部分代码如下所示：

int rows = 5;
int cols = 2048;

int blockSize = 32;
int gridSize = (rows*cols) / blockSize;
dim3 block(blockSize);
dim3 grid(gridSize);

int nStreams = 4;    // preparation for streams
cudaStream_t *streams = (cudaStream_t *)malloc(nStreams * sizeof(cudaStream_t));
for(int ii=0;ii<nStreams;ii++){
    checkCudaErrors(cudaStreamCreate(&streams[ii]));
}

int streamSize = rows * cols / nStreams;
dim3 streamGrid = streamSize/blockSize;

for(int jj=0;jj<nStreams;jj++){
    int offset = jj * streamSize;
    Mykernel<<<streamGrid,block,0,streams[jj]>>>(&d_Data[offset],streamSize);
}    // d_Data is …