仅在发布配置中出现 GPU 崩溃

问：

我有一个带有回调的主机调用方类，用于创建指向 GPU 上类的指针。在此回调中，将调用内核以在 GPU 上创建类的实例。我在 GPU 上为此类指针正确分配了内存。

接下来，通过第二个内核调用此类上的方法，并将结果复制回主机。

所有这些似乎在调试模式下工作正常，但在发布模式下崩溃。这在 Windows 和 Linux 中都会发生。无论我将 2 个 .cu 文件编译为一个可执行文件的一部分，还是将 2 个 .cu 文件编译为静态（或动态）库和链接到库的可执行文件，都会发生这种情况。

我可以让它在发布模式下工作的唯一方法是不通过调用方类来执行内核，但不幸的是，这不适用于我的应用程序。我认为我在 GPU 内存管理方面没有做错任何事情，因为它在调试模式下一切正常。

我提出了一个简单的例子来复制这个问题，我在下面包括了各种代码。只需在 Windows 或 Linux 中编译 .cu 文件作为唯一可执行文件的一部分即可复制问题。

非常感谢您的帮助和最诚挚的问候。

• 函数.cuh

class function {

public:

    __device__ function() {}
    virtual __device__ ~function() {}

    virtual __device__ double calc(const double& x) const = 0;
};

class pointer_derived : public pointer_base
{
    function** m_p;

public:

    pointer_derived(function** p) : m_p(p) {}

    operator function** () { return m_p; }
};

• StaticLib.h

#pragma once

#include "Caller.h"

double run_function(Caller* f, const double& x, bool use_local);

• StaticLib.cu

#include "StaticLib.h"
#include "function.cuh"

class myfunction_local : public function {

public:

    __device__ myfunction_local() {}
    __device__ ~myfunction_local() {}

    __device__ double calc(const double& x) const
    {
        return x * x;
    }

};

__global__ void invoke_function(double* p, function** func, double x)
{
    *p = (*func)->calc(x);
}

__global__ void invoke_local_builder(function** ptr)
{
    *ptr = new myfunction_local();
}

double run_function(Caller* c, const double& x, bool use_local)
{
    function** func_p;

    cudaError_t cudaStatus = cudaMalloc(&func_p, sizeof(function*));

    pointer_derived ptr(func_p);

    if (use_local)
        invoke_local_builder<<<1,1>>>(ptr);
    else
        c->get_function(ptr);

    double* p;

    cudaStatus = cudaMalloc(&p, sizeof(double));

    invoke_function<<<1,1>>>(p,func_p,x);

    double res;

    cudaMemcpy(&res, p, sizeof(double), cudaMemcpyDeviceToHost);

    return res;
}

• 来电者.h

#pragma once

class pointer_base {

public:

    pointer_base() {}
    virtual ~pointer_base() {}

};

class Caller {

public:

    Caller() {}
    ~Caller() {}

    void get_function(pointer_base& ptr);

};

• Caller.cu

#include "Caller.h"
#include "function.cuh"

class myfunction : public function {

public:

    __device__ myfunction() {}
    __device__ ~myfunction() {}

    __device__ double calc(const double& x) const
    {
        return x * x;
    }

};


__global__ void invoke_builder(function** ptr)
{
    *ptr = new myfunction();
}


void Caller::get_function(pointer_base& func_p)
{
    function** ptr = dynamic_cast<pointer_derived&>(func_p);
    invoke_builder<<<1,1>>>(ptr);

}

#include <iostream>
#include "StaticLib.h"

int main()
{
    Caller caller;

    // use_local = true - works both in release and config
    // use_local = false - crashes in release mode but works in debug mode

    bool use_local = true; 

    double res = run_function(&caller, 2.0, use_local);

    std::cout << res << std::endl;

}

我期望调试和发布配置具有相同的行为。