Dla porządku jest to praca domowa, więc pomóż tak mało lub tyle z tym. Używamy stałej pamięci do przechowywania „matrycy maski”, która będzie używana do wykonywania splotu na większej macierzy. Kiedy jestem w kodzie hosta, kopiuję maskę do stałej pamięci za pomocą cudaMemcpyToSymbol ().

Moje pytanie brzmi: kiedy to zostanie skopiowane i uruchomię kod jądra urządzenia, w jaki sposób urządzenie wie, gdzie uzyskać dostęp do stałej macierzy maski pamięci. Czy istnieje wskaźnik, który muszę przekazać podczas uruchamiania jądra. Większość kodu, który podał nam profesor, nie powinna być zmieniana (nie ma wskaźnika do maski), ale zawsze istnieje możliwość, że popełnił błąd (chociaż najprawdopodobniej rozumiem coś)

Czy stała deklaracja pamięci powinna być zawarta w oddzielnym pliku kernel.cu?

Minimalizuję kod, aby pokazać rzeczy związane ze stałą pamięcią. W związku z tym nie należy wskazywać, czy coś nie zostało zainicjalizowane. Jest na to kod, ale w tej chwili nie ma to znaczenia.

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:TO JEST, GDZIE NIE WIEM JAK DOSTĘP DO PAMIĘCI STAŁEJ.

//__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;

}