Bonjour,
j'exécute un ptit program en cuda pour tester le parallèlisme des calcules ...
Je suis en grid 3D et sur une instruction simple, je lance de plus en plus de threads
Voilà mes résultats :
-Block(16,16,1) et Thread(32,32,1) -> 16 * 16 * 1 * 1024 = 262144 Threads, ce qui me donne 20 ms d'execution
-Block(16,16,2) et Thread(32,32,1) -> 16 * 16 * 2 * 1024 = 524288 Threads, ce qui me donne 40 ms d'execution
-Block(16,16,3) et Thread(32,32,1) -> 16 * 16 * 3 * 1024 = 786432 Threads, ce qui me donne 60 ms d'execution
-Block(16,16,4) et Thread(32,32,1) -> 16 * 16 * 4 * 1024 = 1048576 Threads, ce qui me donne 80 ms d'execution
et je me prend 20 ms à chaque fois que j'augmente le block.z
Ma carte est une GTX 690 avec 1536 Cuda Cores par GPU (DUAL), mono utilisation pour le moment.
Chacun de mes blocks sont donc composés par 32*32 Threads, excuté pas en même temps (par Warp)
Voilà mes questions,
quelle est la correlation entre Cuda Core et Thread ?
quel est le facteur limitant ?
Pourquoi ce traitement séquentiel au niveau des blocks ? mes cores seraient déjà saturé ?
Merci pour vos réponses.
voilà la méthode globale :
Code :
- __global__ void computeDetection(int numberAircraft, int *deviceArrayC)
- {
- int indiceSlave = blockDim.y * blockIdx.y + threadIdx.y;
- int indiceMaster = blockDim.x * blockIdx.x + threadIdx.x;
- int indiceSample = blockIdx.z;
- int localIdx = indiceMaster * numberAircraft + indiceSlave;
- if (indiceMaster <= indiceSlave)
- return;
- if (indiceMaster > numberAircraft)
- return;
- deviceArrayC[localIdx] = -1;
- int tmp = 10000;
- for (int indVolumeMaster = 0; indVolumeMaster < 364; indVolumeMaster++)
- {
- for (int indVolumeSlave = 0; indVolumeSlave < 364; indVolumeSlave++)
- {
- tmp = (tmp < indVolumeSlave) ? tmp : indVolumeSlave;
- }
- }
- deviceArrayC[localIdx * 120 + indiceSample] = tmp;
- }
|
Message édité par jojoa69 le 03-07-2013 à 08:31:03
