Gör så här: Konvertera en OpenMP-loop som använder en reduceringsvariabel för att använda Concurrency Runtime

Det här exemplet visar hur du konverterar en OpenMP-parallellför loop som använder reduce-satsen för att använda Concurrency Runtime.

Med OpenMP-satsen reduction kan du ange en eller flera tråd-privata variabler som omfattas av en minskningsåtgärd i slutet av den parallella regionen. OpenMP fördefinierade en uppsättning minskningsoperatorer. Varje minskningsvariabel måste vara en skalär (till exempel int, longoch float). OpenMP definierar också flera begränsningar för hur minskningsvariabler används i en parallell region.

PPL (Parallel Patterns Library) tillhandahåller klassen concurrency::combinable , som ger återanvändbar, trådlokal lagring som gör att du kan utföra detaljerade beräkningar och sedan sammanfoga dessa beräkningar till ett slutligt resultat. Klassen combinable är en mall som fungerar på både skalära och komplexa typer. Om du vill använda combinable klassen utför du delberäkningar i kroppen av en parallell konstruktion och anropar sedan metoden concurrency::combinable::combine eller concurrency::combinable::combine_each för att skapa det slutliga resultatet. Metoderna combine och combine_each tar var och en en kombinationsfunktion som anger hur du kombinerar varje elementpar. Därför combinable är klassen inte begränsad till en fast uppsättning minskningsoperatorer.

Exempel

I det här exemplet används både OpenMP och Concurrency Runtime för att beräkna summan av de första 35 Fibonacci-talen.

// 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);
}

Det här exemplet genererar följande utdata.

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.

Mer information om klassen finns i combinableParallella containrar och objekt.

Kompilera koden

Kopiera exempelkoden och klistra in den i ett Visual Studio-projekt, eller klistra in den i en fil med namnet concrt-omp-fibonacci-reduction.cpp och kör sedan följande kommando i ett Visual Studio-kommandotolkfönster.

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

Se även

Migrera från OpenMP till Concurrency Runtime
parallella containrar och objekt