从c调用cuda导致错误

Question

The errors I am receiving are:

'blockIdx' was not declared in this scope expected primary-expression before '<' token

expected primary-expression before '>' token

expected primary-expression before '<' token

expected primary-expression before '>' token

(the "<,>" refers to the kernel call <<<>>>)

Also,in main function I receive:

error: cannot convert 'float* ' to 'float ' for argument '1' to 'void kernel_wrapper(float*, float*, int, int)

cu file:

#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <math.h>
#include <curand_kernel.h>
#include <cuda_runtime.h>
#include <cuda.h>

.....
__global__ void kernel(float* A,float *B, curandState* globalState, int Asize,int Bsize)
{
...

void kernel_wrapper(float* A_host,float* B_host, int Asize ,int Bsize)
{
...
//allocate host memory 
    A_host=(float*)malloc(Asize*sizeof(float));
    B_host=(float*)malloc(Bsize*sizeof(float));

    //allocate device memory
    float* A_dev,*B_dev;
    cudaMalloc((void**) &A_dev,Asize* sizeof(float));
    cudaMalloc((void**) &B_dev,Bsize* sizeof(float));
....

 kernel<<<1,1>>>(A_host,B_host, devStates,Asize,Bsize);
...

c file:

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/time.h>
#include <string.h>
#include <assert.h>
#include <stdarg.h>
#include <cuda.h>
#include <cuda_runtime.h>
#include "solve.cu"


extern void kernel_wrapper(float* A,float* B, int Asize ,int Bsize);
...
int main()
{...
A = (float*)malloc(N*N*sizeof(float));
B = (float*)malloc(N*HS*sizeof(float));
...
kernel_wrapper(A,B,Asize ,Bsize);
...

I am compiling as:

 g++ -o mycode myfile.c -I/usr/local/cuda-5.5/include -L/usr/local/cuda-5.5/lib64 -lcurand -lcutil -lcudpp -lcuda -lstdc+

Answer 1

You can't include solve.cu which contains device code (eg kernels) in a .c file and then compile it properly with g++

Device code has to be compiled by nvcc

Instead, you will need to compile the two files separately, then link them together.

I would suggest renaming your myfile.c to myfile.cpp

Also remove this line from your myfile.cpp :

#include "solve.cu"

Then compile with:

nvcc -c solve.cu
g++ -c -I/usr/local/cuda-5.5/include  myfile.cpp 
g++ -o mycode solve.o myfile.o -L/usr/local/cuda-5.5/lib64 -lcudart -lcurand -lcutil -lcudpp -lcuda

For the last issue, you are passing double pointers ( ** ):

kernel_wrapper(&A,&B,Asize ,Bsize);

Where the prototype is expecting single pointers ( * ):

extern void kernel_wrapper(float* A,float* B, int Asize ,int Bsize);

A and B are already of type float * , so it looks to me like you should pass them directly:

kernel_wrapper(A,B,Asize ,Bsize);

EDIT: Responding to a question below.

The problem is the pointers A_host and B_host (parameters to kernel_wrapper ) are being passed by value to the kernel wrapper function, and the kernel wrapper function is allocating the storage for those pointers, but the newly modified pointer reflecting the allocated storage is not (cannot) be passed back to the calling function (ie the function that called kernel_wrapper ).

You could allocate the storage for A_host and B_host in the calling function, and then pass the pointer (and then no need to malloc those pointers in kernel_wrapper ) or you could modify the kernel wrapper as follows:

void kernel_wrapper(float** A_host,float** B_host, int Asize ,int Bsize)
{
...
//allocate host memory 
    *A_host=(float*)malloc(Asize*sizeof(float));
    *B_host=(float*)malloc(Bsize*sizeof(float));

    //allocate device memory
    float* A_dev,*B_dev;
    cudaMalloc((void**) &A_dev,Asize* sizeof(float));
    cudaMalloc((void**) &B_dev,Bsize* sizeof(float));
....
 cudaMemcpy(A_dev, *A_host, Asize*sizeof(float), cudaMemcpyHostToDevice);
 cudaMemcpy(B_dev, *B_host, Bsize*sizeof(float), cudaMemcpyHostToDevice);

 kernel<<<1,1>>>(A_dev,B_dev, devStates,Asize,Bsize);
...

You would then also need to modify your calling line in the .cpp file:

int main()
{...
  float *A, *B;
  int Asize = N*N;
  int Bsize = N*NHS;
...
  kernel_wrapper(&A,&B,Asize ,Bsize);
...

The way your code is posted now, you are doing a malloc operation twice each for A and B and that is not necessary.