小编Jac*_*ern的帖子

我正在测试svd,Matlab R2014a似乎没有CPUvs GPU加速.我正在使用一张GTX 460卡片和一张卡片Core 2 duo E8500.

这是我的代码:

%test SVD
n=10000;
%host
Mh= rand(n,1000);
tic
%[Uh,Sh,Vh]= svd(Mh);
svd(Mh);
toc
%device
Md = gpuArray.rand(n,1000);
tic
%[Ud,Sd,Vd]= svd(Md);
svd(Md);
toc

此外,运行时间与运行不同,但CPU和GPU版本大致相同.为什么没有加速？

这是一些测试

for i=1:10
    clear;
    m= 10000;
    n= 100;
    %host
    Mh= rand(m,n);
    tic
    [Uh,Sh,Vh]= svd(Mh);
    toc
    %device
    Md = gpuArray.rand(m,n);
    tic
    [Ud,Sd,Vd]= svd(Md);
    toc
end

>> test_gpu_svd
Elapsed time is 43.124130 seconds.
Elapsed time is 43.842277 seconds. …

我目前正在开发一个带有CUDA功能的mex文件,用于MATLAB.当我做错事(例如错误的指针或类似的东西)时,MATLAB总是崩溃(窗口提示我结束,发送报告进行数学运算或尝试继续).有没有办法防止这种情况发生？这样开发真的很烦人,但你可能知道自己:几乎没有人可以在没有"试错"的情况下编写完美的代码......到目前为止,谢谢!

我有3相同大小的数组(超过300.000元素).一个浮点数和两个索引数组.所以,对于每个号码我都有2ID.

所有3阵列都已经在GPU全局内存中.我想相应地将所有数字与他们的ID排序.

有什么方法可以使用Thrust库来完成这项任务吗？有没有比推力图书馆更好的方法？

当然,我不喜欢将它们复制到主机内存中几次.顺便说一句,他们的数组不是向量.

感谢您的帮助.

暂时的解决方案,但这是非常缓慢的.它需要几4秒钟,我的数组大小按顺序排列300000

thrust::device_ptr<float> keys(afterSum);
thrust::device_ptr<int> vals0(d_index);
thrust::device_ptr<int> vals1(blockId); 

thrust::device_vector<int> sortedIndex(numElements);
thrust::device_vector<int> sortedBlockId(numElements);

thrust::counting_iterator<int> iter(0);
thrust::device_vector<int> indices(numElements);
thrust::copy(iter, iter + indices.size(), indices.begin()); 

thrust::sort_by_key(keys, keys + numElements , indices.begin());    

thrust::gather(indices.begin(), indices.end(), vals0, sortedIndex.begin());
thrust::gather(indices.begin(), indices.end(), vals1, sortedBlockId.begin());

thrust::host_vector<int> h_sortedIndex=sortedIndex;
thrust::host_vector<int> h_sortedBlockId=sortedBlockId;

我将把我的第一个相对较大的CUDA项目编码为Gradient Descent Optimization,用于机器学习目的.我希望从群众智慧中获益,了解CUDA的一些有用的本机功能,这些功能可能是项目中使用的捷径.有什么想法/建议吗？

我正在尝试使用流异步启动多个CUDA FFT内核.为此,我正在创建我的流,cuFFT前向和反向计划如下:

streams = (cudaStream_t*) malloc(sizeof(cudaStream_t)*streamNum);
plansF = (cufftHandle *) malloc(sizeof(cufftHandle)*streamNum);
plansI = (cufftHandle *) malloc(sizeof(cufftHandle)*streamNum);
for(int i=0; i<streamNum; i++)  
{
    cudaStreamCreate(&streams[i]);
    CHECK_ERROR(5)
    cufftPlan1d(&plansF[i], ticks, CUFFT_R2C,1);
    CHECK_ERROR(5)
    cufftPlan1d(&plansI[i], ticks, CUFFT_C2R,1);
    CHECK_ERROR(5)
    cufftSetStream(plansF[i],streams[i]);
    CHECK_ERROR(5)
    cufftSetStream(plansI[i],streams[i]);
    CHECK_ERROR(5)
}

