CUDA内核中的printf（）不'；结果不会产生任何结果

我在CUDA程序中添加了一些

printf（）

语句

__device__ __global__ void Kernel(float *, float * ,int );
void DeviceFunc(float *temp_h , int numvar , float *temp1_h)
{ .....
    //Kernel call
    printf("calling kernel\n");
    Kernel<<<dimGrid , dimBlock>>>(a_d , b_d , numvar);
    printf("kernel called\n");
  ....
}

int main(int argc , char **argv)
{   ....
    printf("beforeDeviceFunc\n\n");
    DeviceFunc(a_h , numvar , b_h); //Showing the data
    printf("after DeviceFunc\n\n");
    ....
}

现在，当我运行程序时，我看到：

beforeDeviceFunc

calling kernel
kernel called
after DeviceFunc

因此，内核中的

printf（）

不会被打印。如何修复此问题？

printf（）

只有在内核成功完成时才会显示输出，因此请检查所有CUDA函数调用的返回代码，并确保没有报告错误

此外，

printf（）

输出仅在程序中的某些点显示。将这些列为

• 通过
  或

  culunchkernel（）

  启动内核（在启动开始时，如果CUDA_launch_BLOCKING环境变量设置为1，也在启动结束时）
• 通过

  cudaDeviceSynchronize（）

  ，

  cuCtxSynchronize（）

  ，

  cudaStreamSynchronize（）

  ，

  cuStreamSynchronize（）

  ，

  cudaEventSynchronize（）

  ，或

  cuEventSynchronize（）

  ，进行同步
• 通过任何阻止版本的

  cudaMemcpy*（）

  或

  cuMemcpy*（）

  进行内存复制
• 通过

  cuModuleLoad（）

  或

  cuModuleUnload（）

  加载/卸载模块
• 通过

  cudaDeviceReset（）

  或

  cuCtxDestroy（）

  销毁上下文
• 在执行由

  cudaStreamAddCallback（）

  或

  cuStreamAddCallback（）

  添加的流回调之前

要检查这是否是您的问题，请在内核调用之后放置以下代码：

{
    cudaError_t cudaerr = cudaDeviceSynchronize();
    if (cudaerr != cudaSuccess)
        printf("kernel launch failed with error \"%s\".\n",
               cudaGetErrorString(cudaerr));
}

然后，您应该看到内核的输出或错误消息

---

更方便的是，如果您在其下运行可执行文件，它将自动为您检查所有返回代码。尽管您应该始终检查错误，但这在解决具体问题时非常方便。

我刚才也遇到了同样的错误，将块大小减小到512有帮助。根据文档，最大块大小可以是512或1024

我编写了一个简单的测试，它表明我的GTX 1070的最大块大小为1024。UPD：您可以使用cudaError\u t cudaPeekAtLastError（）检查内核是否执行过，如果内核已成功启动，并且只有在调用cudaError\u t cudaDeviceSynchronize（）更糟糕之后，它才会返回cudaSuccess

测试块大小为1023

测试块大小为1024

测试块大小为1025

CUDA错误：配置参数无效

块的最大大小为1024

#include "cuda_runtime.h"
#include "device_launch_parameters.h"
#include <iostream>

__global__
void set1(int* t)
{
    t[threadIdx.x] = 1;
}

inline bool failed(cudaError_t error)
{
    if (cudaSuccess == error)
        return false;

    fprintf(stderr, "CUDA error: %s\n", cudaGetErrorString(error));
    return true;
}

int main()
{
    int blockSize;
    for (blockSize = 1; blockSize < 1 << 12; blockSize++)
    {
        printf("Testing block size of %d\n", blockSize);
        int* t;
        if(failed(cudaMallocManaged(&t, blockSize * sizeof(int))))
        {
            failed(cudaFree(t));
            break;
        }
        for (int i = 0; i < blockSize; i++)
            t[0] = 0;
        set1 <<<1, blockSize>>> (t);
        if (failed(cudaPeekAtLastError()))
        {
            failed(cudaFree(t));
            break;
        }
        if (failed(cudaDeviceSynchronize()))
        {
            failed(cudaFree(t));
            break;
        }

        bool hasError = false;
        for (int i = 0; i < blockSize; i++)
            if (1 != t[i])
            {
                printf("CUDA error: t[%d] = %d but not 1\n", i, t[i]);
                hasError = true;
                break;
            }
        if (hasError)
        {
            failed(cudaFree(t));
            break;
        }

        failed(cudaFree(t));
    }
    blockSize--;
    if(blockSize <= 0)
    {
        printf("CUDA error: block size cannot be 0\n");
        return 1;
    }
    printf("Block maximum size is %d", blockSize);
    return  0;
}

