小编Jac*_*ern的帖子

我将代码片段分成了一个,DLL因为它会经常更新,这样就可以更容易部署.

但我对我能做什么以及我不能做什么有疑问DLL.

1. 我可以通过一个std:string或CString一个DLL？
2. 我可以将指针传递给structwith std::string members并将其填入DLL？
3. 可以DLL返回指向那里分配的结构的指针吗？它会有效吗？我可以删除吗？
4. 什么应该更好地通过,a std::String或a Cstring？

谢谢 !

我正在使用CUDA,我已经创建了一个int2_类来处理复数整数.

ComplexTypes.h文件中的类声明如下:

namespace LibraryNameSpace
{
    class int2_ {

        public:
            int x;
            int y;

            // Constructors
            __host__ __device__ int2_(const int,const int);
            __host__ __device__ int2_();
            // etc.

            // Equalities with other types      
            __host__ __device__ const int2_& operator=(const int);
            __host__ __device__ const int2_& operator=(const float);
            // etc.

    };
}

ComplexTypes.cpp文件中的类实现如下:

#include "ComplexTypes.h"

__host__ __device__         LibraryNameSpace::int2_::int2_(const int x_,const int y_)           { x=x_; y=y_;}
__host__ __device__         LibraryNameSpace::int2_::int2_() {}
// etc.

__host__ __device__ const   LibraryNameSpace::int2_& LibraryNameSpace::int2_::operator=(const int a)                        { x = a; …

我正在努力熟悉CUDA编程,并且有一段非常有趣的时间.我目前正在研究这个处理矩阵乘法的pdf,有和没有共享内存.这两个版本的完整代码都可以在这里找到.该代码几乎与CUDA矩阵乘法样本中的代码完全相同.虽然非共享内存版本具有以任何矩阵大小运行的能力,但无论块大小如何,共享内存版本必须与块大小的倍数(我设置为4,默认最初为16)的矩阵一起使用.

在pdf结尾处提出的问题之一是更改它,以便共享内存版本也可以使用块大小的非倍数.我认为这将是一个简单的索引检查,就像在非共享版本中一样:

int row = blockIdx.y * blockDim.y + threadIdx.y;
int col = blockIdx.x * blockDim.x + threadIdx.x;
if(row > A.height || col > B.width) return;

但这不起作用.这是完整的代码,减去主要的方法(有点乱,对不起),我已经有所修改了:

void MatMul(const Matrix A, const Matrix B, Matrix C) { 
  // Load A and B to device memory 
  Matrix d_A; 
  d_A.width = d_A.stride = A.width; 
  d_A.height = A.height; 
  size_t size = A.width * A.height * sizeof(float); 
  cudaError_t err = cudaMalloc(&d_A.elements, size); 
  printf("CUDA malloc A: %s\n",cudaGetErrorString(err)); 
  err = cudaMemcpy(d_A.elements, A.elements, …

考虑一个包含数值的字符串数组:

string[] intArray = {"25", "65" , "0"};

将数字加载到a List<int>而不使用for或while迭代的最优雅的方法是intArray什么？

我想模仿CPU上CUDA双线性插值的行为,但我发现返回值tex2D似乎不适合双线性公式.

我想将插值系数从比特值[1]的比特转换float为9比特定点格式导致不同的值.8

根据转换fomula [2,线106] ,该转换的结果将是相同的作为输入float时coeffient是1/2^n,与n=0,1,..., 8,但我仍然(不总是)接收怪异值.

下面我报告一个奇怪值的例子.在这种情况下,奇怪的价值总是发生在id = 2*n+1,有人可以告诉我为什么吗？

Src数组:

Src[0][0] =  38;  
Src[1][0] =  39;  
Src[0][1] = 118;  
Src[1][1] =  13;  

纹理定义:

static texture<float4, 2, cudaReadModeElementType> texElnt;
texElnt.addressMode[0] = cudaAddressModeClamp;
texElnt.addressMode[1] = cudaAddressModeClamp;
texElnt.filterMode = cudaFilterModeLinear;
texElnt.normalized = false;

内核功能:

static __global__ void kernel_texElnt(float* pdata, int w, int h, int c, float stride/*0.03125f*/) {
    const int gx = blockIdx.x*blockDim.x + …

我有两个数组,我希望将一个数组复制到另一个数组中.例如,我有

A A A A A A A A ...

B B B B B B B B ...

我想每三个元素复制B到A获得

B A A B A A B A ...

从帖子" 是否有一个标准的,跨步的memcpy版本？ ",似乎在C中没有这种可能性.

但是,我经历过,在某些情况下,memcpy比基于for循环的副本更快.

我的问题是; 有没有办法在C++中有效地执行跨步内存复制,至少执行标准for循环？

非常感谢你.

编辑 - 澄清问题

为了使问题更清晰,让我们表示手头上的两个数组a和b.我有一个执行独特的跟随for循环的函数

for (int i=0; i<NumElements, i++)
    a_[i] = b_[i];

例如,两者[]都是重载运算符(我正在使用表达式模板技术),以便它们实际上是有意义的

 a[3*i]=b[i];

我正在尝试减少CUDA,我真的是一个新手.我目前正在研究NVIDIA的示例代码.

我想我真的不确定如何设置块大小和网格大小,特别是当我的输入数组大于(512 X 512)而不是单个块大小时.

这是代码.

template <unsigned int blockSize>
__global__ void reduce6(int *g_idata, int *g_odata, unsigned int n)
{
    extern __shared__ int sdata[];
    unsigned int tid = threadIdx.x;
    unsigned int i = blockIdx.x*(blockSize*2) + tid;
    unsigned int gridSize = blockSize*2*gridDim.x;
    sdata[tid] = 0;

    while (i < n) 
    { 
        sdata[tid] += g_idata[i] + g_idata[i+blockSize]; 
        i += gridSize; 
    }

    __syncthreads();

    if (blockSize >= 512) { if (tid < 256) { sdata[tid] += sdata[tid + 256]; } __syncthreads(); }
    if (blockSize …

从用户的'guess'顶点初始化用于Nelder-Mead单纯形搜索的单纯形的最佳方法是什么？

我正在尝试在GPU上实现矩阵向量乘法(使用CUDA).

在我的C++代码(CPU)中,我将矩阵加载为密集矩阵,然后使用CUDA执行矩阵向量乘法.我也使用共享内存来提高性能.

1. 我怎么能以有效的方式加载矩阵,知道我的矩阵是一个稀疏矩阵？

下面是我加载矩阵的C++函数:

int readMatrix( char* filename, float* &matrix, unsigned int *dim = NULL, int majority = ROW_MAJOR )
{
    unsigned int w, h, x, y, num_entries;

    float val;

    std::ifstream file( filename );

    if ( file )
    {
        file >> h >> w >> num_entries;
        cout << w << " " << h << " " << num_entries << "\n";

        assert( w == h || w == 1 || h == 1 );

        if( dim != NULL ) *dim …

我已经阅读了一些关于GPGPU的"持久线程"的论文,但我并不是真的理解它.任何人都可以给我一个例子或向我展示这种编程方式的用途吗？

在阅读和搜索"持久线程"之后,我在脑海中留下了什么:

Presistent Threads它只不过是一个while循环,它可以保持线程运行并计算大量的工作.

它是否正确？提前致谢

参考:http ://www.idav.ucdavis.edu/publications/print_pub？pub_id = 1089 http://developer.download.nvidia.com/GTC/PDF/GTC2012/PresentationPDF/S0157-GTC2012-Persistent-Threads-Computing .PDF