0

Matlab で使用するフォアグラウンド抽出カーネルを作成しましたが、何も出力されなかったので、それを純粋な Cuda C に移植し、ほとんどのロジックを削除しました。このことは何もしていません。リターンの前に cuPrintf ステートメントを出力することさえありません。

#include <cuda.h>
#include <stdio.h>      /* printf, scanf, NULL */
#include <stdlib.h>     /* calloc, exit, free */
#include "cuPrintf.cu"
#include "utils.h" 
#include <time.h>       /* clock_t, clock, CLOCKS_PER_SEC */



__global__ void foreground_extract(      unsigned char* inputImageRed,
                                         unsigned char* inputImageGreen,
                                         unsigned char* inputImageBlue,

                                         unsigned char* outputImageRed,
                                         unsigned char* outputImageGreen,
                                         unsigned char* outputImageBlue,                                          

                                         const int xDim, 
                                         const int yDim)
{


    cuPrintf("print something \n");
    //x = col, y = row
    //xDim = col_dim, yDim = row_dim
    int x = threadIdx.x + blockIdx.x * blockDim.x;
    int y = threadIdx.y + blockIdx.y * blockDim.y;
    int offset = x + y *blockDim.x *gridDim.x;

    int nnodes = xDim*yDim;
    if (offset >= nnodes) return;


    //test equality

    outputImageRed[offset] = inputImageRed[offset];
    outputImageGreen[offset] = inputImageGreen[offset];
    outputImageBlue[offset] = inputImageBlue[offset];

    cuPrintf("print something here too \n");
    cuPrintf("%d \n", outputImageRed[offset]);

}

