标签: nvidia

我使用Eclipse作为OpenCL的编辑器,我开启了*.cl文件的语法突出显示,使其行为类似于C++代码.它工作得很好,但我的所有代码都加下划线为语法错误.有没有办法让我的语法突出显示并关闭我的*.cl文件的错误/警告？

为什么我的内核产生奇怪的错误消息或"0"只搜索结果我在SO上发现这个答案,提到在nvidia gpus上运行内核的超时为5秒？我用谷歌搜索结果,但我找不到确认来源或更多信息.

你怎么知道的？

对于运行时间长的内核,timout会导致奇怪的行为吗？

谢谢!

我有两个程序.唯一的区别是一个使用常量内存来存储输入而另一个使用全局内存.我想知道为什么全局内存比常量内存快一个？他们都计算点积btw 2矩阵

#include<cuda_runtime.h>
#include<cuda.h>
#include<stdio.h>
#include<stdlib.h>
#define intMin(a,b) ((a<b)?a:b)
//Threads per block
#define TPB 128
//blocks per grid
#define BPG intMin(128, ((n+TPB-1)/TPB))

const int n = 4;
__constant__ float deva[n],devb[n];
__global__ void addVal( float *c){
    int tid = blockIdx.x * blockDim.x + threadIdx.x;

    //Using shared memory to temporary store results
    __shared__ float cache[TPB];
    float temp = 0;
    while(tid < n){
        temp += deva[tid] * devb[tid];
        tid += gridDim.x * blockDim.x;


    }
    cache[threadIdx.x] = temp;
    __syncthreads();
    int i = blockDim.x/2;
    while( …

我正在研究GPU计算，无法弄清NVIDIA Quadro 6000和NVIDIA Tesla C2075显卡之间的技术/性能差异。它们都具有6GB的RAM和相同数量的计算核心。那有什么区别呢？我想用卡进行CUDA计算。

编辑： 请，如果Nvidia表示卡X可以用于气候计算，卡y可以用于地震处理，那么这仅是PR。没有用于气候计算的图形卡。一张卡既适合单精度或双精度计算，又适合FFT等。这正是我在这里的问题：技术上的区别是什么？对于一张卡相对于另一张卡，我期望获得哪种计算更快的结果？

我刚刚在GPU上实现了一个算法,用于计算数组的连续索引差异.我将其与基于CPU的实现进行了比较,并注意到对于大型阵列,基于GPU的实现执行得更快.

我很好奇为什么基于GPU的实现执行得更快.请注意,我知道GPU有几个核心的表面推理因此可以并行操作,即,不是按顺序访问每个索引,我们可以分配一个线程来计算每个索引的差异.

但有人可以告诉我更深层次的原因,为什么GPU的表现更快.他们的架构有什么不同,他们可以击败基于CPU的实现

我正在尝试编写一个小型演示程序，该程序具有两个正在运行的cuda流，并受事件控制，彼此等待。到目前为止，该程序如下所示：

// event.cu
#include <iostream>
#include <cstdio>
#include <cuda_runtime.h>
#include <cuda.h>

using namespace std;

__global__ void k_A1() { printf("\tHi! I am Kernel A1.\n"); }
__global__ void k_B1() { printf("\tHi! I am Kernel B1.\n"); }
__global__ void k_A2() { printf("\tHi! I am Kernel A2.\n"); }
__global__ void k_B2() { printf("\tHi! I am Kernel B2.\n"); }

int main()
{
  cudaStream_t streamA, streamB;
  cudaEvent_t halfA, halfB;
  cudaStreamCreate(&streamA);
  cudaStreamCreate(&streamB);
  cudaEventCreate(&halfA);
  cudaEventCreate(&halfB);

  cout << "Here is the plan:" << endl <<
    "Stream A: A1, launch …

目标是在另一个文件中调用一个设备函数,当我编译全局内核时,它显示以下错误*不支持外部调用(找到非内联调用_Z6GoldenSectionCUDA)*.

有问题的代码(不是完整的代码,但问题出现的地方),cat norm.h

# ifndef NORM_H_
# define NORM_H_
# include<stdio.h>

__device__ double invcdf(double prob, double mean, double stddev);

#endif

猫norm.cu

# include <norm.h>

__device__ double invcdf(double prob, double mean, double stddev) {
    return (mean + stddev*normcdfinv(prob));
       }

猫test.cu

# include <norm.h>
# include <curand.h>
# include <curand_kernel.h>

__global__ void phase2Kernel(double* out_profit, struct strategyHolder* strategy) {
       curandState seedValue;
       curand_init(threadIdx.x, 0, 0, &seedValue);
       double randomD = invcdf(curand_uniform_double( &seedValue ), 300, 80);
    }

nvcc -c norm.cu -o norm.o …

我在这里遇到了一个非常奇怪的深度测试问题.我在Windows上的OpenGL 3.3核心配置文件上下文中渲染一个简单的网格,启用深度测试并将glDepthFunc设置为GL_LESS.在我的机器上(配备nVidia Geforce GTX 660M的笔记本电脑),一切都按预期工作,深度测试正在运行,这就是它的样子:

现在,如果我在不同的PC上运行程序,一个带有Radeon R9 280的塔,它看起来更像是这样的:

奇怪的是,真正奇怪的是,当我在绘制之前每帧调用glEnable(GL_DEPTH_TEST)时,结果在两台机器上都是正确的.当我这样做时,我认为在两台机器上都正确创建了深度缓冲区,看起来深度测试在渲染之前以某种方式被禁用,当我在初始化时只启用它一次.以下是可能以某种方式成为问题一部分的最小代码:

在创建上下文并使其成为当前之后,在初始化时调用代码:

glEnable(GL_CULL_FACE);
glEnable(GL_DEPTH_TEST);
glDepthFunc(GL_LESS);

代码在缓冲区交换之前调用每个帧:

glClearColor(0.4f, 0.6f, 0.8f, 1.0f);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

// mShaderProgram->getID() simply returns the handle of a simple shader program
glUseProgram(mShaderProgram->getID());  

glm::vec3 myColor = glm::vec3(0.7f, 0.5f, 0.4f);
GLuint colorLocation = glGetUniformLocation(mShaderProgram->getID(), "uColor");
glUniform3fv(colorLocation, 1, glm::value_ptr(myColor));

glm::mat4 modelMatrix = glm::mat4(1.0f);
glm::mat4 viewMatrix = glm::lookAt(glm::vec3(0.0f, 3.0f, 5.0f), glm::vec3(0.0f, 0.0f, 0.0f), glm::vec3(0.0f, 1.0f, 0.0f));
glm::mat4 projectionMatrix = glm::perspectiveFov(60.0f, (float)mWindow->getProperties().width, (float)mWindow->getProperties().height, 1.0f, 100.0f);
glm::mat4 inverseTransposeMVMatrix = glm::inverseTranspose(viewMatrix*modelMatrix);

GLuint mMatrixLocation = glGetUniformLocation(mShaderProgram->getID(), "uModelMatrix"); …

我有一个实时视频流管道,可以对H.264执行RGB32帧编码.我的目标是NVIDIA硬件,因此我计划使用CUDA执行从RGB32到NV12的色彩空间转换.我查找了内核执行类似任务的示例,一切看起来都很好.然而,由于很多人提到数据传输速度是CPU到GPU通信的最关键点,我想知道是否有人有经验,这是将RGB32数据提供给CUDA内核的更好方法:

• 使用cudaMemcpy()(至少这个主题表明它cudaMemcpy()比OS图形堆栈表现更好
• 使用向cuda注册并通过用户空间代码更新的动态Direct3D11资源 Map()

如果有人有这方面的经验,那么我很高兴听到它,否则 - 基准测试是:)

我正在使用基于这篇文章的代码来查看GPU加速,但我能看到的只是减速:

import numpy as np
from timeit import default_timer as timer
from numba import vectorize
import sys

if len(sys.argv) != 3:
    exit("Usage: " + sys.argv[0] + " [cuda|cpu] N(100000-11500000)")


@vectorize(["float32(float32, float32)"], target=sys.argv[1])
def VectorAdd(a, b):
    return a + b

def main():
    N = int(sys.argv[2])
    A = np.ones(N, dtype=np.float32)
    B = np.ones(N, dtype=np.float32)

    start = timer()
    C = VectorAdd(A, B)
    elapsed_time = timer() - start
    #print("C[:5] = " + str(C[:5]))
    #print("C[-5:] = " + str(C[-5:]))
    print("Time: {}".format(elapsed_time))

main()

结果: …