A modelos paralela a biblioteca (PPL)

A biblioteca (PPL) dos padrões de paralela fornece um modelo imperativo de programação que promova a escalabilidade e acessibilidade para desenvolver aplicativos simultâneas.O PPL compila os componentes de programação e de gerenciamento de recursos de tempo de execução de simultaneidade.Disparam o nível de abstração entre o código do aplicativo e o mecanismo subjacente de threads fornecendo algoritmos genéricos, type-safe e os controles que atuam em paralelamente dados.O PPL também permite que você desenvolver aplicativos que tamanho fornecendo alternativas ao estado compartilhado.

O PPL fornece os seguintes recursos:

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

• Algoritmos paralelos: algoritmos genéricas que atuam em coleções de dados paralelamente

• Contêiner e objetos paralelos: tipos genéricos do contêiner que fornecem acesso a seus elementos simultânea seguro

Exemplo

O PPL fornece um modelo de programação que se assemelha à biblioteca padrão (STL) do modelo.O exemplo demonstra vários recursos de PPL.Calcula vários números de Fibonacci em e série paralelamente.Ato de ambos os cálculos em um objeto de std::array .O exemplo também imprime no console a hora que são necessários para executar ambos os cálculos.

A versão serial usa o algoritmo de STL std::for_each para atravessar a matriz e armazena os resultados em um objeto de std::vector .A versão paralela executa a mesma tarefa, mas usa o algoritmo de PPL concurrency::parallel_for_each e armazena os resultados em um objeto de concurrency::concurrent_vector .A classe de concurrent_vector permite que cada iteração do loop para adicionar simultaneamente os elementos sem o requisito para sincronizar acesso de gravação para o contêiner.

Porque atua parallel_for_each simultaneamente, a versão paralela este exemplo deve classificar o objeto de concurrent_vector para gerar os mesmos resultados que a versão serial.

Observe que o exemplo usa um método de naïve para calcular os números de Fibonacci; no entanto, esse método ilustra como o tempo de execução de simultaneidade pode melhorar o desempenho dos cálculos longas.

// 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 seguinte saída de exemplo são para um computador que tem quatro processadores.

Cada iteração do loop requer uma quantidade de tempo diferente para o botão.O desempenho de parallel_for_each é limitado pela operação que conclui o último.Como consequência, você não deve aguardar melhorias de desempenho linear entre as versões seriais e paralelas deste exemplo.

Tópicos relacionados