在main函数中,我正在启动正向FFT,如下所示:

for(w=1;w<q;w++)
  {
    cufftExecR2C(plansF[w], gpuMem1+k,gpuMem2+j);
    CHECK_ERROR(8)
    k += rect_small_real;
    j += rect_small_complex;
  }

我还有其他内核,我使用相同的流异步启动.

当我使用Visual Profiler 5.0分析我的应用程序时,我发现除了CUDA FFT(正向和反向)之外的所有内核并行运行并重叠.FFT内核确实在不同的流中运行,但它们不重叠,因为它们实际上是顺序运行的.谁能告诉我我的问题是什么？

我的环境是VS 2008,64位,Windows 7.

谢谢.

NVIDIA GPU是否支持无序执行？

我的第一个猜测是它们不包含如此昂贵的硬件.但是,在阅读时CUDA progamming guide,指南建议使用指令级并行(ILP)来提高性能.

ILP不是支持乱序执行的硬件可以利用的功能吗？或者NVIDIA的ILP仅仅意味着编译器级别的指令重新排序,因此它的顺序在运行时仍然是固定的.换句话说,只是编译器和/或程序员必须以这样的方式安排指令的顺序,即通过按顺序执行可以在运行时实现ILP？

我知道Amdahl定律和并行程序的最大加速.但我无法正确研究古斯塔夫森定律.什么是Gustafson定律,Amdahl和Gustafson定律之间有什么区别？

假设我有一个x(n)很K * N长的序列,只有第一个N元素与零不同.我假设,N << K例如,N = 10和K = 100000.我想通过FFTW计算这种序列的FFT.这相当于具有一系列长度N并且具有零填充K * N.由于N并且K可能是"大",我有一个显着的零填充.我正在探索是否可以节省一些计算时间,避免显式零填充.

案子 K = 2

让我们从考虑案例开始K = 2.在这种情况下,DFT x(n)可以写成

如果k是偶数k = 2 * m,那么

这意味着DFT的这些值可以通过长度序列的FFT来计算N,而不是K * N.

如果k是奇数k = 2 * m + 1,那么

这意味着可以通过长度序列的FFT再次计算DFT的这种值N,而不是K * N.

因此,总之,我可以用长度2 * N …

这是我在GT 440上的内核的Compute Visual Profiler的输出:

• 内核详细信息:网格大小:[100 1 1],块大小:[256 1 1]
• 寄存器比率:0.84375(27648/32768)[每个线程35个寄存器]
• 共享内存比率:0.336914(16560/49152)[每块5520字节]
• 每SM的活动块数:3(每个SM的最大活动块数:8)
• 每个SM的活动线程数:768(每个SM的最大活动线程数:1536)
• 潜在占用率:0.5(24/48)
• 占用限制因素:登记

请注意标记为粗体的子弹.内核执行时间是121195 us.

我通过将一些局部变量移动到共享内存来减少每个线程的一些寄存器.Compute Visual Profiler输出变为:

• 内核详细信息:网格大小:[100 1 1],块大小:[256 1 1]
• 寄存器比率:1(32768/32768)[每个线程30个寄存器]
• 共享内存比率:0.451823(22208/49152)[每块5552字节]
• 每SM的活动块数:4(每个SM的最大活动块数:8)
• 每个SM的活动线程数:1024(每个SM的最大活动线程数:1536)
• 潜在入住率:0.666667(32/48)
• 占用限制因素:登记

因此,现在4块在单个SM上与3先前版本中的块同时执行.但是,执行时间115756 us几乎相同!为什么？是不是完全独立的块在不同的CUDA核心上执行？

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

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