CUDA 中设备函数指针的分配（来自主机函数指针）

Question

I encapsulate my function pointers in a structure/class. I can use these functions in a CPU implementation easily. However, if I want to use function pointers in CUDA, I have to register these functions by CUDA directives. Unfortuanely, here things become tricky. What I want is to create and device function pointers from a class containing function pointers.

But let's start with the structure:

#ifndef TRANSFERFUNCTIONS_H_
#define TRANSFERFUNCTIONS_H_

#ifndef SWIG
#include <cmath>
#include <stdio.h>
#include <string.h>
#endif

#define PI    3.14159265358979323846f 



typedef float (*pDistanceFu) (float, float);
typedef float (*pDecayFu) (float, float, float);


//////////////////////////////////////////////////////////////////////////////////////////////
#ifdef __CUDACC__
        __host__ __device__
#endif
inline static float
fcn_gaussian_nhood (float dist, float sigmaT) {
        return exp(-pow(dist, 2.f)/(2.f*pow(sigmaT, 2.f)));
}

#ifdef __CUDACC__
        __host__ __device__
#endif
inline static float
fcn_rad_decay (float sigma0, float T, float lambda) {
        return std::floor(sigma0*exp(-T/lambda) + 0.5f);
}

    //////////////////////////////////////////////////////////////////////////////////////////////
#ifdef __CUDACC__
        __host__ __device__
#endif
inline static float
fcn_lrate_decay (float sigma0, float T, float lambda) {
        return sigma0*exp(-T/lambda);
}

class DistFunction;
typedef float (*pDistanceFu) (float, float);
typedef float (*pDecayFu) (float, float, float);
typedef float (DistFunction::*pmDistanceFu) (float, float);
typedef float (DistFunction::*pmDecayFu) (float, float, float);


class DistFunction {
private:
        pDistanceFu hDist;
        pDecayFu hRadDecay; 
        pDecayFu hLRateDecay;

public:
        DistFunction(char *, pDistanceFu, pDecayFu, pDecayFu);
        void Assign();

        char *name;
        pDistanceFu distance;
        pDecayFu rad_decay;
        pDecayFu lrate_decay;
};

void test();

#endif /* TRANSFERFUNCTIONS_H_ */

Implementation:

//#include <iostream>
#include "Functions.h"
#include <iostream>
#include <thrust/extrema.h>
#include <thrust/distance.h>
#include <thrust/device_vector.h>


DistFunction::DistFunction(char *cstr, pDistanceFu dist, pDecayFu rad, pDecayFu lrate) : name(cstr), distance(dist), rad_decay(rad), lrate_decay(lrate) {
}

void DistFunction::Assign() {
        pDistanceFu hDist;
        pDecayFu hRadDecay; 
        pDecayFu hLRateDecay;

        cudaMemcpyFromSymbol(&hDist, distance, sizeof(pDistanceFu) );
        cudaMemcpyFromSymbol(&hRadDecay, rad_decay, sizeof(pDecayFu) );
        cudaMemcpyFromSymbol(&hLRateDecay, lrate_decay, sizeof(pDecayFu) );

        distance = hDist;
        rad_decay = hRadDecay;
        lrate_decay = hLRateDecay;
}

DistFunction fcn_gaussian = DistFunction(
        (char*)"gaussian",
        fcn_gaussian_nhood,
        fcn_rad_decay,
        fcn_lrate_decay
);



struct sm20lrate_decay_functor {
        float fCycle;
        float fCycles;
        DistFunction m_pfunc;

        sm20lrate_decay_functor(const DistFunction &pfunc, float cycle, float cycles) : m_pfunc(pfunc), fCycle(cycle), fCycles(cycles) {}

        __host__ __device__
        float operator()(float lrate) {
                return (m_pfunc.lrate_decay)(lrate, fCycle, fCycles);
        }
};

void test() {
        unsigned int iWidth     = 4096;
        thrust::device_vector<float> dvLearningRate(iWidth, 0.f);
        thrust::device_vector<float> dvLRate(iWidth, 0.f);

        thrust::transform( dvLRate.begin(),
                dvLRate.end(),
                dvLearningRate.begin(),
                sm20lrate_decay_functor(fcn_gaussian, 1, 100) );
}

Edit: Made a minimal example.

It seems that CUDA device function pointers are useless, because I cannot use them dynamically. For what they have been implemented remains enigmatic for me. Can it be that CUDA is not really supporting function pointers but just uses function references in a similar way?

Answer 1

Question is not explicit enough. I will try to rephrase: Is it possible to get the function pointer of a device function from the host without using an intermediate globally declared variable ?

This is possible, though not exactlty the way you express it.

First, in your code sample, the function is marked inline static, hence, if CUDA does not see any use for its address, the function will most probably get inlined, and getting a pointer to it will not be feasible.

Second, you do not document what GetDistFunction() returns, hence, we don't know what symbol it returns.

The method you are using, cudaMemcpyFromSymbol is returning

symbol is a variable that resides in global or constant memory space.

