我有一个包含"原始"BGRA纹理的缓冲区,每种颜色一个字节.线条顺序相反(纹理颠倒).
BGRA缓冲区全部为绿色(0,255,0,255).
我需要将其转换为RGBA并翻转纹理线.我试过这个:
// bgra is an unsigned char*
int width = 1366;
int height = 768;
unsigned char* rgba = new unsigned char[width * height * 4];
for(int y = height - 1; y >= 0; y--)
{
for(int x = 0; x < width; x++)
{
rgba[(x * y * 4)] = bgra[(x * y * 4) + 2];
rgba[(x * y * 4) + 1] = bgra[(x * y * 4) + 1];
rgba[(x * y * …我想使用cuFFT库提供的批处理方法执行4412D,32-by-32FFT.变换的参数如下:
int n[2] = {32,32};
int inembed[] = {32,32};
int onembed[] = {32,32/2+1};
cufftPlanMany(&plan,2,n,inembed,1,32*32,onembed,1,32*(32/2+1),CUFFT_D2Z,441);
cufftPlanMany(&inverse_plan,2,n,onembed,1,32*32,inembed,1,32*32,CUFFT_Z2D,441);
在使用上述计划进行正向和反向FFT之后,我无法获得原始数据.
任何人都可以建议我如何正确设置cudaPlanMany的参数？提前谢谢了.
顺便说一下,这是cudaPlanMany我用于最佳方式吗？
我有个问题!我需要在cuda c中初始化一个常量全局数组.要初始化数组,我需要使用for!我需要这样做,因为我必须在一些内核中使用这个数组,而我的教授告诉我将其定义为只在设备中可见的常量.
我怎样才能做到这一点？？
我想做这样的事情:
#include <stdio.h>
#include <math.h>
#define N 8
__constant__ double H[N*N];
__global__ void prodotto(double *v, double *w){
int k=threadIdx.x+blockDim.x*blockIdx.x;
w[k]=0;
for(int i=0;i<N;i++) w[k]=w[k]+H[k*N+i]*v[i];
}
int main(){
double v[8]={1, 1, 1, 1, 1, 1, 1, 1};
double *dev_v, *dev_w, *w;
double *host_H;
host_H=(double*)malloc((N*N)*sizeof(double));
cudaMalloc((void**)&dev_v,sizeof(double));
cudaMalloc((void**)&dev_w,sizeof(double));
for(int k=0;k<N;k++){
host_H[2*N*k+2*k]=1/1.414;
host_H[2*N*k+2*k+1]=1/1.414;
host_H[(2*k+1)*N+2*k]=1/1.414;
host_H[(2*k+1)+2*k+1]=-1/1.414;
}
cudaMemcpyToSymbol(H, host_H, (N*N)*sizeof(double));
cudaMemcpy(dev_v, v, N*sizeof(double), cudaMemcpyHostToDevice);
cudaMemcpy(dev_w, w, N*sizeof(double), cudaMemcpyHostToDevice);
prodotto<<<1,N>>>(dev_v, dev_w);
cudaMemcpy(v, dev_v, N*sizeof(double), cudaMemcpyDeviceToHost);
cudaMemcpy(w, dev_w, N*sizeof(double), cudaMemcpyDeviceToHost);
for(int i=0;i<N;i++) printf("\n%f %f", v[i], …我正在Cuda开发一些简单的程序,我想知道哪个线程正在执行GPU的哪个核心.我正在使用Visual Studio 2012,我有一块NVIDIA GeForce 610M显卡.
是否有可能这样做...我已经在谷歌搜索了很多但都是徒劳的.
编辑:
我知道这真的很奇怪,但我的大学项目指南要求我这样做.
我的问题是在开始执行内核后，在CUDA（特别是开普勒或较新的nvidia体系结构）中调度线程块。
根据我对开普勒架构的理解（可能不正确），可以随时将单个SM调度的活动块的数量受到限制（如果我没记错的话，可以分配16个块）。同样，据我了解，一旦将块计划在特定的SM上运行，它们就无法移动。
我很好奇的是，在最初选择块并开始在设备上执行之后，块调度和执行行为（假设内核具有的线程块多于所有SM中的活动块）。
SM中当前运行的单个活动块完成后是否立即执行新块？还是仅在SM完成其所有当前活动块后才执行下一组块？还是仅在所有SM完成所有当前活动的块执行后才启动它们？
另外，我听说块调度已“固定”到单个SM。我假设仅在块变为活动状态后才将其固定为单个SM。是这样吗
我有一个模拟计算在电场和磁场中移动的带电粒子的3D矢量. 我尝试使用说明__align__符在CUDA中加速这一点,认为可能限制因素是全局内存读取和写入,但使用__align__最终减慢它(可能是因为它增加了总内存需求).我也试过使用float3,float4但他们的表现相似
我已经创建了此代码的简化版本并将其粘贴在下面以显示我的问题. 下面的代码应该是可编译并通过改变的定义CASE在第四行至0,1或2,可以尝试我上述不同的选项. 两个函数,ParticleMoverCPU并且ParticleMoverGPU被定义为比较CPU VS GPU性能.
谢谢!
CPU - Intel Xeon E5620 @ 2.40GHz
GPU - NVIDIA Tesla C2070
// CASE 0: Regular struct with 3 floats
// CASE 1: Aligned struct using __align__(16) with 3 floats
// CASE 2: float3
#define CASE 0 // define to either 0, 1 or 2 as described …我使用cuda 7.5版cufft来执行一些FFT和逆FFT.使用cufftExecC2R(.,.)函数执行逆FFT时出现问题.
实际上,当我使用a batch_size = 1时,cufftPlan1d(,)我得到了正确的结果.但是,当我增加批量大小时,结果不正确.
我粘贴一个示例最小代码来说明这一点.我会快速创建它,请忽略代码的肮脏.
#include <cufft.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <math.h>
#include <ctime>
#include <iostream>
typedef float2 Complex;
void iTest(int argc, char** argv);
#define SIGNAL_SIZE 9
#define BATCH_SIZE 2
int main(int argc, char** argv) {
iTest(argc, argv);
return 0;
}
void iProcess(Complex *x, double *y, size_t n) {
cufftComplex *deviceData;
cudaMalloc(reinterpret_cast<void**>(&deviceData),
SIGNAL_SIZE * BATCH_SIZE * sizeof(cufftComplex));
cudaMemcpy(deviceData, x, SIGNAL_SIZE * sizeof(cufftComplex) * BATCH_SIZE,
cudaMemcpyHostToDevice);
cufftResult cufftStatus;
cufftHandle …我正在尝试拦截来自 pytorch 库的 cudaMemcpy 调用以进行分析。我注意到 NVIDIA 在 CUDA 工具包示例中有一个 cuHook 示例。然而，该示例需要修改应用程序本身的源代码，在这种情况下我无法做到这一点。那么有没有一种方法可以在不修改应用程序源代码的情况下编写一个钩子来拦截CUDA调用呢？
我目前正在尝试在我的 GPU 上使用 CUBLAS 实现矩阵乘法。
它适用于方阵和某些大小的输入，但对于其他人，最后一行不会返回（并且包含 0，因为这是我实现它的方式）。
我认为这是 的分配或语法问题cublasSgemm，但我找不到它的位置。
注意：如果您不熟悉 CUBLAS：它是column-majored，这就是为什么看起来操作以另一种方式执行的原因。
任何帮助，将不胜感激。
请注意，gpuErrchk和cublasErrchk在这里当然无关紧要。
#include <cuda.h>
#include <cuda_runtime.h>
#include <cublas_v2.h>
#include <vector>
std::vector<float> CUDA_mult_MAT(const std::vector<float> &data_1 , const uint64_t data_1_rows, const uint64_t data_1_columns,
const std::vector<float> &data_2 , const uint64_t data_2_rows, const uint64_t data_2_columns){
cublasHandle_t handle;
cublasErrchk(cublasCreate(&handle));
std::vector<float> result(data_1_rows * data_2_columns); //Vector holding the result of the multiplication
/*----------------------------------------------------------------------------------------------*/
float* GPU_data_1 = NULL;
gpuErrchk(cudaMalloc((void**)&GPU_data_1 , data_1.size()*sizeof(float))); //Allocate memory on the GPU
gpuErrchk(cudaMemcpy(GPU_data_1, …我试图获取cuFFT库调用的分析数据,例如plan和exec.我正在使用nvprof(命令行分析工具),选项为"--print-api-trace".除了cuFFT apis之外,它打印所有api的时间.是否需要更改任何标志以获取cuFFT分析数据？或者我需要使用事件并测量自己？
我想在cuda中重复一个向量来形成一个矩阵，避免太多的memcopy。向量和矩阵都在 GPU 上分配。
例如：
我有一个向量：
a = [1 2 3 4]
将其展开为矩阵：
b = [1 2 3 4;
1 2 3 4;
.......
1 2 3 4]
我尝试过的是分配 b 的每个元素。但这涉及到大量的 GPU 内存到 GPU 内存的复制。
我知道这在 matlab 中很容易（使用 repmat），但是如何在 cuda 中有效地做到这一点？我没有在 cublas 中找到任何常规。
我使用copy_if以下方法在两个推力设备阵列之间有选择地复制项目：
thrust::device_vector<float4> collated = thrust::device_vector<float4>
original_vec.size());
thrust::copy_if(original_vec.begin(), original_vec.end(),
collated.begin(), is_valid_pt());
collated.shrink_to_fit();
的is_valid_pt实现为：
struct is_valid_kpt
{
__host__ __device__ bool operator()(const float4 x)
{
return x.w >= 0;
}
};
现在，运行此代码后，我期望collated向量的大小比原始数组小得多，但它们的大小仍然相同。
如何在JSFiddle中为不支持ES6的浏览器（如IE）启用ES6？