CUDA allocation de tableau de tableaux

J'ai un peu de difficulté à allouer tableau de tableaux dans CUDA.

void ** data;
cudaMalloc(&data, sizeof(void**)*N); //allocates without problems
for(int i = 0; i < N; i++) {
    cudaMalloc(data + i, getSize(i) * sizeof(void*)); //seg fault is thrown
}

Qu'ai-je tort?

Le point principal est que l'ensemble de ces tableaux est de taille différente.

OriginalL'auteur | 2009-12-02

Vous devez allouer les pointeurs pour un hôte de la mémoire, puis allouer de la mémoire de l'appareil pour chaque tableau et de le stocker du pointeur dans la mémoire hôte.
Ensuite allouer de la mémoire pour stocker les pointeurs dans le dispositif
puis copier l'hôte de la mémoire à la mémoire de l'appareil.
Un exemple vaut 1000 mots:

__global__ void multi_array_kernel( int N, void** arrays ){
    //stuff
}


int main(){

    const int N_ARRAYS = 20;
    void *h_array = malloc(sizeof(void*) * N_ARRAYS);
    for(int i = 0; i < N_ARRAYS; i++){
        cudaMalloc(&h_array[i], i * sizeof(void*));
        //TODO: check error
    }
    void *d_array = cudaMalloc(sizeof(void*) * N_ARRAYS);

    //Copy to device Memory
    cudaMemcpy(d_array, h_array, sizeof(void*) * N_ARRAYS, cudaMemcpyHostToDevice);

    multi_array_kernel<1,1>(N_ARRAYS, d_array);
    cudaThreadSynchronize();

    for(int i = 0; i < N_ARRAYS; i++){
        cudaFree(h_array[i]); //host not device memory
        //TODO: check error
    }
    cudaFree(d_array);
    free(h_array);
}

fabrizioM, pouvez-vous expliquer comment travailler sur chaque tableau une fois copiés sur l'appareil? je suis en train de faire quelque chose de mal quand j'essaie d'accéder à chaque tableau.
poser une nouvelle question à SI
Je suppose que tu veux dire N_ARRAYS au lieu de N dans votre fonction principale

OriginalL'auteur fabrizioM

4

Je ne crois pas que cela soit pris en charge. cudaMalloc() alloue de la mémoire de l'appareil, mais stocke l'adresse d'une variable sur l'ordinateur hôte. Dans ta boucle for, vous sont le passage d'adresses dans la mémoire de l'appareil.

En fonction de ce que vous voulez accomplir, vous pouvez allouer data avec la normale de l'hôte malloc() avant l'appel de la boucle for que vous avez actuellement. Ou allouer un seul gros bloc de mémoire de l'appareil et de calculer les décalages dans la main.

Regarder des Sections 2.4, 3.2.1 et B. 2.5 (en bas) de la Guide de Programmation CUDA pour plus de détails. Plus précisément, sur le bas de la page 108:

L'adresse obtenue en prenant l'adresse d'un __device__, __shared__ ou
__constant__ variable ne peut être utilisée dans le code de l'appareil.

Cela est correct. Le pointeur alloué par cudaMalloc doit résider dans la mémoire hôte et que vous voulez stocker ces pointeurs dans la mémoire de l'appareil. Au lieu de cela, vous devez créer un tableau de pointeurs sur l'hôte, puis le copier dans l'appareil à la fin, ou tout simplement calcul des décalages de Gabriel suggère.

OriginalL'auteur Gabriel
2

Je pense que dans la première boucle, il doit être &h_array[i] pas &d_array[i].

OriginalL'auteur Jamshidi

vous ne pouvez pas utiliser

cudaMalloc(&h_array[i], i * sizeof(void*));

pour tableau déclaré que void *

utilisation de type de données défini

CUdeviceptr *h_array = malloc(sizeof(CUdeviceptr *) * N);

int *h_array = malloc(sizeof(int *) * N);

et de le jeter aux void *

cudaMalloc((void *)&h_array[i], i * sizeof(void*));

OriginalL'auteur yurijgera

1

Fil similaire dans les forums de nvidia - http://forums.nvidia.com/index.php?showtopic=69403&st=20

OriginalL'auteur Sayan

J'ai eu le même Problème et a réussi à le résoudre.

FabrizioM réponse était un bon point de départ pour moi et m'a beaucoup aidé. Mais néanmoins, j'ai rencontré quelques problèmes quand j'ai essayé de transférer le code de mon projet. En utilisant le plus de commentaires, posts, j'ai été capable d'écrire un exemple de travail (VS2012, CUDA7.5). Donc je vais poster mon code supplémentaire comme réponse et comme point de départ pour d'autres.

Pour comprendre la désignation: je suis en utilisant un vecteur de OpenCV cv::Mat en entrée qui sont capturées à partir de plusieurs caméras et je suis le traitement de ces images dans le Noyau.

     void TransferCameraImageToCuda(const std::vector<cv::Mat*>* Images)
{

     int NumberCams     = Images->size();
     int imageSize      = Images->at(0)->cols*Images->at(0)->rows;

     CUdeviceptr*           CamArraysAdressOnDevice_H;
     CUdeviceptr*           CamArraysAdressOnDevice_D;


         //allocate memory on host to store the device-address of each array
         CamArraysAdressOnDevice_H = new CUdeviceptr[NumberCams];

         //allocate memory on the device and store the arrays on the device 
         for (int i = 0; i < NumberCams; i++){
             cudaMalloc((void**)&(CamArraysAdressOnDevice_H[i]), imageSize * sizeof(unsigned short));
             cudaMemcpy((void*)CamArraysAdressOnDevice_H[i], Images->at(i)->data, imageSize * sizeof(unsigned short), cudaMemcpyHostToDevice);
         }

         //allocate memory on the device to store the device-adresses of the arrays
         cudaMalloc((void**)&CamArraysAdressOnDevice_D, sizeof(CUdeviceptr*)* NumberCams);

         //Copy the adress of each device array to the device
         cudaMemcpy(CamArraysAdressOnDevice_D, CamArraysAdressOnDevice_H, sizeof(CUdeviceptr*)* NumberCams, cudaMemcpyHostToDevice);




}

Dans le noyau de lancement, je suis le casting du dispositif de pointeur vers le pointeur de type de données (unsigned short**)

DummyKernel<<<gridDim,blockDim>>>(NumberCams, (unsigned short**) CamArraysAdressOnDevice_D)

et le noyau de la définition est par exemple:

__global__ void DummyKernel(int NumberImages, unsigned short** CamImages)
{
    int someIndex = 3458;
    printf("Value Image 0 : %d \n", CamImages[0][someIndex]);
    printf("Value Image 1 : %d \n", CamImages[1][someIndex]);
    printf("Value Image 2 : %d \n", CamImages[2][someIndex]);
}

OriginalL'auteur Christian_B

Vous devez vous connecter pour publier un commentaire.