Discussion :

[brugere]

Bonjour !

Je travaille actuellement à la création d'une librairie C++ (sous linux) qui utilise CUDA pour une partie des calculs. Tout ceci est effectué avec l'IDE QtCreator et donc l'utilisation de l'API qui va avec.

Je vous expose donc mon problème :
Lors d'une étape du calcul j'instancie un thread pour garder la main
Dans le thread j'appelle une fonction CUDA définie dans un fichier .cu
A la suite de cette instruction je recopie le résultat et termine le thread.

Mais les instructions suivant l'appel CUDA ne sont jamais exécutées, je l'ai vérifié à l'aide de gdb (quand l'appel est commenté les points d'arrêt sont atteints mais sinon ils ne sont jamais rencontrés)

Je me doute qu'il y a une explication enfantine mais j'avoue avoir atteint les limites de ma patience pour le moment Si jamais l'un de vous avait une info ou un bon lien à m'indiquer je serais preneur !

Merci d'avance.

[EDIT: un petit bout de code]

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
 
void FonctionPrincipale(){
  QMutexLocker ml(&mMutex);
  WorkThread* wthread = new WorkThread(this);
  wthread->start();
}
 
void WorkThread::run()
{
  //initialisation de variables
  FonctionCuda(Parametre p1);
  //autres instructions jamais exécutées
}
 
/**Fichier .cu **/
__host__ void FonctionCuda(Parametre p1)
{
  double *a_cuda;
    double *b_cuda;
    unsigned int nBytes = sizeof(double) * n;
    int threadsPerBlock = 256;
    int blocksPerGrid   = (n + threadsPerBlock - 1) / threadsPerBlock;
 
    // allocate and copy memory into the device
    cudaMalloc((void **)& a_cuda, nBytes);
    cudaMalloc((void **)& b_cuda, nBytes);
    cudaMemcpy(b_cuda, a, nBytes, cudaMemcpyHostToDevice);
    compute<<<blocksPerGrid, threadsPerBlock>>>(b_cuda,a_cuda);
    cudaMemcpy(a, a_cuda, n*sizeof(double),cudaMemcpyDeviceToHost);
    cudaFree(a_cuda);
    cudaFree(b_cuda);
}

[gbdivers]

Bonjour et bienvenue sur le forum

Classiquement, c'est un problème de config de ta compilation. Tu appelles comment nvcc ?

Sinon, les appels des fonctions cuda est asynchrone, ça ne sert à rien de threader les appels (sauf si tu mets des barrières... mais ça serait idiot de mettre des barrières pour mettre dans un threas après)

[LinuxUser]

On peut voir le kernel?

Et où est déclaré ce que tu copies sur le device, ta variable appelée "a"?

[brugere]

Bonjour à vous deux et merci pour vos réponses

On peut voir le kernel?

Et où est déclaré ce que tu copies sur le device, ta variable appelée "a"?

La variable est déclarée dans le run du WorkThread
Le kernel est un "dummie krenel" il ne fait que faire l'addition du tableau avec lui-même. Par ailleurs il fonctionne, car si je fait des affichages du tableau "a" j'ai bien des résultats cohérents. Le code que je vous ai fourni se veut descriptif car je ne peux pas fournir le "vrai" code (employeur tatillon )

Bonjour et bienvenue sur le forum

Classiquement, c'est un problème de config de ta compilation. Tu appelles comment nvcc ?

Sinon, les appels des fonctions cuda est asynchrone, ça ne sert à rien de threader les appels (sauf si tu mets des barrières... mais ça serait idiot de mettre des barrières pour mettre dans un threas après)

Pour ce qui est de l'appel à nvcc il est fait à l'aide de QMake, je me suis inspiré du Tutoriel Cuda partie VII-C.

Pour ce qui est du threading, mon projet est un "plugin" qui doit s'imbriquer dans une application lourde en C++. Cette dernière doit effectuer des appel asynchrones pour le lancement des calculs car il y aura plusieurs plugins différents. C'est pour cela que je crée un thread pour le travail. Il y aurait peut-être une meilleur solution ?

Je vais me concentrer sur la configuration de ma compilation et reviendrais vers vous quand j'aurais progressé

Merci encore !

[EDIT] J'oubliais, j'ai créé un mutex que je bloque avant d'appeler thread.start(); mais comme l'appel de la fonction Cuda est asynchrone je ne peux pas être assuré que cette dernière sera terminée ... je vais creuser de ce coté

[backlash]

As-tu lu la doc?

Si la fonction est asynchrone alors il y a forcément un mécanisme pour savoir quand les résultats sont disponible.

[brugere]

Bon, en réalité ce que je pensais être un problème, n'était qu'une exécution normale (je ne suis pas encore assez familier avec Cuda).

Le réel problème était l'accès à une variable par le main alors que cette dernière devait être remplie par la partie cuda du programme (qui était alors toujours en cours d'exécution). Je pensais avoir correctement effectué le contrôle à l'aide de mutex mais ça n'était pas exact. Du coup en bloquant et débloquant mon mutex "à la main" (sans utiliser le QMutexLocker) cela fonctionne parfaitement.

Merci encore à vous deux de m'avoir accompagné dans ma réflexion

[EDIT] @Backlash : tu avais raison

[gbdivers]

A lire : CUDA C Programming Guide - Asynchronous Concurrent Execution, en particulier les parties sur __syncthreads() et les events