Fonction OpenMP manquante: priorité de thread

Question

Tout le monde y pense. OpenMP fonctionnalités pour ajuster les muscles du processeur pour gérer le dumbbel. Dans mes recherches pour openmp, nous ne pouvons pas définir la priorité du thread pour exécuter du code de bloc avec un muscle puissant. Une seule méthode (_beginthreadex ou CreateThread avec 5. paramètres) pour créer des threads avec la plus haute priorité.

Voici un code pour ce numéro:

Ce réglage manuel est.

int numberOfCore = (execute __cpuid to obtain number of cores on your cpu). 

HANDLES* hThreads = new HANDLES[ numberOfCore ]; 
hThreads[0] = _beginthreadex(NULL, 0, someThreadFunc, NULL, 0, NULL); 

SetThreadPriority(hThreads[0], HIGH_PRIORITY_CLASS); 

WaitForMultipleObjects(...); 

Voici que je veux voir cette partie:

#pragma omp parallel 
{ 
#pragma omp for (threadpriority:HIGH_PRIORITY_CLASS) 
for(;;) { ... } 
} 

Ou

#pragma omp parallel 
{ 
// Generally this function greatly appreciativable. 
_omp_set_priority(HIGH_PRIORITY_CLASS); 
#pragma omp for 
for(;;) { ... } 
} 

Je ne sais pas s'il y avait un moyen de priorité de configuration avec OpenMP pls nous en informer.

Answer 1

Vous pouvez faire SetThreadPriority dans le corps de la boucle sans nécessiter un soutien particulier de OpenMP:

for (...) 
{ 
    DWORD priority=GetThreadPriority(...); 
    SetThreadPriority(...); 
    // stuff 
    SetThreadPriority(priority); 
} 

Answer 2

Simple test révèle des résultats inattendus: J'ai couru un test simple dans Visual Studio 2010 (Windows 7):

#include <stdio.h> 
    #include <omp.h> 
    #include <windows.h> 

    int main() 
    { 
     int tid, nthreads; 

     SetThreadPriority(GetCurrentThread(), THREAD_PRIORITY_ABOVE_NORMAL); 

     #pragma omp parallel private(tid) num_threads(4) 
     { 
      tid = omp_get_thread_num(); 
      printf("Thread %d: Priority = %d\n", tid, GetThreadPriority(GetCurrentThread())); 
     } 

     printf("\n"); 

     #pragma omp parallel private(tid) shared(nthreads) num_threads(4) 
     { 
      tid = omp_get_thread_num(); 

      #pragma omp master 
      { 
       printf("Master Thread %d: Priority = %d\n", tid, GetThreadPriority(GetCurrentThread())); 
      } 
     } 

     #pragma omp parallel num_threads(4) 
     { 
      SetThreadPriority(GetCurrentThread(), THREAD_PRIORITY_ABOVE_NORMAL); 
     } 

     printf("\n"); 

     #pragma omp parallel private(tid) num_threads(4) 
     { 
      tid = omp_get_thread_num(); 
      printf("Thread %d: Priority = %d\n", tid, GetThreadPriority(GetCurrentThread())); 
     } 

     return 0; 
    } 

La sortie est la suivante:

Thread 1: Priority = 0 
    Thread 0: Priority = 1 
    Thread 2: Priority = 0 
    Thread 3: Priority = 0 

    Master Thread 0: Priority = 1 

    Thread 0: Priority = 1 
    Thread 1: Priority = 1 
    Thread 3: Priority = 1 
    Thread 2: Priority = 1 

Explication: Les threads maîtres OpenMP sont exécutés avec la priorité de thread de la main. Les autres threads OpenMP sont laissés en priorité normale. Lors de la définition manuelle de la priorité de thread des threads OpenMP, les threads conservent cette priorité.