小编ein*_*ica的帖子

Nvidia CUDA驱动程序究竟做了什么？从使用CUDA的角度来看.驱动程序传递内核代码,执行配置(#threads,#blockss)......还有什么？

我看到一些帖子,驱动程序应该知道可用SM的数量.但这不是不必要的吗？一旦内核传递给GPU,GPU调度程序只需要将工作分散到可用的SM ......

我正在尝试用CUDA 2.0(NVIDIA 590)处理一系列大型结构.我想为它使用共享内存.我已经尝试了CUDA占用计算器,尝试为每个线程分配最大共享内存,以便每个线程可以处理整个数组元素.但是,我在100%多处理器加载的计算器中可以看到的最大值(每块的共享内存)/(每块的线程数)是32字节,这对于单个元素(在数量级上)是不够的.32个字节是(每个块的共享内存)/(每个块的线程数)的最大可能值吗？是否可以说哪个alter4native更可取 - 在全局内存中分配数组的一部分还是只使用欠载的多处理器？或者它只能通过实验来决定？我能看到的另一个替代方案是在几个过程中处理数组,但它看起来像是最后的手段.这是我第一次尝试与CUDA非常复杂的东西,所以我可能会错过其他一些选择......

我在我的cuda程序中添加了一些printf语句

__device__ __global__ void Kernel(float *, float * ,int );
void DeviceFunc(float *temp_h , int numvar , float *temp1_h)
{ .....
    //Kernel call
    printf("calling kernel\n");
    Kernel<<<dimGrid , dimBlock>>>(a_d , b_d , numvar);
    printf("kernel called\n");
  ....
}

int main(int argc , char **argv)
{   ....
    printf("beforeDeviceFunc\n\n");
    DeviceFunc(a_h , numvar , b_h); //Showing the data
    printf("after DeviceFunc\n\n");
    ....
}

同样在Kernel.cu中,我写道:

#include<cuda.h>
#include <stdio.h>
__device__ __global__ void Kernel(float *a_d , float *b_d ,int size)
{
    int idx = threadIdx.x ;
    int idy = …

用C告诉我的电脑

printf("%d",(int)-1);

我确实希望,并且通常也得到'-1'响应.但是,在我的基于Ubuntu的Cuda 5.0上使用的特斯拉M2090 Nvidia卡这个无辜的演示程序

/** cheese.cu */
#include <iostream>
#include <cuda.h>
#include <cstdio>

using namespace std;

template<typename T> struct SpacePtr
  { size_t size; T* ptr; };

 __global__ void f(SpacePtr<int>* sp)
{
  printf("This _is_ a 'minus one' or ain't it: %d\n",(int)-1);
  // Note: All appears to work fine with %lu instead of %zd
  // Still: How does the size value affect the -1?
  printf("On DEV: Size: %zd, Minus One: %d\n",sp->size,(int)-1);
}

int main()
{
  SpacePtr<int> data; data.ptr = 0; data.size …

我一直在使用LinkedBlockingQueue,最近ArrayBlockingQueue由于插入性能缓慢而改变了这一点.之后我获得了显着的性能提升.但是,我的代码有时会抛出一个内存不足的错误:

我的Java代码

ArrayBlockingQueue<String> s = new ArrayBlockingQueue<String>(Integer.MAX_VALUE);

我查看了ArrayBlockingQueue源代码.真的,我感到震惊 - 它object[]为给定的初始容量分配了一个.这是内存不足错误的原因.

ArrayBlockingQueue源代码

public ArrayBlockingQueue(int capacity, boolean fair) {
    if (capacity <= 0)
        throw new IllegalArgumentException();
    this.items = (E[]) new Object[capacity];
    lock = new ReentrantLock(fair);
    notEmpty = lock.newCondition();
    notFull =  lock.newCondition();
}

这不会猜测初始容量或创建具有最小容量的队列.因为它会在高峰时间和正常时间变化.如果我提供最小容量,队列将在高峰时段立即填写.如果我给出最大容量,我会得到一个内存不足的错误,我不想在插入元素之前分配一个对象[].

请建议任何替代方案.

在具有 4 个 NVIDIA GPU 的节点上，我在设备 0 上启用了 ECC 内存保护（所有其他都禁用了 ECC）。由于我在设备 0 上启用了 ECC，我的应用程序（CUDA，仅使用一个设备）在尝试在此设备 0（驱动程序 API）上创建上下文时挂起。我不知道为什么它在那一刻挂起。如果我根据另一台设备使用不同的设备设置 CUDA_VISIBLE_DEVICE 它工作正常。它必须与启用 ECC 有关。有什么想法吗？这里的输出nvidia-smi：（为什么它报告 99% 不稳定的 GPU 利用率，那里什么都没有运行？）

+------------------------------------------------------+                       
| NVIDIA-SMI 4.304.54   Driver Version: 304.54         |                       
|-------------------------------+----------------------+----------------------+
| GPU  Name                     | Bus-Id        Disp.  | Volatile Uncorr. ECC |
| Fan  Temp  Perf  Pwr:Usage/Cap| Memory-Usage         | GPU-Util  Compute M. |
|===============================+======================+======================|
|   0  Tesla K20m               | 0000:02:00.0     Off |                    1 |
| N/A   29C    P0    49W / 225W |   0%   12MB / 4799MB …

我在一个Iterator实例中有一个生成器,它next()在迭代器上每次生成并返回一个项目.它似乎有点工作,但我得到了null返回的价值.

班级代码:

package spiral;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;
import java.util.List;
import java.util.logging.Level;
import java.util.logging.Logger;

/**
 *
 * @author student
 */
public class Spiral7DGenerator implements Iterator<List<Integer>> {
    private boolean releaseNext = false;
    private List<Integer> releaseList;

    public Spiral7DGenerator() {
        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int t = 0; true; t++) {
                    loops(t);
                }
            }
        }).start();
    }

    @Override
    public boolean hasNext() {
        return true;
    }

    @Override
    public List<Integer> next() { …

我在OpenCL内核中使用以下宏:

#define ided_printf(_format, ...) printf("(%u,%u,%u) " _format, get_global_id(0), get_group_id(0), get_local_id(0), __VA_ARGS__ )

它工作正常.但是,当我编译它时(我在Win7上使用AMD的APP OpenCL库),每次使用宏时都会收到以下警告:

argument of type "const __constant char *" is incompatible with parameter of type "__constant char *"

我为什么要这样做？毕竟,字符串文字是常量.即使OpenCL编译器没有使它们成为const,为什么"(%u,%u,%u)"字符串是const'ed而另一个字符串(_format)没有被释放？

我假设这是一个编译器错误; 如果是的话,我们将不胜感激.也许是某种演员？

在 CUDA 中，流 0 与其他流有何关系？流 0（默认流）是否与上下文中的其他流同时执行？

考虑以下示例：

cudaMemcpy(Dst, Src, sizeof(float)*datasize, cudaMemcpyHostToDevice);//stream 0;

cudaStream_t stream1;

/...creating stream1.../

somekernel<<<blocks, threads, 0, stream1>>>(Dst);//stream 1;

在上面的代码中，编译器能否确保始终在完成后somekernel启动或与 并发执行？ cudaMemcpysomekernelcudaMemcpy