Como: Converter um loop de OpenMP que usa uma variável de tamanho máximo para usar o tempo de execução de concorrência

Este exemplo mostra como converter um loop de OpenMP paralelapara que use a cláusula de redução para usar o tempo de execução de simultaneidade.

A cláusula de OpenMP reduction permite que você especifique um ou mais variáveis particulares com que estão sujeitos a uma operação de tamanho no final da região paralela.OpenMP predefine um conjunto de operadores mitigação.Cada variável mitigação deve ser um escalar (por exemplo, int, long, e float).OpenMP também define várias limitações sobre como variáveis mitigação são usados em uma região paralela.

A biblioteca (PPL) dos padrões de paralela fornece a classe de concurrency::combinable , que fornece reutilizável, o local de armazenamento com que o permite executar cálculos refinados e mesclar nos cálculos em um resultado final.A classe de combinable é um modelo que atue em escalar e tipos complexos.Para usar a classe de combinable , subpropriedades e executar cálculos no corpo de uma compilação paralela e então chame o método de concurrency::combinable::combine ou de concurrency::combinable::combine_each para gerar o resultado final.Os métodos de combine e de combine_each cada têm uma função de combinação que especifica como combinar cada par de elementos.Como consequência, a classe de combinable não é restrita a um conjunto fixo de operadores mitigação.

Exemplo

Este exemplo usa OpenMP e o tempo de execução de simultaneidade 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);
}

O exemplo produz a seguinte saída.

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

Compilando o código

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

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

Consulte também

Conceitos

Migrando de OpenMP ao tempo de execução de concorrência

Contêiner e objetos paralelos