The function pointer symbol is not a variable, it is a pointer to a code region. Also, GetDistFunction()->xxx is unlikely to be a symbol.

The technique you use is one of the approach to do the operation you intend. You may also initialize your structure on the device where getting the function pointer is as trivial as it is on host side. That way, your code will get simpler with no call to cudaMemcpyToSymbol nor global variable holding the pointer. Here is a snippet of code illustrating both approaches, the second one avoiding use of intermediate global-scope variable:

typedef int (*funcptr) ();

__device__ int f() { return 42 ; }

__device__ funcptr f_ptr = f ;

__global__ void kernel ( funcptr func )
{
    int k = func () ;
    printf ("%d\n", k) ;

    funcptr func2 = f ; // does not use a global-scope variable
    printf ("%d\n", func2()) ;
}


int main ()
{
    funcptr h_funcptr ;

    if (cudaSuccess != cudaMemcpyFromSymbol (&h_funcptr, f_ptr, sizeof (funcptr)))
        printf ("FAILED to get SYMBOL\n");

    kernel <<<1,1>>> (h_funcptr) ;
    if (cudaDeviceSynchronize() != cudaSuccess)
        printf ("FAILED\n");
    else
        printf ("SUCCEEDED\n");
}

Finally, as a design comment, you may want to try use virtual functions, and build the appropriate instance of your class on the device, all these initialization steps would be generated by the compiler, here is an example:

class T
{
public:
    virtual __device__ int f() const = 0 ;
} ;

class G : public T
{
public:
    virtual __device__ int f() const { return 42; }
} ;

__global__ void kernel2 ()
{
    T* t = new G() ;
    int k = t->f();
    printf ("%d\n", k) ;
}

int main ()
{
    kernel2<<<1,1>>>();
    if (cudaDeviceSynchronize() != cudaSuccess)
        printf ("FAILED\n");
    return 0 ;
}

And using the prototype pattern or a singleton would help.

Answer 2

I finally found out that my example posted in the question is impossible to realize with device function pointers, because function pointers can neither be assigned outside main space (eg constructor), nor dynamically.

Function wise, this demo implementation of CUDA function pointers corresponds to the example below.

typedef int (*funcptr) ();

__device__ int f() { return 42 ; }

__device__ funcptr f_ptr = f ;

__global__ void kernel ( funcptr func )
{
    int k = func () ;
    printf ("%d\n", k) ;

    funcptr func2 = f ; // does not use a global-scope variable
    printf ("%d\n", func2()) ;
}


int main ()
{
    funcptr h_funcptr ;

    if (cudaSuccess != cudaMemcpyFromSymbol (&h_funcptr, f_ptr, sizeof (funcptr)))
        printf ("FAILED to get SYMBOL\n");

    kernel <<<1,1>>> (h_funcptr) ;
    if (cudaDeviceSynchronize() != cudaSuccess)
        printf ("FAILED\n");
    else
        printf ("SUCCEEDED\n");
}

As one can clearly see, the example above has no gain in flexibility, as every function pointer must be assigned to a device symbol in global space.

__device__ int f() { return 42 ; }

__global__ void kernel () {
    int k = f() ;
    printf ("%d\n", k) ;
}

int main ()
{
    kernel <<<1,1>>> () ;
    if (cudaDeviceSynchronize() != cudaSuccess)
        printf ("FAILED\n");
    else
        printf ("SUCCEEDED\n");
}

The only way to circumvent the absolutely useless device function implementation of NVIDIA, which cannot yield any benefit over normal function calls (because of the named reasons), is to use templates. Unfortunately, templates allow no run-time flexibility. Nevertheless, this is no disadavnatge in comparison to CUDA device function pointers , because they also don't allow runtime change of functions.

This is my template based solution for the problem illustrated above. It may look like strong opinion against CUDA device function pointers, but if someone can prove me wrong, he can post an example ..

typedef float (*pDistanceFu) (float, float);
typedef float (*pDecayFu) (float, float, float);

template <pDistanceFu Dist, pDecayFu Rad, pDecayFu LRate>
class DistFunction {    
public:
        DistFunction() {}
        DistFunction(const char *cstr) : name(cstr) {};

        const char *name;

        #ifdef __CUDACC__
                __host__ __device__
        #endif
        static float distance(float a, float b) { return Dist(a,b); };
        #ifdef __CUDACC__
                __host__ __device__
        #endif
        static float rad_decay(float a, float b, float c) { return Rad(a,b,c); };
        #ifdef __CUDACC__
                __host__ __device__
        #endif
        static float lrate_decay(float a, float b, float c) { return LRate(a,b,c); };
};

And an example:

template <class F>
struct functor {
float fCycle;
float fCycles;

functor(float cycle, float cycles) : fCycle(cycle), fCycles(cycles) {}

__host__ __device__
float operator()(float lrate) {
    return F::lrate_decay(lrate, fCycle, fCycles);
}
};

typedef DistFunction<fcn_gaussian_nhood,fcn_rad_decay,fcn_lrate_decay> gaussian;
void test() {
        functor<gaussian> test(0,1);
}