Biblioteca de padrões paralelos (PPL)

A Biblioteca de Padrões Paralelos (PPL) fornece um modelo de programação imperativo que promove escalabilidade e facilidade de uso para o desenvolvimento de aplicativos simultâneos. O PPL baseia-se nos componentes de agendamento e gerenciamento de recursos do Concurrency Runtime. Ele aumenta o nível de abstração entre o código do aplicativo e o mecanismo de threading subjacente, fornecendo algoritmos e contêineres genéricos e seguros para tipos que atuam nos dados em paralelo. O PPL também permite desenvolver aplicativos que podem ser dimensionados fornecendo alternativas ao estado compartilhado.

O PPL fornece as seguintes características:

• Paralelismo de tarefas: um mecanismo que funciona sobre o ThreadPool do Windows para executar vários itens de trabalho (tarefas) em paralelo

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

• Contêineres e objetos paralelos: tipos de contêineres 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 C++. O exemplo a seguir demonstra muitos recursos do PPL. Calcula vários números de Fibonacci em série e em paralelo. Ambos os cálculos atuam em um objeto std::array . O exemplo também imprime no console o tempo necessário para executar ambos os cálculos.

A versão serial usa o algoritmo C++ Standard Library std::for_each para percorrer a matriz e armazena os resultados em um objeto std::vetor . A versão paralela executa a mesma tarefa, mas usa o algoritmo PPL concurrency::parallel_for_each e armazena os resultados em um objeto concurrency::concurrent_vector. A concurrent_vector classe permite que cada iteração de loop adicione simultaneamente elementos sem a necessidade 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 concurrent_vector objeto para produzir os mesmos resultados que a versão serial.

Note que o exemplo usa um método ingênuo para calcular os números de Fibonacci; no entanto, esse método ilustra como o Concurrency Runtime 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 terminar. O desempenho de parallel_for_each é limitado pela operação que termina por último. Portanto, você não deve esperar melhorias de desempenho linear entre as versões serial e paralela deste exemplo.

Tópicos relacionados