Biblioteca paralela de padrões (PPL)

O paralela padrões PPL (biblioteca) fornece um modelo de programação imperativo que promove a escalabilidade e facilidade de uso para o desenvolvimento de aplicativos simultâneos. A PPL amplia os componentes de gerenciamento de recursos e o agendamento do Runtime de simultaneidade. Ele aumenta o nível de abstração entre o código de aplicativo e o mecanismo subjacente de threading, fornecendo os algoritmos de segurança de tipo genéricos e contêineres que atuam nos dados em paralelo. A PPL permite desenvolver aplicativos dimensionar fornecendo alternativas para o estado compartilhado.

A PPL fornece os seguintes recursos:

• Paralelismo de tarefas: um mecanismo para executar vários itens de trabalho (tarefas) em paralelo

• Algoritmos de Parallel: algoritmos genéricos que atuam em coleções de dados em paralelo

• Paralelo recipientes e objetos: tipos de contêiner genérico que fornecem acesso simultâneo seguro para seus elementos

Exemplo

A PPL fornece um modelo de programação que se assemelha a biblioteca STL (Standard Template). O exemplo a seguir demonstra a PPL muitos recursos. Ele calcula vários números de Fibonacci em série e em paralelo. Ambas as computações agir em um std::array objeto. O exemplo também imprime no console o tempo necessário para executar ambas as computações.

A versão de serial usa a STL std::for_each o algoritmo para atravessar o array e armazena os resultados em um std:: Vector objeto. A versão paralela executa a mesma tarefa, mas usa a PPL Concurrency::parallel_for_each algoritmo e armazena os resultados em um Concurrency::concurrent_vector objeto. O concurrent_vector classe permite que cada iteração do loop simultaneamente, adicionar elementos sem a necessidade de sincronizar o acesso de gravação para o recipiente.

Porque parallel_for_each atos simultaneamente, a versão paralela deste exemplo deve classificar a concurrent_vector o objeto para produzir os mesmos resultados que a versão serial.

Observe que o exemplo usa um método simples para calcular os números de Fibonacci; No entanto, esse método ilustra como o Runtime de simultaneidade pode melhorar o desempenho de computações 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 (a.begin(), a.end(), [&](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 (a.begin(), a.end(), [&](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(results2.begin(), results2.end());
   });   
   wcout << L"parallel time: " << elapsed << L" ms" << endl << endl;

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

A saída de exemplo a seguir é de um computador que possui 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 um valor diferente de tempo para concluir. O desempenho de parallel_for_each é limitada pela operação que termina por último. Portanto, você não deve esperar melhorias de desempenho linear entre as versões seriais e paralelas deste exemplo.

Tópicos relacionados

Título	Descrição
Paralelismo de tarefas (Runtime de simultaneidade)	Descreve a função de tarefas e os grupos de tarefas da PPL.
Algoritmos paralelos	Descreve como usar os algoritmos paralelos, como parallel_for e parallel_for_each.
Paralelo recipientes e objetos	Descreve os vários recipientes paralelas e objetos que são fornecidos da PPL.
Cancelamento na 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.