Separar `cudaMalloc` e `cudaMemcpy` em funções diferentes?

Estou usando cuda para acelerar meu código, no qual processo todas as imagens em loop. Cada imagem é processada na GPU via cuda.

Referi-me a cuda-samples para escrever o código abaixo:

• nome do arquivo:my_cuda.cu

#include "cuda_runtime.h"


int process_one_image(args)
{
    // note that declaration of some params is omitted.
    unsigned char *h_data = (unsigned char *)malloc(size);
    unsigned char *h_rgb = (unsigned char *)malloc(size_result);
    // initialize the host memory as an image info.
    ...

    unsigned char *d_data;
    unsigned char *d_rgb;

    cudaMalloc((void **)&d_data, size);
    cudaMalloc((void **)&d_rgb, size_result);
    cudaMemcpy(d_data, h_data, size, cudaMemcpyHostToDevice);

    // process the d_data on GPU
    ...

    // copy the result from device to host.
    cudaMemcpy(h_rgb, d_rgb, size_result, cudaMemcpyDeviceToHost);


    free(h_rgb);
    free(h_data)
    cudaFree(d_rgb);
    cudaFree(d_data);
}

no código acima cudaMalloce cudaMemcpyestão na mesma função process_one_image. e o código é executado corretamente.

Mas quero executar esse código repetidamente, em um loop de mais de 10.000 vezes. Então eu não quero fazer cudaMalloce cudaFreetoda vez eu processo imagens.

Então, quero mudar meu código para o arranjo abaixo.

• arquivo_cuda:my_cuda.cu

#include "cuda_runtime.h"

int initCuda(unsigned char *h_data, unsigned char *h_rgb, unsigned char *d_data, unsigned char *d_rgb)
{
    // note that declaration of some params is omitted.
    unsigned char *h_data = (unsigned char *)malloc(size);
    unsigned char *h_rgb = (unsigned char *)malloc(size_result);
    cudaMalloc((void **)&d_data, size);
    cudaMalloc((void **)&d_rgb, size);
}

int FinalizeCuda(unsigned char *h_data, unsigned char *h_rgb, unsigned char *d_data, unsigned char *d_rgb)
{
    cudaFree(d_data);
    cudaFree(d_rgb);
    free(h_data);
    free(h_rgb);
}

int process_one_image(unsigned char *h_data, unsigned char *h_rgb, unsigned char *d_data, unsigned char *d_rgb) // note some args are omitted such as size etc.
{

    cudaMemcpy(d_data, h_data, size, cudaMemcpyHostToDevice);

    // process the d_data on GPU
    ...

    // copy the result from device to host.
    cudaMemcpy(h_rgb, d_rgb, size, cudaMemcpyDeviceToHost);
}

• meu_c_código:c_code.c

#include "my_cuda.cu"


int processing_loop(args)  // specific args are omitted
{
    // declaration of host and device memory
    unsigned char *h_data;
    unsigned char *h_rgb;
    unsigned char *d_data;
    unsigned char *d_rgb;

    initCuda(h_data, h_rgb, d_data, d_rgb);
    while (1)
    {
        int ret = process_one_image(h_data, h_rgb, d_data, d_rgb);
    }
    FinalizeCuda(h_data, h_rgb, d_data, d_rgb);

}

Aqui você pode notar que quero cudaMallocapenas uma vez no arquivo C, para acelerar esse código, mas acho que não funcionou corretamente. Ele não relatou nenhum bug, mas não recebo nada do h_rgb.

Parece que (eu acho) durante o processamento cudaMemcpy, não foi possível encontrar o endereço correto d_datae copiá-lo para d_data.

Então, como posso corrigir esse bug, OU , é uma maneira adequada de executar cudaMallocapenas uma vez?

Todo o código está localizado em ffio key_file_path:

• ffio/ffio/ffio_c/ffio.c- correspondente ao c_code.carquivo de exemplo.
• ffio/ffio/ffio_c/yuv2rgb.cu- correspondente ao my_cuda.cuexemplo.

como executar todo o exemplo:

• ./compiler.shpara construir o arquivo executávelmain
• executar mainlocalizado emffio/ffio/ffio_c/test
• verifique a variável ffio->cudaFrameusando Ctrl+F