Temps de calcul en parallèle

Bonjour, j'ai créé mon premier programme CUDA c'est un simple programme qui calcul les cosinus de 0 à 360, c'est juste question d'apprendre le langage. J'ai conçu le programme avec Visual studio Community 2015 en C++, j'ai installé le SDK CUDA. Mon programme fonction il affiche bien les 361 cosinus mais les calculs sont lent 100 000 microsecondes contrairement a mon 2eme programmes qui lui fais le calcul cosinus par le processeur en moins de 10 microsecondes. Mon processeur est un i7 3770 et ma carte graphique une Nvidia 980. Pour faire mon programme je me suis servi du projet contenu en exemple dans Visual Studio qui lui fait des additions. Si quelqu'un a des explications sur le sujet je l'en remercie.:calim2:

Bonjour,
je pense que cela vient de tes cudaMemcpy si tu en as. Sinon peux-tu monter ton code ? Ça m’intéresse beaucoup de voir ce que tu as fais.

J'ai actuellement le même problème et je suis quasiment sur que le problème viens de l'utilisation de la mémoire partagé :

https://devblogs.nvidia.com/parallel...memory-cuda-cc

Merci pour le lien j'ai laissais un moment ce programme, je vais essayer de mis remettre mais il me faudrait une idée de projet. Pour le code je me suis servi du code en exemple dans le SDK quand on créait un nouveau projet celui sur les additions moi c'est des cos.

Content que tu t'y remette.
De mon côté je programme des réseaux de neurones mais mon code est trop lent ("seulement" 20 000 étapes par secondes pour un réseaux de 480 neurones). En gros je ne lis qu'environ une fois ma base de données par seconde mais je suis sur qu'en cuda et en stockant mes données en RAM plutôt que sur le disque je peux améliorer la vitesse de mon algorithme par 50 (enfin théoriquement).

PS : Vérifie aussi tes options de compilation quand tu compiles pour comparer la vitesse.

C'est sur qu'une base de donnée sur disque ca flingue la vitesse par rapport à l'enorme vitesse de la carte graphique il faudrait effectivement créer la base en RAM avec une copie sur disque donc il faut utiliser un OS Linux et creer un dossier en RAM avec la base. Je connais pas les réseaux de neurones ca avoir avec l'intelligence artificielle ou c'est du calcul en masse ou autre chose. Ces dernieres semaines j'ai fais un programme grand public pour faire de l'encodage nvidia ca marche bien ca encode à environ 20X une video 720p. j'ai réutilisé des programmes pour le faire j'ai pas fait de cuda c'était deja fait. J'avais un projet professionnel intéressant avec une entreprise d'analyse bio que j'ai contacté pour essayer d'obtenir un fichier d'analyse pour faire des test de developpement à la maison et les recontacter si c'est concluant, l'entreprise ne m'a meme pas répondu, c'est triste qu'en France on ne vous prenne pas au sérieux si vous ne venez pas d'une grosse boite c'était pour le coup de gueule, c'est un beau projet mais pas de données sources pour faire des test et des comparaisons.

Effectivement ca a l'air d'etre cudaMalloc qui rallonge le temps car j'ai relevé le temps sans prendre en compte le cudaMalloc et je suis à 21 microsecondes au lieu de 150 000 quand meme, c'est étonnant je vais me penché sur la doc que tu m a donné :mrgreen: j'ai aussi regardé les paramètres de compilation et fais des test mais ca n'a rien donné.

temps calculs CUDA parallèle uniquement = 20 microsecondes
temps calculs CUDA parallèle + cudaMemcpy = 180 microsecondes
temps calculs CUDA parallèle + cudaMemcpy + cudaMalloc = 150000 microsecondes

Mon problème de lenteur ne viens ni de cudaMemcpy ni de cudaMalloc mais du coup je sais pas trop d'ou ça viens,je pense que ça viens de la mémoire partagée, enfin bref.
De toute façon pour la base de données j'ai pas besoin de passer sous linux car ma carte graphique à 2Go de mémoire vidéo et je n'ai qu'à peine 10 Mo de données. Je vais donc tout copier dans la RAM de ma carte graphique.

Sinon oui les réseaux de neurones c'est fait pour faire de l'IA, dans mon cas je suis en train de créer une IA sur Street FIghter 5.

