openmp reduce technique

Question

Ich habe diese for-Schleife, die minimale und maximale Länge findet, wie Sie sehen können Ich habe zwei Werte zu reduzieren hier beim Betrachten von OpenMP Ich kann nur feststellen, dass es Reduktionstechnik für nur einen Wert bietet.

for (size_t i = 0; i < m_patterns.size(); ++i) 
{// start for loop 
    if (m_patterns[i].size() < m_lmin)   
     m_lmin = m_patterns[i].size();   
    else if (m_patterns[i].size() > m_lmax)   
     m_lmax = m_patterns[i].size(); 
}// end for loop 

kann ich die folgenden

#pragma omp parallel for reduction (min:m_lmin,max:m_lmax) 

oder soll ich umschreiben die for-Schleife zu zwei for-Schleifen eines für das Minimum und einen für die maximale

eine andere Frage .. kann ich tbb containers wie concurrent_vector in OpenMP

Answer 1

Für openmp steht eine offizielle Spezifikation zur Verfügung (www.openmp.org). Aber schließlich macht dein Compiler die ganze Arbeit. So ist die Antwort auf Ihre Frage sein kann Compiler ähnliche ... jedoch Microsoft bietet http://msdn.microsoft.com/de-de/library/2etkydkz(v=vs.80).aspx

was darauf hindeutet,

#pragma omp parallel for reduction(min:m_lmin) reduction(max:m_lmax) 

Answer 2

Von OpenMP 3.1 begannen sie Unterstützung von min & max Reduktionsoperation. OpenMP 3.1 ist von GCC 4.7 verfügbar. Sie können sich auf this link beziehen, um weitere Einzelheiten zur minimalen Reduktion zu erfahren.

Answer 3

Sie können simultane Vektor- sowie Min- und Max-Reduktionen durchführen, indem Sie private Versionen der Variablen parallel füllen und dann in einem kritischen Abschnitt zusammenführen. Dies funktioniert in MSVC, das nur OpenMP 2.5 unterstützt (die Min- und Max-Reduktionen werden nicht unterstützt). Aber unabhängig davon, ob Ihre Version von OpenMP Min- und Max-Reduktionen unterstützt, ist dies eine nützliche Technik zum Lernen.

Diese Methode ist effizient, solange die Anzahl der Elemente, die Sie durchlaufen, viel größer ist als die Anzahl der Threads (oder die Zeit über die Elemente ist groß im Vergleich zum Zusammenführen).

#pragma parallel 
{ 
    int m_lmin_private = m_lmin; 
    int m_max_private = m_max_private; 
    #pragma omp for nowait 
    for (size_t i = 0; i < m_patterns.size(); ++i) { 
     if (m_patterns[i].size() < m_lmin_private)   
      m_lmin_private = m_patterns[i].size();   
     else if (m_patterns[i].size() > m_lmax_private)   
      m_lmax_private = m_patterns[i].size(); 
    } 
    #pragma omp critical 
    { 
     if (m_lmin_private<m_lmin)   
      m_lmin = m_lmin_private;  
     if (m_lmax_private>m_lmax)   
      m_lmax = m_lmax_private;      
    } 
} 

Für die gleichzeitige Vektoren uns die gleiche Methode:

std::vector<int> vec; 
#pragma omp parallel 
{ 
    std::vector<int> vec_private; 
    #pragma omp for nowait //fill vec_private in parallel 
    for(int i=0; i<n; i++) { 
     vec_private.push_back(i); 
    } 
    #pragma omp critical 
    vec.insert(vec.end(), vec_private.begin(), vec_private.end()); 
}