Question

我是Cuda编程的新手。我正在尝试创建一个简单的cuda和cpp图像处理程序，以改变图像的亮度，饱和度，对比度等。我从一个非常简单的函数开始，只是为了改变图像的亮度，将图像的所有RGB分量乘以alpha值。

这是我的CPP计划：

#include <cutil_inline.h>
#include <cutil_gl_inline.h>

#include <cuda_runtime_api.h>
#include <cuda_gl_interop.h>

using namespace std;

struct ImageData {
    unsigned char *data;    /* Points to large array of R,G,B-order data */
    int  height;
    int width;
};

ImageData imageData;
float *imageResult; // to store the image result from cuda after running the kernel
unsigned char *d_Input;
unsigned char *d_Output;
unsigned char *h_Output;

// These are CUDA functions to handle allocation and launching the kernels
extern "C" void initInput( unsigned char *data, unsigned char **device, unsigned int size); 
extern "C" void filter(unsigned char *d_src, unsigned char *d_dest, int width, int height, int filterMode, 
                float alpha, float contrast, float saturation, bool use_array );

void initCuda()
{
        unsigned int size = imageData.width * imageData.height * 3 * sizeof(unsigned char);
        cutilSafeCall(cudaMalloc ((void**) &d_Input, size));  // allocate storage for device image input
        cutilSafeCall(cudaMalloc ((void**) &d_Output, size)); // allocate storage for device image output
    initInput( imageData.data, &d_Input, size); 
}

int main () {


    loadPPMImageData( (char *)"boxes.ppm", &imageData); //this function is defined in another file
    cudaGLSetGLDevice( 0 );
    initCuda();
    filter(  d_Input, d_Output, imageData.width, imageData.height, 1, 0.8, 1.0, 1.0, 1 );

    cutilSafeCall(cudaMemcpy( h_Output, d_Output, size, cudaMemcpyDeviceToHost)); // copy output data from device to host
    //print the output
    for (int i = 0; i < imageData.size; i++) {
        cout << d_Output
    }
    // do some memory cleanups

    //done
    return 0
}

这是我的kernel.cu文件：

#include <iostream>
#include <cstdlib>
#include <string>
#include <cmath>

#include <shrUtils.h>
#include <cutil_inline.h>
#include <cutil_math.h>


//Kernel function
__global__ void
applyAlpha(unsigned char* input, unsigned char* output, int width, int height, float alpha) 
{
// calculate normalized coordinates
unsigned int x = blockIdx.x * blockDim.x + threadIdx.x;
unsigned int y = blockIdx.y * blockDim.y + threadIdx.y;
output[ ((y * width + x) * 3) + 0] = (int) ( (int)input [ ((y * width + x) * 3) + 0] * alpha); // r
output[ ((y * width + x) * 3) + 1] = (int) ( (int)input [ ((y * width + x) * 3) + 1] * alpha); // g
output[ ((y * width + x) * 3) + 2] = (int) ( (int)input [ ((y * width + x) * 3) + 2] * alpha); // b
}


extern "C"
int iDivUp( int a, int b ){
    return (a % b != 0) ? (a / b + 1) : (a / b);
}


extern "C" 
void initInput( unsigned char *data, unsigned char **deviceArray, unsigned int size) // /* image data, device pointer, etc */ )
{
    /* TODO: Array version DONE
     *  Initialize device memory for array version
     *  and cuda arrays for texture version here
     */
    cutilSafeCall(cudaMemcpy( deviceArray, data, size, cudaMemcpyHostToDevice)); // copy image data from host to device (array version)
    //TODO: Texture version

}


extern "C" 
void filter( unsigned char *d_src, unsigned char *d_dest, int width, int height, int filter_mode, float alpha, float contrast, float saturation, bool use_array )
{
    /*  TODO
     * run different kernels for array and texture version
     */

    dim3 dimBlock(16, 16, 1);
    dim3 dimGrid( iDivUp (width, dimBlock.x), iDivUp( height, dimBlock.y), 1);

    if (use_array) { // Array version
        if (filter_mode == 1) { // filter mode: brightness (alpha)

            applyAlpha<<< dimGrid, dimBlock >>>(d_src, d_dest, width, height, alpha);

            // check if kernel execution generated an error
            cutilCheckMsg("Kernel execution failed");

            cutilSafeCall( cutilDeviceSynchronize() );
        }
    }
    else { //Texture Version
        //not yet implemented
    }

}

的 //修改 的我根据Andrew的回答修改了上面的文件。但是现在我在编译之后遇到了以下错误：

ld: warning: ignoring file kernel.o, file was built for i386 which is not the architecture being linked (x86_64)
Undefined symbols for architecture x86_64:
  "_initInput", referenced from:
      initCuda()    in CS380_prog4.o
  "_filter", referenced from:
      display()     in CS380_prog4.o
     (maybe you meant: ___GLEW_SGIS_texture_filter4, ___GLEW_EXT_texture_filter_anisotropic , ___GLEW_NV_multisample_filter_hint )
ld: symbol(s) not found for architecture x86_64
collect2: ld returned 1 exit status
make: *** [testprog] Error 1

我在这两个函数中都使用了“extern C”命令：initInput和filter。函数声明（在test.cpp中）和定义（在kernel.cu中）也有相同的参数，但它仍然抱怨它无法找到该函数。我该如何解决这个链接问题？

Answer 1

您将.cu文件直接包含在.cpp文件中，该文件有效地将内容复制到.cpp文件中。 nvcc将使用标准的C ++编译器来编译它（在unix平台上使用g ++），它不知道任何Cuda语法的含义。

您必须将每个文件编译为目标文件，然后将它们与C ++编译器链接，使.cu文件中导出函数的标题与标准C相同。

Answer 2

cuda-grayscale中有一个很好的例子。

它曾用于在CUDA 3.1上编译。那里有一个Makefile，在它上面巅峰。

CXX=g++

CUDA_INSTALL_PATH=/usr/local/cuda
CFLAGS= -I. -I$(CUDA_INSTALL_PATH)/include `pkg-config --cflags opencv`
LDFLAGS= -L$(CUDA_INSTALL_PATH)/lib -lcudart `pkg-config --libs opencv`    

all:
        $(CXX) $(CFLAGS) -c main.cpp -o Debug/main.o
        nvcc $(CUDAFLAGS) -c kernel_gpu.cu -o Debug/kernel_gpu.o
        $(CXX) $(LDFLAGS) Debug/main.o Debug/kernel_gpu.o -o Debug/grayscale

clean:
        rm -f Debug/*.o Debug/grayscale

需要有关非常简单的Cuda和C ++程序的帮助

2 个答案: