Für die Aufzeichnung ist dies eine Hausaufgabe, also helfen Sie so wenig oder so viel dabei. Wir verwenden einen konstanten Speicher, um eine "Maskenmatrix" zu speichern, die verwendet wird, um eine Faltung auf einer größeren Matrix durchzuführen. Wenn ich mich im Host-Code befinde, kopiere ich die Maske mithilfe von cudaMemcpyToSymbol () in den konstanten Speicher.

Meine Frage ist, sobald dies kopiert wurde und ich meinen Gerätekernelcode starte, woher das Gerät weiß, wo es auf die konstante Speichermaskenmatrix zugreifen soll. Gibt es einen Zeiger, den ich beim Start des Kernels übergeben muss? Der größte Teil des Codes, den der Professor uns gegeben hat, sollte nicht geändert werden (es gibt keinen Hinweis auf die übergebene Maske), aber es besteht immer die Möglichkeit, dass er einen Fehler gemacht hat (obwohl es sehr wahrscheinlich ist, dass ich etwas verstehe).

Soll die Konstante memeory declaratoin in der separaten Datei kernel.cu enthalten sein?

Ich minimiere den Code, um nur die Dinge zu zeigen, die mit dem konstanten Speicher zu tun haben. Als solches weisen Sie bitte nicht darauf hin, dass etwas nicht initialisiert ist. Es gibt Code dafür, aber das ist derzeit nicht von Belang.

main.cu:

#include <stdio.h>
#include "kernel.cu"

__constant__ float M_d[FILTER_SIZE * FILTER_SIZE];

int main(int argc, char* argv[])
{

     Matrix M_h, N_h, P_h; // M: filter, N: input image, P: output image

    /* Allocate host memory */
    M_h = allocateMatrix(FILTER_SIZE, FILTER_SIZE);
    N_h = allocateMatrix(imageHeight, imageWidth);
    P_h = allocateMatrix(imageHeight, imageWidth);

    /* Initialize filter and images */
    initMatrix(M_h);
    initMatrix(N_h);


    cudaError_t cudda_ret = cudaMemcpyToSymbol(M_d, M_h.elements, M_h.height * M_h.width * sizeof(float), 0, cudaMemcpyHostToDevice);
    //char* cudda_ret_pointer = cudaGetErrorString(cudda_ret);

    if( cudda_ret != cudaSuccess){
        printf("\n\ncudaMemcpyToSymbol failed\n\n");
        printf("%s, \n\n", cudaGetErrorString(cudda_ret));
    }


    // Launch kernel ----------------------------------------------------------
    printf("Launching kernel..."); fflush(stdout);

    //INSERT CODE HERE
    //block size is 16x16
    //              \\\\\\\\\\\\\**DONE**
    dim_grid = dim3(ceil(N_h.width / (float) BLOCK_SIZE), ceil(N_h.height / (float) BLOCK_SIZE));
    dim_block = dim3(BLOCK_SIZE, BLOCK_SIZE);



    //KERNEL Launch

    convolution<<<dim_grid, dim_block>>>(N_d, P_d);

    return 0;
}

kernel.cu:Hier weiß ich nicht, wie ich auf den konstanten Speicher zugreifen kann.

//__constant__ float M_c[FILTER_SIZE][FILTER_SIZE];

__global__ void convolution(Matrix N, Matrix P)
{
    /********************************************************************
    Determine input and output indexes of each thread
    Load a tile of the input image to shared memory
    Apply the filter on the input image tile
    Write the compute values to the output image at the correct indexes
    ********************************************************************/

    //INSERT KERNEL CODE HERE

    //__shared__ float N_shared[BLOCK_SIZE][BLOCK_SIZE];


    //int row = (blockIdx.y * blockDim.y) + threadIdx.y;
    //int col = (blockIdx.x * blockDim.x) + threadIdx.x;

}