Como converter um loop OpenMP que usa uma variável de redução para usar o tempo de execução paralelo.

Este exemplo demonstra como converter um paralelo OpenMP para loop que usa a cláusula de redução para usar o Concurrency Runtime.

A cláusula OpenMP reduction permite especificar uma ou mais variáveis thread-private que estão sujeitas a uma operação de redução no final da região paralela. OpenMP predefine um conjunto de operadores de redução. Cada variável de redução deve ser escalar (por exemplo, int, long, e float). OpenMP também define várias restrições sobre como as variáveis de redução são usadas em uma região paralela.

A Biblioteca de Padrões Paralelos (PPL) fornece a classe concurrency::combinable , que fornece armazenamento local de thread reutilizável que permite executar cálculos refinados e, em seguida, mesclar esses cálculos em um resultado final. A combinable classe é um modelo que atua em tipos escalares e complexos. Para usar a combinable classe, execute subcálculos no corpo de uma construção paralela e, em seguida, chame o método concurrency::combinable::combine ou concurrency::combinable::combine_each para produzir o resultado final. Cada um dos combine métodos e combine_each usa uma função de combinação que especifica como combinar cada par de elementos. Por conseguinte, a classe não se restringe a um conjunto fixo combinable de operadores de redução.

Exemplo

Este exemplo usa OpenMP e o Concurrency Runtime para calcular a soma dos primeiros 35 números de Fibonacci.

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

Este exemplo produz o seguinte resultado.

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.

Para obter mais informações sobre a combinable classe, consulte Contêineres e objetos paralelos.

Compilando o código

Copie o código de exemplo e cole-o em um projeto do Visual Studio ou cole-o em um arquivo chamado concrt-omp-fibonacci-reduction.cpp e, em seguida, execute o seguinte comando em uma janela do prompt de comando do Visual Studio.

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

Ver também

Migrando do OpenMP para o Concurrency Runtime
Contêineres e objetos paralelos