Mon code semble exact puisse que c'est quasiment l'identique à celui sur les additions livrer avec le SDK qui n'a aucune raison d'être mal codé, j'ai fais d'ailleurs une mesure de temps sur le programme du SDK et je trouve les mêmes conclusions qu'avec le miens à savoir de grosses valeurs dans les 100000, dois je en conclure que mon programme n'a aucun problème, peut être la compilation ? Ca rend fou lol quand tout à l air bon :aie: comment dire j'ai l'impression d'avancer sans avancer la 4eme dimension.

Mesure de temps :

Première méthode :

#include "cuda_runtime.h"
#include <chrono>
using namespace std::chrono;

DEBUT DU CODE :
auto temps = duration_cast<microseconds>(high_resolution_clock::now() - t1).count();

ENDROIT OU ON VEUT MESURER LE TEMPS :
auto temps = duration_cast<microseconds>(high_resolution_clock::now() - t1).count();

TEMPS VISIBLEMENT EN MICROSECONDES : printf("\nTemps : %lld microsecondes \n", temps);

Temps total : 150000 microsecondes
Sans les cudaMalloc : 180 microsecondes
Seulement le 2eme cudaMalloc : 300 microsecondes
Uniquement les 361 calculs : 20 microsecondes

Ca à l'air de ralentir au premier cudaMalloc : cudaStatus1 = cudaMalloc( (void**)&dev_c , size * sizeof(float) );
Le deuxieme cudaMalloc ralentie bien moins : cudaStatus = cudaMalloc((void**)&dev_angle, size * sizeof(int));



Deuxième méthode :

#include "cuda_runtime.h"
#include <chrono>
using namespace std::chrono;

DEBUT DU CODE :
cudaEvent_t start, stop;
cudaEventCreate(&start);
cudaEventCreate(&stop);

cudaStatus = cudaDeviceSynchronize();
cudaEventRecord(start, 0);

ENDROIT OU ON VEUT MESURER LE TEMPS :
cudaEventRecord(stop, 0);
cudaEventSynchronize(stop);
float temps;
cudaEventElapsedTime(&temps, start, stop);

TEMPS : printf("\nTemps : %f microsecondes \n", temps);

Temps total : approximativement 1.05 il semble que se soit des millisecondes
Sans les cudaMalloc : 0.10 millisecondes
Seulement le 2eme cudaMalloc : 0.12 millisecondes
Uniquement les 361 calculs : 0.0075 millisecondes

Le 2 méthodes de temps ne me donne pas les mêmes valeurs j'y comprend plus rien.
 

Tout d'abord regarde si tu n'est pas en mode debug ou autre, vérifie bien tes options de compilation.

Essaye de voir si tu fais beaucoup plus de calculs, à mon avis utiliser un GPU pour calculer seulement 360 cosinus n'est pas rentable. Le GPU est plus rapide uniquement sur beaucoup de calculs.

Et si tu calculs par exemple 1 000 000 de cosinus, le CPU est-il toujours plus rapide que le GPU ?

PS : Sinon tu ne peut pas nous montrer tout ton code, ça permettrais peut-être de mieux voir ce qui ne va pas.

J'ai effectué 1000 fois le calcul de cos(0) à cos(360) en calcul CUDA en Release x86


cudaError_t CosinusCuda(float *c, int *AngleDegre, unsigned int s)
{
int *dev_angle = 0;
float *dev_c = 0;
cudaError_t cudaStatus;

cudaSetDevice(0);

//TEMPS
high_resolution_clock::time_point t = high_resolution_clock::now();

// Alloue de la memoire pour les données
cudaStatus = cudaMalloc((void**)&dev_c, s * sizeof(float));
cudaStatus = cudaMalloc((void**)&dev_angle, s * sizeof(int));

//TEMPS
high_resolution_clock::time_point TempsApresCudaMalloc = high_resolution_clock::now();

cudaStatus = cudaMemcpy(dev_angle, AngleDegre, s * sizeof(int), cudaMemcpyHostToDevice);

// On execute 1000 fois les 1000 calculs
for (int k = 0; k < 1000; k++)
{
// calcul parallele de cos(0) à cos(360)
cosinus << < 1, s >> > (dev_c, dev_angle);
cudaStatus = cudaDeviceSynchronize();
}

cudaStatus = cudaMemcpy(c, dev_c, s * sizeof(float), cudaMemcpyDeviceToHost);

//Calcul le temps d'execution du calcul parallele
auto temps = duration_cast<microseconds>(high_resolution_clock::now() - t).count();
auto TempsApres_CudaMalloc = duration_cast<microseconds>(high_resolution_clock::now() - TempsApresCudaMalloc).count();

printf("\nTemps des calculs cos : %lld \n", temps);
printf("\nTemps sans Malloc des calcul cos : %lld \n", TempsApres_CudaMalloc);

cudaFree(dev_c);
cudaFree(dev_angle);

return cudaStatus;
}

