Biblioteca de padrões paralelos (PPL)

A biblioteca de padrões paralelos (PPL) fornece um modelo de programação imperativo que promove a escalabilidade e a facilidade de uso no desenvolvimento de aplicativos simultâneos. A PPL baseia-se nos componentes de agendamento e gerenciamento de recursos do Runtime de Simultaneidade. Ela aumenta o nível de abstração entre o código do aplicativo e o mecanismo de threading subjacente fornecendo algoritmos genéricos e fortemente tipados, além de contêineres que atuam em dados em paralelo. A PPL também permite desenvolver aplicativos que são dimensionados fornecendo alternativas ao estado compartilhado.

A PPL fornece os recursos a seguir:

• Paralelismo de tarefas: um mecanismo que funciona em cima do Thread de Pools do Windows para executar vários itens de trabalho (tarefas) em paralelo

• Algoritmos paralelos: algoritmos genéricos que funcionam em cima do Runtime de Simultaneidade para agir em coleções de dados em paralelo

• Contêineres e objetos paralelos: tipos de contêiner genéricos que fornecem acesso simultâneo seguro aos seus elementos

Exemplo

O PPL fornece um modelo de programação que se assemelha à Biblioteca Padrão do C++. O exemplo a seguir demonstra muitos recursos do PPL. Ele calcula vários números de Fibonacci em série e em paralelo. Ambas as computações atuam em um objeto std::array. O exemplo também imprime no console o tempo necessário para executar ambas as computações.

A versão serial usa o algoritmo std::for_each da Biblioteca Padrão do C++ para percorrer a matriz e armazena os resultados em um objeto std::vector. A versão paralela executa a mesma tarefa, mas usa o algoritmo PPL concurrency::p arallel_for_each e armazena os resultados em um objeto concurrency::concurrent_vector. A classe concurrent_vector permite que cada iteração de loop adicione elementos simultaneamente sem o requisito de sincronizar o acesso de gravação ao contêiner.

Como parallel_for_each atua simultaneamente, a versão paralela deste exemplo deve classificar o objeto concurrent_vector para produzir os mesmos resultados da versão serial.

Observe que o exemplo usa um método ingênuo para calcular os números de Fibonacci; no entanto, esse método ilustra como o Runtime de Simultaneidade pode melhorar o desempenho de cálculos longos.

// parallel-fibonacci.cpp
// compile with: /EHsc
#include <windows.h>
#include <ppl.h>
#include <concurrent_vector.h>
#include <array>
#include <vector>
#include <tuple>
#include <algorithm>
#include <iostream>

using namespace concurrency;
using namespace std;

// Calls the provided work function and returns the number of milliseconds 
// that it takes to call that function.
template <class Function>
__int64 time_call(Function&& f)
{
   __int64 begin = GetTickCount();
   f();
   return GetTickCount() - begin;
}

// Computes the nth Fibonacci number.
int fibonacci(int n)
{
   if(n < 2)
      return n;
   return fibonacci(n-1) + fibonacci(n-2);
}

int wmain()
{
   __int64 elapsed;

   // An array of Fibonacci numbers to compute.
   array<int, 4> a = { 24, 26, 41, 42 };

   // The results of the serial computation.
   vector<tuple<int,int>> results1;

   // The results of the parallel computation.
   concurrent_vector<tuple<int,int>> results2;

   // Use the for_each algorithm to compute the results serially.
   elapsed = time_call([&] 
   {
      for_each (begin(a), end(a), [&](int n) {
         results1.push_back(make_tuple(n, fibonacci(n)));
      });
   });   
   wcout << L"serial time: " << elapsed << L" ms" << endl;
   
   // Use the parallel_for_each algorithm to perform the same task.
   elapsed = time_call([&] 
   {
      parallel_for_each (begin(a), end(a), [&](int n) {
         results2.push_back(make_tuple(n, fibonacci(n)));
      });

      // Because parallel_for_each acts concurrently, the results do not 
      // have a pre-determined order. Sort the concurrent_vector object
      // so that the results match the serial version.
      sort(begin(results2), end(results2));
   });   
   wcout << L"parallel time: " << elapsed << L" ms" << endl << endl;

   // Print the results.
   for_each (begin(results2), end(results2), [](tuple<int,int>& pair) {
      wcout << L"fib(" << get<0>(pair) << L"): " << get<1>(pair) << endl;
   });
}

A saída de exemplo a seguir é para um computador que tem quatro processadores.

serial time: 9250 ms
parallel time: 5726 ms

fib(24): 46368
fib(26): 121393
fib(41): 165580141
fib(42): 267914296

Cada iteração do loop requer uma quantidade diferente de tempo para concluir. O desempenho de parallel_for_each é limitado pela operação que termina por último. Portanto, você não deve esperar melhorias de desempenho lineares entre as versões serial e paralela deste exemplo.

Tópicos Relacionados

Título	Descrição
Paralelismo de tarefas	Descreve a função de tarefas e grupos de tarefas no PPL.
Algoritmos paralelos	Descreve como usar algoritmos paralelos, como parallel_for e parallel_for_each.
Contêineres e objetos em paralelo	Descreve os vários contêineres e objetos paralelos fornecidos pelo PPL.
Cancelamento no PPL	Explica como cancelar o trabalho que está sendo executado por um algoritmo paralelo.
Runtime de Simultaneidade	Descreve o Runtime de Simultaneidade, que simplifica a programação paralela e contém links para tópicos relacionados.