Différence entre deux boucles omp

Question

Je commence juste à utiliser OpenMP et j'écris une fonction qui divise un tableau en numBlocks blocs et calcule un histogramme sur chaque bloc (ie, un histogramme par bloc) en inspectant les éléments blockSize de chaque bloc (dans le code que je fournis, l'histogramme enregistre la divisibilité des éléments dans le bloc par les entiers 1 à numBuckets).

Dans la première je créer boucle omp for un fil pour chaque bloc en utilisant:

#pragma omp for schedule(static) 
for(uint blockNum = 0; blockNum < numBlocks; blockNum++){ 
    for(uint blockSubIdx = 0; blockSubIdx < blockSize; blockSubIdx++){ 
     uint idx = blockNum * blockSize + blockSubIdx; 
     // Compute histogram here by examining array[idx] 
    } 
} 

il mise en œuvre d'une autre manière, je vous prie fils de chaque opérer sur blockSize éléments, où je l'ai déjà affirmé que array.size() == numBlocks * blockSize:

#pragma omp for schedule(static, blockSize) 
for(uint idx = 0; idx < array.size(); idx++){ 
    uint blockNum = idx/blockSize; 
    // Compute histogram here by examining array[idx] 
} 

Cette deuxième méthode ne fonctionne pas correctement si j'augmente le nombre de threads (en utilisant export OMP_NUM_THREADS) au-dessus d'un certain seuil (78 sur mon nœud de calcul) - le résultat h Les valeurs de l'istogramme ne correspondent pas à celles d'un calcul en série.

Selon https://computing.llnl.gov/tutorials/openMP/, il semble que les blocs de taille blockSize dans la deuxième méthode sont contigus, donc je ne comprends pas pourquoi il échoue. Cependant, il semble que plusieurs threads écrivent sur le même index dans l'histogramme. Y a-t-il une subtilité qui me manque?

Voici un aperçu de l'ensemble du code source: https://gist.github.com/anonymous/5391777.

MISE À JOUR: Le seuil de fil ne montre une certaine dépendance à l'égard array.size(). Ce n'est pas la valeur particulière du seuil que j'essaie de comprendre, mais plutôt l'existence du seuil.

Answer 1

Il me semble que vous essayez de fusionner la boucle. Tu pourrais essayer ça. Je ne sais pas si cela répond à votre question.

#pragma omp parallel for schedule(static) 
for(uint n = 0; n < (numBlocks*blockSize); n++){ 
    uint blockNum = n/blockSize; 
    uint blockSubIdx = n%blockSize; 
    uint idx = blockNum * blockSize + blockSubIdx; 
    // Compute histogram here by examining array[idx] 
} 

Aussi, pourquoi essayez-vous d'augmenter le nombre de threads? Votre UC ne peut exécuter qu'un certain nombre de threads matériels en même temps. Augmenter le nombre de threads pour OpenMP ne va pas aider les performances. Pourquoi ne pas les laisser à la valeur par défaut?

Enfin, si le calcul de l'histogramme prend un temps différent en fonction de idx, vous pouvez essayer schedule(dynamic) à la place.