Was sind die effizienten Alternativen zu „std::vector', wenn OpenMP parallel für Schleifen verwendet wird, insbesondere wenn eine Größenänderung erforderlich ist?

Alternativen zu std::vector in der parallelen For-Schleife von OpenMP

In OpenMP das Arbeiten mit einem gemeinsam genutzten std::vector in einer parallelen for Schleife kann Leistungsprobleme mit sich bringen. In diesem Artikel werden potenzielle Alternativen untersucht, die Geschwindigkeitsvorteile bieten, insbesondere wenn eine Größenänderung während der Ausführung der Schleife erforderlich ist.

Kandidatenalternativen

• std ::vector mit OpenMP-Reduktion:

  Dieser Ansatz beinhaltet die Verwendung einer benutzerdefinierten Reduktion, die mit deklariert wird #pragma omp erklärt Reduzierung. Der folgende Code zeigt, wie er zum parallelen Kombinieren von Vektoren angewendet werden kann:

  #pragma omp declare reduction (merge : std::vector<int> : omp_out.insert(omp_out.end(), omp_in.begin(), omp_in.end()))
  
  std::vector<int> vec;
  #pragma omp parallel for reduction(merge: vec)
  for (int i = 0; i < 100; i++) vec.push_back(i);

• std::vector mit statischer Planung und geordneter Einfügung:

  Wenn die Beibehaltung der Reihenfolge der Elemente von entscheidender Bedeutung ist, kann diese Technik eingesetzt werden. Es verwendet einen statischen Zeitplan und einen geordneten Abschnitt, um Vektoren in der gewünschten Reihenfolge einzufügen:

  std::vector<int> vec;
  #pragma omp parallel
  {
      std::vector<int> vec_private;
      #pragma omp for nowait schedule(static)
      for (int i = 0; i < N; i++) vec_private.push_back(i);
      #pragma omp for schedule(static) ordered
      for (int i = 0; i < omp_get_num_threads(); i++)
      {
          #pragma omp ordered
          vec.insert(vec.end(), vec_private.begin(), vec_private.end());
      }
  }

• Präfixsummenmethode:

  Diese Methode vermeidet das Speichern von Vektoren für jeden Thread und entscheidet sich für einen einzelnen, parallel zusammengeführten Vektor. Es nutzt ein Präfix-Summen-Array, um Einfügepunkte zu verfolgen:

  std::vector<int> vec;
  size_t *prefix;
  #pragma omp parallel
  {
      int ithread = omp_get_thread_num();
      int nthreads = omp_get_num_threads();
      #pragma omp single
      {
          prefix = new size_t[nthreads + 1];
          prefix[0] = 0;
      }
      std::vector<int> vec_private;
      #pragma omp for schedule(static) nowait
      for (int i = 0; i < 100; i++) vec_private.push_back(i);
      prefix[ithread + 1] = vec_private.size();
      #pragma omp barrier
      #pragma omp single
      {
          for (int i = 1; i < (nthreads + 1); i++) prefix[i] += prefix[i - 1];
          vec.resize(vec.size() + prefix[nthreads]);
      }
      std::copy(vec_private.begin(), vec_private.end(), vec.begin() + prefix[ithread]);
  }
  delete[] prefix;

Diese Alternativen bieten effektive und effiziente Mittel zum Arbeiten mit parallelen for-Schleifen und zur Größenänderung von Vektoren in einer OpenMP-Umgebung und übertreffen die Einschränkungen gestellt von std::vector.

Das obige ist der detaillierte Inhalt vonWas sind die effizienten Alternativen zu „std::vector', wenn OpenMP parallel für Schleifen verwendet wird, insbesondere wenn eine Größenänderung erforderlich ist?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!