Reprise du message précédent :
Bonsoir messieurs,
Je suis heureux de voir que vous répondez
 
Alors à mon tour :
 
hephaestos :  
>> Tu me conseils de voir "les exemples donnés par le guide de programmation", mais quel guide ? Le guide CUDA sur le site nVidia officiel ?
>> "Il sera nettement plus rentable de les faire calculer au fur et à mesure des calculs par chacun des fils d'exécution de ton gpu. Ça t'évitera des accès mémoire dans la mémoire globale au coût prohibitif." Je prends note, merci.
>> "Et c'est vraiment très inélégant ces deux boucles for de construction et d'utilisation des vecteur." Je ne suis pas sûr de comprendre. Penses-tu qu'il serait plus intelligent de ne pas créer de vecteur et d'utiliser des valeurs qui seront générées au fur et à mesure de leur appellation ?
(>> Pour la langue française je suis conscient que je ne suis pas une bête, veux tu bien me préciser où se trouvent mes erreurs ? Ça m'aidera à les corriger, merci.)
 
bjone :
>> Je suis pour toute simplification ! Je vais voir ce que je peux faire au niveau de la factorisation. C'est vrai que j'ai balancé la formule comme calculée directement sans penser à la simplifier au maximum.
>>  Pour le resize() je me demande si en fait, il ne serait pas mieux de manipuler des vecteurs de taille fixe ( des tableaux ). Qu'en pensez vous ?
>> pour la boucle for et les /100, j'avais jamais pensé à utiliser autre chose que des nombre entiers je dois vous avouer ^^, je vais donc faire ceci :
for(double i = 0; i < C; i += 0.01){...}
Quel vision étroite de ma part !
 
J'ai apprécié tous vos commentaires et suggestions, et je vous en remercie.
 
PS : je crois que je vais virer les vecteurs, ils servent à rien en fait... j'essaye de faire un code trop propre mais là pour du calcul comme ça, je perds trop en performance.
 
J'ai vu le temps que ça me prenait sur mon Q6600 @ 3.6 GHz, il me faut 11 ans... Mais c'est sans parallélisation.

Après c'est toi de faire de voir si il y a des comportements prévisibles.
par exemple: au lieu de te balader par 0.01, tu te balades par 0.1 et quand tu tombes sur un taux d'erreur à moins de 20% tu refais la dernière portion par pas de 0.01....

Oui, tout à fait (cuda programming guide, je crois qu'il s'appelle).

Oui, c'est la meilleure solution ici. Si tu préférais, pour une raison ou pour une autre, construire d'abords les vecteurs puis les utiliser dans une autre boucle, tu gagnerais (en terme de performance) à construire ton vecteur en réservant à l'avance la place mémoire que tu sais avoir besoin, en appelant avant ta boucle de push_back(), un reserve() ; et dans la boucle qui utilise les vecteurs, tu ne devrais pas laisser en dur la taille de la boucle mais plutôt reprendre la taille de ton vecteur : for(unsigned int i=0;i<vecteur.size();++i)

En fait, c'est plutôt ta volonté de ne pas utiliser d'accents qui m'agace. Je suis contre cette habitude, c'est aux systèmes de se faire aux accents, ou aux utilisateurs de se faire à l'anglais. Le français contient des accents et puis c'est tout, je préfère voir des caractères à la con (qui apparaissent en général dans les messages des consoles quand on fait un cout<< "éèàô" ) que des mots sans accent, signe d'une renonciation. La seule vraie faute qui m'a choqué, c'est le 'garantit' dans ton premier commentaire.

Que si par tableau tu entends des trucs du style int[N], c'est une très mauvaise idée, tu n'y gagneras à peu près rien, et tu y perdras beaucoup.

des tableaux de cette taille vont péter ta pile. Utilise un vector mais fixe ca taille et utilise [].
 
Ensuite, au lieu d'ecrire dans le fichier a la volée, crée un vector de résultats et écris le en une fois.

Arrrghhh, je suis nouveau en cuda et j'essaye d'installer ça sur mon ordi. J'ai récupéré le toolkit et la sdk 3.2 sur le site nvidia, j'ai aussi téléchargé un ms visual studio 2008 exprès pour l'occasion. Mais rien n'y fait ca ne fonctionne pas. error LNK à tout va.
Quelqu'un saurait comment faire du CUDA sous un autre éditeur ? ou aurais un tutoriel propre pour l'instalation de CUDA sous VS2008?
 
Je crois que l'un de mes gros pb est que lors de l'installation de la SDK il m'installe un bout de Visual Studio 2005 alors que j'ai déjà la version 2008 d'installer..

erreur de link, tu n'as sans doute pas ajouté la bonne bibliothèque dans ton projet (cudart.lib) ?

j'ai envie d'essayer http://code.google.com/p/copperhead/ ou pycuda
Qqun s'est déjà lancé ?

C'est exactement ca, il me manque cudart.lib ... mais j'ai essayé de rajouter ce fichier à certains endroits mais rien y fait...
Que dois je faire ? (j'imagine que c'est rajouter un chemin d'accès vers l'endroit où sont cachés ces librairies non?)
 
D'ailleurs lorsque je fais tourner le deviceQuery, ca fonctionne sans pb..

dans les propriétés du projet, section répertoires c++ (un truc comme ça) tu as les chemins des bibliothèques qui doit contenir le chemin du répertoire où se trouve cudart.lib. et dans les options du linker il y a un champs dans lequel il faut préciser que tu utilises cudart.lib.

Bon alors, ca fonctionne à moitié.
Quand je compile le fichier vectorAdd proposé par la SDK voici ce que ca me sort :
 
1>------ Début de la génération : Projet : vectorAdd, Configuration : Release Win32 ------
1>Compiling with CUDA Build Rule...
1>"C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v3.2\\bin\nvcc.exe"    -gencode=arch=compute_10,code=\"sm_10,compute_10\" -gencode=arch=compute_20,code=\"sm_20,compute_20\"  --machine 32 -ccbin "C:\Program Files\Microsoft Visual Studio 9.0\VC\bin"    -Xcompiler "/EHsc /W3 /nologo /O2 /Zi   /MT  " -I"C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v3.2\/include" -I"./" -I"../../common/inc" -I"../../../shared/inc" -I"C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v3.2\\include" -maxrregcount=32  --compile -o "Release/vectorAdd.cu.obj" vectorAdd.cu  
1>vectorAdd.cu
1>tmpxft_00003d24_00000000-6_vectorAdd.compute_20.cudafe1.gpu
1>tmpxft_00003d24_00000000-10_vectorAdd.compute_20.cudafe2.gpu
1>vectorAdd.cu
1>tmpxft_00003d24_00000000-3_vectorAdd.compute_10.cudafe1.gpu
1>tmpxft_00003d24_00000000-14_vectorAdd.compute_10.cudafe2.gpu
1>vectorAdd.cu
1>vectorAdd.cu
1>tmpxft_00003d24_00000000-6_vectorAdd.compute_20.cudafe1.cpp
1>tmpxft_00003d24_00000000-23_vectorAdd.compute_20.ii
1>Le journal de génération a été enregistré à l'emplacement "file://c:\ProgramData\NVIDIA Corporation\NVIDIA GPU Computing SDK 3.2\C\src\vectorAdd\Release\BuildLog.htm"
1>vectorAdd - 0 erreur(s), 0 avertissement(s)
========== Génération : 1 a réussi, 0 a échoué, 0 mis à jour, 0 a été ignoré ==========
 
Ensuite lorsque je génère le projet (en Release win32, l'autre option est x64 mais ca ne fonctionne pas) j'obtiens :
plein de lignes puis :
2>vectorAdd - 0 erreur(s), 0 avertissement(s)
========== Génération : 2 a réussi, 0 a échoué, 1 mis à jour, 0 a été ignoré ==========
 
Ensuite je ne sais pas quoi faire pour afficher le résultat. lorsque je fais ctrl + F5 j'ai un message d'erreur qui me dit "en gros" que RegSvr32 ne fonctionne pas comme il faut...
 
 
Bref j'imagine que si j'en suis arrivé là ca doit être simple, malheureusement je ne sais absolument pas quoi faire.  

le plus simple c'est de passer sous linux )

Bonjour,
 
Je rencontre un petit problème lors de l'exécution d'un kernel d'addition entre deux matrices:
 
#define BLOCK_SIZE 16
 
#define IDX(i,j,nbColonnes) (i*nbColonnes+j)
 
__global__ void matAddKernel(double* A, double* B, double* C,int nbLignes, int nbColonnes)
{
 int i=blockIdx.y*BLOCK_SIZE+threadIdx.y;
 int j=blockIdx.x*BLOCK_SIZE+threadIdx.x;
 
 //Code provenant de la doc Cuda:
 /*
 int i=blockIdx.x*BLOCK_SIZE+threadIdx.x;
 int j=blockIdx.y*BLOCK_SIZE+threadIdx.y;
 */  
 
 if(i<nbLignes && j<nbColonnes)
  C[IDX(i,j,nbColonnes)]=A[IDX(i,j,nbColonnes)]+B[IDX(i,j,nbColonnes)];
}
 
Appel du kernel:
 
dim3 nbThreadsParBloc (BLOCK_SIZE,BLOCK_SIZE);
dim3 nbBloc ( ceil(N/(float)nbThreadsParBloc.x) , ceil(M/(float)nbThreadsParBloc.y) );
 
matAddKernel<<<nbBloc,nbThreadsParBloc>>>(A_d,B_d,C_d,N,M);
 
Le problème est le suivant :  
 
Par une simple modification d'indices dans le kernel proposé par la doc Cuda (on inverse le rôle de i et j), ce qui paraît plus "logique" mathématiquement ; i représentant la ligne et j la colonne, le résultat est plus rapide mais donne un résultat faux pour des matrices de taille supérieure à 128*128.
Par contre, en passant en float, j'arrive à trouver de bon résultats, avec un temps d'execution très rapide pour des matrices de taille 4096*4096. (environ 40 fois plus rapide que sur le CPU).
 
De quoi viendrait ce problème? Peut-être lié à l'accès mémoire?
Comment se fait cet accès?
 
Merci pour toutes vos remarques.