int main()
{

        int xDim = 3;
        int yDim = 3;

                                         unsigned char* h_inputImageRed;
                                         unsigned char* h_inputImageGreen;
                                         unsigned char* h_inputImageBlue;

                                         unsigned char* h_outputImageRed;
                                         unsigned char* h_outputImageGreen;
                                         unsigned char* h_outputImageBlue;


                    h_inputImageRed = (unsigned char*) calloc ((xDim*yDim), sizeof(unsigned char));
                    h_inputImageGreen = (unsigned char*) calloc ((xDim*yDim), sizeof(unsigned char));
                    h_inputImageBlue = (unsigned char*) calloc ((xDim*yDim), sizeof(unsigned char));

                    h_outputImageRed = (unsigned char*) calloc ((xDim*yDim), sizeof(unsigned char));
                    h_outputImageGreen = (unsigned char*) calloc ((xDim*yDim), sizeof(unsigned char));
                    h_outputImageBlue = (unsigned char*) calloc ((xDim*yDim), sizeof(unsigned char));


      //initiate input only 
      unsigned char init =0;
      for (int i=0; i<(xDim*yDim);i++){

                                          h_inputImageRed[i] = init;
                                          h_inputImageGreen[i] = init;
                                          h_inputImageBlue[i] = init;

                                          init++;

                                          printf("%d\n", h_inputImageRed[i]);

      }

                                         //device arrays
                                         unsigned char* d_inputImageRed;
                                         unsigned char* d_inputImageGreen;
                                         unsigned char* d_inputImageBlue;

                                         unsigned char* d_outputImageRed;
                                         unsigned char* d_outputImageGreen;
                                         unsigned char* d_outputImageBlue;


     //cudaMallocs

     checkCudaErrors(cudaMalloc((void**)&d_inputImageRed, (sizeof(unsigned char)*xDim*yDim)));
     checkCudaErrors(cudaMalloc((void**)&d_inputImageGreen, (sizeof(unsigned char)*xDim*yDim)));
     checkCudaErrors(cudaMalloc((void**)&d_inputImageBlue, (sizeof(unsigned char)*xDim*yDim)));

     checkCudaErrors(cudaMalloc((void**)&d_outputImageRed, (sizeof(unsigned char)*xDim*yDim)));
     checkCudaErrors(cudaMalloc((void**)&d_outputImageGreen, (sizeof(unsigned char)*xDim*yDim)));
     checkCudaErrors(cudaMalloc((void**)&d_outputImageBlue, (sizeof(unsigned char)*xDim*yDim)));

     //cudaMemcpys, Host to Device

     checkCudaErrors(cudaMemcpy(d_inputImageRed, h_inputImageRed, (sizeof(unsigned char)*xDim*yDim), cudaMemcpyHostToDevice));
     checkCudaErrors(cudaMemcpy(d_inputImageGreen, h_inputImageGreen, (sizeof(unsigned char)*xDim*yDim), cudaMemcpyHostToDevice));
     checkCudaErrors(cudaMemcpy(d_inputImageBlue, h_inputImageBlue, (sizeof(unsigned char)*xDim*yDim), cudaMemcpyHostToDevice));

     checkCudaErrors(cudaMemcpy(d_outputImageRed, h_outputImageRed, (sizeof(unsigned char)*xDim*yDim), cudaMemcpyHostToDevice));
     checkCudaErrors(cudaMemcpy(d_outputImageGreen, h_outputImageGreen, (sizeof(unsigned char)*xDim*yDim), cudaMemcpyHostToDevice));
     checkCudaErrors(cudaMemcpy(d_outputImageBlue, h_outputImageBlue, (sizeof(unsigned char)*xDim*yDim), cudaMemcpyHostToDevice));

     cudaPrintfInit();

     int gridSizeX = ceil(float(xDim/8));
     int gridSizeY = ceil(float(yDim/8));
     int gridSizeZ = 1;

     int blockSizeX=8;
     int blockSizeY=8;
     int blockSizeZ=1;

     const dim3 gridSize(gridSizeX,gridSizeY,gridSizeZ);
     const dim3 blockSize(blockSizeX,blockSizeY,blockSizeZ);

     foreground_extract <<< gridSize, blockSize >>>(d_inputImageRed,
                                                    d_inputImageGreen,
                                                    d_inputImageBlue,

                                                    d_outputImageRed,
                                                    d_outputImageGreen,
                                                    d_outputImageBlue,

                                                    xDim,yDim);


      cudaPrintfDisplay(stdout,true);
      cudaPrintfEnd();

      checkCudaErrors(cudaMemcpy(h_outputImageRed, d_outputImageRed, (sizeof(unsigned char)*xDim*yDim), cudaMemcpyDeviceToHost));
      checkCudaErrors(cudaMemcpy(h_outputImageGreen, d_outputImageGreen, (sizeof(unsigned char)*xDim*yDim), cudaMemcpyDeviceToHost));
      checkCudaErrors(cudaMemcpy(h_outputImageBlue, d_outputImageBlue, (sizeof(unsigned char)*xDim*yDim), cudaMemcpyDeviceToHost));

      //free gpu data
     checkCudaErrors( cudaFree(d_outputImageRed) );
     checkCudaErrors( cudaFree(d_outputImageGreen) );
     checkCudaErrors( cudaFree(d_outputImageBlue) );
     checkCudaErrors( cudaFree(d_inputImageRed) );
     checkCudaErrors( cudaFree(d_inputImageGreen) );
     checkCudaErrors( cudaFree(d_inputImageBlue) );

     //free host data
     free(h_outputImageRed);
     free(h_outputImageGreen);
     free(h_outputImageBlue);
     free(h_inputImageRed);
     free(h_inputImageGreen);
     free(h_inputImageBlue);



      while(true){}
      return 0;
}
4

1 に答える 1

3

カーネルが起動していないため、カーネルの printf から出力が得られません。カーネルの起動時に適切なcuda エラー チェック を行うと、これを発見できます。

カーネルの起動によって返されるエラーはinvalid configuration argument.

gridSize.xとに無効な値を渡しています gridSize.y。

それらが何であるかを確認したい場合は、カーネルを呼び出す前にそれらを印刷してください。(一般的なデバッグのヒント。)

あなたが考えていることをしていないので、この行を見てみましょう:

 int gridSizeX = ceil(float(xDim/8));
                              ^  ^
                              both values inside the parenthesis are *integers*

xDimこれらの値 (または8)のどちらも にキャストしていませんfloat。そのため、ホスト コンパイラは、整数除算を使用して括弧内の数量を解決します。3/8 の整数除算はゼロです。その後は何も値を変更しません。まだゼロ。

于 2013-06-02T03:39:52.930 に答える