//Affichage à l'execution du code
Temps des calculs cos : 132684

Temps des calcul cos sans cudaMalloc : 41269


//Si on execute 1 fois cos(0) à cos(360)
Temps des calculs cos : 89155

Temps sans Malloc des calcul cos : 220


J'ai effectué 1000 fois le calcul de cos(0) à cos(360) en calcul CPU en Release x86

int main()
{
float c[1001] = { 0 };

//Temps
high_resolution_clock::time_point t1 = high_resolution_clock::now();

int i = 0;
int k = 0;

//1000 fois cos(0) à cos(360)
for (i = 0; i < 1000; i++)
{
for (k = 0; k < 361; k++)
{
c[k] = cos(0.01745329251994329576923690768489 * k);
}
}

//Calcul Temps en microsecondes entre temps t1 et t2
high_resolution_clock::time_point t2 = high_resolution_clock::now();

auto duration = duration_cast<microseconds>(t2 - t1).count();

k = 0;

for (k = 0; k < 361; k++)
{
printf("cos(%d) = %f \n", k, c[k]);
}

printf("Temps : %d", duration);

return 0;
}

//Affichage à l'execution du code
Temps : 109

//Si on execute 1 fois cos(0) à cos(360)
Temps des calculs cos : 4

CONCLUSION dans ce cas avec mes paramétrages le CPU est beaucoup plus rapide que le GPU pour le calcul de 1000 fois cos(0) à cos (360) donc il est fort possible qu'il y est un probleme dans mes parametrages CUDA, je pense par contre que le code est exact, les calculs CPU sont performants, étonnant ???

REMARQUE le temps est en Microsecondes il me semble.

le compilateur :

CUDACOMPILE : nvcc warning : The 'compute_20', 'sm_20', and 'sm_21' architectures are deprecated, and may be removed in a future release (Use -Wno-deprecated-gpu-targets to suppress warning).

J'ai vue ou c'est y a 2 champs un que je peux modifier et l'autre que je ne peux pas modifier car grisé

LINK : /LTCG spécifié mais aucune génération de code requise*; supprimez /LTCG de la ligne de commande de l'édition de liens pour améliorer les performances de l'éditeur de liens

Je ne sais pas ce que sait , merci pour quelques explications :D

En gros tu passes de 109 ms SUR GPU à 220 ms sur GPU, du coup c'est 2 fois plus long sur GPU. Sachant que la fréquence d'un GPU et à peu près 2 fois plus lent qu'un CPU c'est comme si aucune parallélisation n'était effectuer ...


Tu peux tester ça si tu veux mais je ne suis pas sur que ça aide beaucoup ...

Au lieu de faire une boucle de 1 à 1000 fait plutôt :

Code:

---

cosinus <<<1000, s>>> (dev_c, dev_angle);

---

ou ça :

Code:

---

cosinus <<<100, 10*s>>> (dev_c, dev_angle);

---

ou encore :

Code:

---

cosinus <<<10, 100, s>>> (dev_c, dev_angle);

---

Et retire ça :

Code:

---

cudaDeviceSynchronize();

---

Car la synchronisation est déjà faite de base quand tu sort de ta fonction __global__

PS : En ce moment j'ai pas trop le temps mais vers mi-août je me consacrerai 100% à la résolution de ce problème ;)

merci Matthieu76 j'avais pas pensé à ta première solution cosinus <<<1000, s>>> (dev_c, dev_angle); qui me plait bien :D et toi c'est quoi tes difficultés sur ton projet. Si t'as des références de livres intéressants sur CUDA je suis preneur, quasiment tous ceux que j'ai vu sont en anglais je crois que je vais devoir faire avec l'anglais :(

