我可以在CUDA设备上为包含浮点数数组的对象分配内存吗？

Question

I am working on parallel solving of identical ordinary differential equations with different initial conditions. I have solved this problem with OpenMP and now I want to implement similar code on GPU. Specifically, I want to allocate memory on device for floats in class constructor and then deallocate it in destructor. It doesn't work for me since I get my executable "terminated by signal SIGSEGV (Address boundary error)". Is it possible to use classes, constructors and destructors in CUDA?

By the way, I am newbie in CUDA and not very experienced in C++ either.

I attach the code in case I have described my problem poorly.

#include <cmath>
#include <iostream>
#include <fstream>
#include <iomanip>
#include <random>
#include <string>
#include <chrono>
#include <ctime>

using namespace std;

template<class ode_sys>
class solver: public ode_sys 
{
    public:
    int *nn;
    float *t,*tt,*dt,*x,*xx,*m0,*m1,*m2,*m3;

    using ode_sys::rhs_sys;

    __host__ solver(int n): ode_sys(n)
    { //here I try to allocate memory. It works malloc() and doesn't with cudaMalloc() 
        size_t size=sizeof(float)*n;
        cudaMalloc((void**)&nn,sizeof(int));
        *nn=n;
        cudaMalloc((void**)&t,sizeof(float));
        cudaMalloc((void**)&tt,sizeof(float));
        cudaMalloc((void**)&dt,sizeof(float));
        cudaMalloc((void**)&x,size);
        cudaMalloc((void**)&xx,size);
        cudaMalloc((void**)&m0,size);
        cudaMalloc((void**)&m1,size);
        cudaMalloc((void**)&m2,size);
        cudaMalloc((void**)&m3,size);
    }

    __host__ ~solver()
    {
        cudaFree(nn);
        cudaFree(t);
        cudaFree(tt);
        cudaFree(dt);
        cudaFree(x);
        cudaFree(xx);
        cudaFree(m0);
        cudaFree(m1);
        cudaFree(m2);
        cudaFree(m3);
    }

    __host__ __device__ void rk4()
    {//this part is not important now. 
    }
};

class ode 
{
    private:
    int *nn;

    public:
    float *eps,*d;

    __host__ ode(int n)
    {
        cudaMalloc((void**)&nn,sizeof(int));
        *nn=n;
        cudaMalloc((void**)&eps,sizeof(float));
        size_t size=sizeof(float)*n;
        cudaMalloc((void**)&d,size);
    }

    __host__ ~ode()
    {
        cudaFree(nn);
        cudaFree(eps);
        cudaFree(d);
    }

    __host__ __device__ float f(float x_,float y_,float z_,float d_)
    {
        return d_+*eps*(sinf(x_)+sinf(z_)-2*sinf(y_));
    }

    __host__ __device__ void rhs_sys(float *t,float *dt,float *x,float *dx)
    {
    }
};

//const float pi=3.14159265358979f;

__global__ void solver_kernel(int m,int n,solver<ode> *sys_d)
{
    int index = threadIdx.x;
    int stride = blockDim.x;

    //actually ode numerical evaluation should be here
    for (int l=index;l<m;l+=stride)
    {//this is just to check that i can run kernel
        printf("%d Hello \n", l);
    }
}

int main ()
{
    auto start = std::chrono::system_clock::now();
    std::time_t start_time = std::chrono::system_clock::to_time_t(start);
    cout << "started computation at " << std::ctime(&start_time);

    int m=128,n=4,l;// i want to run 128 threads, n is dimension of ode

    size_t size=sizeof(solver<ode>(n));
    solver<ode> *sys_d;   //an array of objects
    cudaMalloc(&sys_d,size*m);    //nvprof shows that this array is allocated

    for (l=0;l<m;l++)
    {
        new (sys_d+l) solver<ode>(n);   //it doesn't work as it meant to
    }

    solver_kernel<<<1,m>>>(m,n,sys_d);   

    for (l=0;l<m;l++)
    {
        (sys_d+l)->~solver<ode>();    //it doesn't work as it meant to
    }
    cudaFree(sys_d);    //it works

    auto end = std::chrono::system_clock::now();
    std::chrono::duration<double> elapsed_seconds = end-start;
    std::time_t end_time = std::chrono::system_clock::to_time_t(end);
    std::cout << "finished computation at " << std::ctime(&end_time) << "elapsed time: " << elapsed_seconds.count() << "s\n";

    return 0;
}

//end of file

Answer 1

Distinguish host-side and device-side memory

As other answer also state:

• GPU (global) memory you allocate with cudaMalloc() is not accessible by code running on the CPU; and
• System memory (aka host memorY) you allocate in plain C++ (with std::vector , with std::make_unique , with new etc.) is not accessible by code running on the GPU.

So, you need to allocate both host-side and device-side memory. For a simple example of working with both device-side and host-side memory see the CUDA vectorAdd sample program .

_{(Actually, you can also make a special kind of allocation which is accessible from both the device and the host; this is Unified Memory . But let's ignore that for now since we're dealing with the basics.)}

Don't live in the kingdom of nouns

Specifically, I want to allocate memory on device for floats in class constructor and then deallocate it in destructor.

I'm not sure you really want to do that. You seem to be taking a more Java-esque approach, in which everything you do is noun-centric, ie classes are used for everything: You don't solve equations, you have an "equation solver". You don't "do X", you have an "XDoer" class etc. Why not just have a (templated) function which solves an ODE system, returning the solution? Are you using your "solver" in any other way?

(this point is inspired by Steve Yegge's blog post, Execution in the Kingdom of Nouns .)

Try to avoid allocating and de-allocating yourself

In well-written modern C++, we try to avoid direct, manual allocation of memory (that's a link to the C++ Core Programming Guidelines by the way). Now, it's true that you free your memory with the destructor, so it's not all that bad, but I'd really consider using std::unique_ptr on the host and something equivalent on the device (like cuda::memory::unique_ptr from my Modern-C++ CUDA API wrapper cuda-api-wrappers library); or a GPU-oriented container class like thrust 's device vector.

Check for errors

You really must check for errors after you call CUDA API functions. And this is doubly necessary after you launch a kernel. When you call a C++ standard library code, it throws an exception on error; CUDA's runtime API is C-like, and doesn't know about exceptions. It will just fail and set some error variable you need to check.

So, either you write error checks, like in the vectorAdd() sample I linked to above, or you get some library to exhibit more standard-library-like behavior. cuda-api-wrappers and thrust will both do that - on different levels of abstraction; and so will other libraries/frameworks.

Answer 2

You need an array on the host side and one on the device side.

Initialize the host array, then copy it to the device array with cudaMemcpy . The destruction has to be done on the host side again.

An alternative would be to initialize the array from the device, you would need to put __device__ in front of your constructor, then just use malloc .

Answer 3

You can not dereference pointer to device memory in host code:

__host__ ode(int n)
{
    cudaMalloc((void**)&nn,sizeof(int));
    *nn=n; // !!! ERROR
    cudaMalloc((void**)&eps,sizeof(float));
    size_t size=sizeof(float)*n;
    cudaMalloc((void**)&d,size);
}

You will have to copy the values with cudaMemcpy. (Or use the parameters of a __global__ function.)