#包括“cuda_runtime.h”
#包括“设备启动参数.h”
#包括
__全球的__
无效集合1（int*t）
{
t[threadIdx.x]=1；
}
内联布尔失败（cudaError\t错误）
{
如果（cudaSuccess==错误）
返回false；
fprintf（stderr，“CUDA错误：%s\n”，cudaGetErrorString（错误））；
返回true；
}
int main（）
{
整块大小；
对于（blockSize=1；blockSize<1 I get
内核启动失败，错误为“CUDA驱动程序版本不适合CUDA运行时版本”。
然后检查您的安装并确保最新版本（或足够新版本）驱动程序已安装。我没有根访问权限进行更新。您知道如何检查cuda 4中的错误吗？我想这会对您有所帮助。您好，我也有同样的问题，并尝试了您的答案。我没有收到任何错误，但没有打印内核中的printf行。在我的情况下，
cudaDeviceSynchronize（）
未返回任何错误。但是我注意到块尺寸太大（32 x 32），创建较小的线程块解决了问题。您的错误检查是错误的，您的语句“注意，如果提供的块大小超过最大块大小，内核将无法运行，没有任何异常、错误等”.和块大小限制等都在文档中有详细描述。感谢您的反馈。我是否提到“至少我不知道从哪里得到[错误]”，我发现调用cudaPeekAtLastError有助于更新应答器。根据GPU的Cuda计算能力，每个多处理器的块数或多或少是有限的。例如，2.x支持每个SM 1536个线程，但仅支持8个块。如果每个块只使用一个完整的扭曲，则最大线程数为256个，这使得隐藏延迟更加困难。除了同步和延迟之外，缓存利用率是让线程在同一个SM上运行的另一个原因。for循环是另一种选择，它具有足够多的线程（隐藏延迟）和块（利用所有SM）来实现缓存利用率。
{
    cudaError_t cudaerr = cudaDeviceSynchronize();
    if (cudaerr != cudaSuccess)
        printf("kernel launch failed with error \"%s\".\n",
               cudaGetErrorString(cudaerr));
}

#include "cuda_runtime.h"
#include "device_launch_parameters.h"
#include <iostream>

__global__
void set1(int* t)
{
    t[threadIdx.x] = 1;
}

inline bool failed(cudaError_t error)
{
    if (cudaSuccess == error)
        return false;

    fprintf(stderr, "CUDA error: %s\n", cudaGetErrorString(error));
    return true;
}

int main()
{
    int blockSize;
    for (blockSize = 1; blockSize < 1 << 12; blockSize++)
    {
        printf("Testing block size of %d\n", blockSize);
        int* t;
        if(failed(cudaMallocManaged(&t, blockSize * sizeof(int))))
        {
            failed(cudaFree(t));
            break;
        }
        for (int i = 0; i < blockSize; i++)
            t[0] = 0;
        set1 <<<1, blockSize>>> (t);
        if (failed(cudaPeekAtLastError()))
        {
            failed(cudaFree(t));
            break;
        }
        if (failed(cudaDeviceSynchronize()))
        {
            failed(cudaFree(t));
            break;
        }

        bool hasError = false;
        for (int i = 0; i < blockSize; i++)
            if (1 != t[i])
            {
                printf("CUDA error: t[%d] = %d but not 1\n", i, t[i]);
                hasError = true;
                break;
            }
        if (hasError)
        {
            failed(cudaFree(t));
            break;
        }

        failed(cudaFree(t));
    }
    blockSize--;
    if(blockSize <= 0)
    {
        printf("CUDA error: block size cannot be 0\n");
        return 1;
    }
    printf("Block maximum size is %d", blockSize);
    return  0;
}