Oui, si tu fais de l'informatique va falloir te mettre à l'anglais, si tu avais posé ta question directement sur le forum CUDA de NVidia tu aurais eu de meilleurs réponses.
Après je ne suis pas non plus super bon en anglais mais je comprends relativement bien quand ça parle d'informatique et puis je m'aide aussi beaucoup de google trad et reverso.

Bah moi sur mon projet j'ai en gros le même problème que toi, mon code est trop lent, sur 100s de simulation mon code CUDA ne me fait gagné qu'1 ou 2 secondes sans prendre en compte les allocations mémoires.

Le but de mon projet c'est de faire une Intelligence Artificielle sur Street Fighter V.

https://www.youtube.com/watch?v=eWSbIXSbMis

Pour être bien faudrait que mon code CUDA accélère environ par 20 mon temps de calculs comme ça je pourrais me préoccuper d’améliorer mes algorithmes plutôt que de juste les rendre plus rapide.
Pour l'instant j'ai une réseaux de neurones "basique" mais il y a encore plein de façon d'améliorer mon algorithme d'apprentissage.

Street Fighter V a l'air d'être un bon jeu de combat extrèmement rapide et fuide, je ne connais que les anciennes versions notamment celle du debut à la creation de Street Fighter un jeu que j'aimais beaucoup, j'ai eu la chance de connaitre toute l'évolution de l'informatique de pong à aujourd'hui. Maintenant je ne suis plus trop gamer ca m'arrive d'y jouer, en ce moment je préfère le développement. Toi t'es un des développeurs de Street Fighter V ou c'est un projet OpenSource comme d'autres moteurs de jeux.

C'est pas du tout open source, je lis dans la mémoire RAM pour récupérer les valeurs dont j'ai besoin et je simule des appuis de touche pour faire jouer mon IA.

Voici la réponse à notre problème :

https://devtalk.nvidia.com/default/t...-it-possible-/

Merci pour le lien je l'ai survolé il va me falloir du temps pour comprendre à cause l'anglais. Par contre j'ai une piste de réflexion, je pense aussi que le problème vient peut être du fait que j'ai une carte graphique grand public une 980 GTX et si je faisais les test avec une carte pro la différence serait le jour et la nuit parce que je crois qu'il y a un bridage des cartes grand public concernant CUDA qui est plus orienté PRO et si je pense ca c'est parce ma carte qui a 2048 coeurs CUDA et une fréquence de 1200Mhz est 3 fois moins cher qu'une Quadro M4000 qui a moins de coeurs CUDA 1660 et une fréquence inférieure de 800Mhz, alors il doit y avoir une sacré différence au niveau des drivers car j'ose espéré qu'une carte PRO est plus puissante pour les applications parce que je trouve l'argument d'économie d'énergie pas suffisant pour justifier 3 fois le prix. Pourquoi ma carte qui a des caractéristiques visiblement supérieur à une M4000 serais beaucoup moins cher, il doit surement y avoir un bridage au niveau du driver enfin Nvidia semble dire que le driver de la carte pro est plus optimisé ?

Salut, quoi de neuf depuis le temps ?

Pour répondre à ton dernier post, tu as raison qu'il y a une différence entre les différentes cartes graphiques mais sachant que ta cartes graphique peut faire tourner des jeux vidéo en 3D. Je ne pense clairement pas que ton problème vienne de là. Si calculer 360 valeurs était aussi long comment ta carte graphique ferait-elle pour afficher des 100e de modèles 3D en temps réel ?

Perso de mon côté ça fais 2 mois que mon pc et mort et je viens d'en racheter un avec une GTX1070 donc ça va mais je ne pense pas me remettre au CUDA tout de suite, si mon code est lent c'est 1000 fois plus à cause du reste que de du GPU ou du CPU d'ailleurs en finance pour faire un très très grand nombre de calcul en parallèle, ils utilisent pleins CPU en même temps (21 000 un mec m'a dit je crois). Ca dois coûter beaucoup moins chère à produire du code CPU que GPU.

Du coup je vais continuer mon projet mais sans retoucher à la partie en CUDA, de tout façon je vais surement finir par utiliser la librairie TensorFlow de google qui est l'une des meilleure librairie de réseaux de neurones et qui intègre directement les calculs GPU sans toucher à rien, juste un boolean à passer à true.