Útmutató: Redukciós változót használó OpenMP-ciklus átalakítása az egyidejűségi futtatókörnyezet használatához

Ez a példa bemutatja, hogyan alakítható át egy OpenMP párhuzamos for ciklus, amely a redukció záradékot használja az Egyidejűségi Futási Környezet használatára.

Az OpenMP reduction záradék lehetővé teszi egy vagy több szál-privát változó megadását, amelyek a párhuzamos régió végén csökkentési műveletnek vannak alávetve. Az OpenMP előre definiálja a csökkentési operátorok egy készletét. Minden csökkentési változónak skalárisnak kell lennie (például int, longés float). Az OpenMP több korlátozást is meghatároz a csökkentési változók párhuzamos régióban való felhasználására.

A Párhuzamos Minták Könyvtár (PPL) biztosítja a concurrency::combinable osztályt, amely újrafelhasználható, szálhoz kötött tárolót biztosít, lehetővé téve ezzel a részletes számítások elvégzését, majd azok végső eredménybe való összeolvasztását. Az combinable osztály egy olyan sablon, amely skaláris és összetett típusok esetében is működik. Az combinable osztály használatához végezze el az alszámításokat egy párhuzamos szerkezet törzsében, majd hívja meg a concurrency::combinable::combine vagy a concurrency::combinable::combine_each metódust a végső eredmény előállításához. A(z) combine és combine_each metódusok mindegyike egy összevonási függvényt fogad, amely meghatározza, hogyan lehet kombinálni az egyes elempárokat. Ezért az combinable osztály nem korlátozódik a csökkentési operátorok rögzített készletére.

példa

Ez a példa az OpenMP-t és az egyidejűségi futtatókörnyezetet is használja az első 35 Fibonacci-szám összegének kiszámításához.

// concrt-omp-fibonacci-reduction.cpp
// compile with: /EHsc /openmp
#include <ppl.h>
#include <iostream>

using namespace concurrency;
using namespace std;

// Computes the nth Fibonacci number.
// This function illustrates a lengthy operation and is therefore
// not optimized for performance.
int fibonacci(int n)
{
   if (n < 2)
      return n;

   // Compute the components in parallel.
   int n1, n2;
   parallel_invoke(
      [n,&n1] { n1 = fibonacci(n-1); },
      [n,&n2] { n2 = fibonacci(n-2); }
   );

   return n1 + n2;
}

// Uses OpenMP to compute the sum of Fibonacci numbers in parallel.
void omp_parallel_fibonacci_sum(int count)
{
   int sum = 0;
   #pragma omp parallel for reduction(+ : sum)
      for (int i = 0; i < count; ++i)
      {
         sum += fibonacci(i);
      }

   wcout << L"The sum of the first " << count << L" Fibonacci numbers is " 
         << sum << L'.' << endl;
}

// Uses the Concurrency Runtime to compute the sum of Fibonacci numbers in parallel.
void concrt_parallel_fibonacci_sum(int count) 
{
   combinable<int> sums;
   parallel_for(0, count, [&sums](int i)
      {
         sums.local() += fibonacci(i);
      });

   wcout << L"The sum of the first " << count << L" Fibonacci numbers is " 
         << sums.combine(plus<int>()) << L'.' << endl;
}

int wmain()
{
   const int count = 35;

   wcout << L"Using OpenMP..." << endl;
   omp_parallel_fibonacci_sum(count);

   wcout << L"Using the Concurrency Runtime..." << endl;
   concrt_parallel_fibonacci_sum(count);
}

Ez a példa a következő kimenetet hozza létre.

Using OpenMP...
The sum of the first 35 Fibonacci numbers is 14930351.
Using the Concurrency Runtime...
The sum of the first 35 Fibonacci numbers is 14930351.

Az osztályról további információt a combinablePárhuzamos tárolók és objektumok című témakörben talál.

A kód összeállítása

Másolja ki a példakódot, és illessze be egy Visual Studio-projektbe, vagy illessze be egy elnevezett concrt-omp-fibonacci-reduction.cpp fájlba, majd futtassa a következő parancsot egy Visual Studio parancssori ablakban.

cl.exe /EHsc /openmp concrt-omp-fibonacci-reduction.cpp

Lásd még

Migrálás az OpenMP-ről az egyidejűségi futtatókörnyezetbe
párhuzamos tárolók és objektumok