Windows Dev Center

Este artigo foi traduzido por máquina. Coloque o ponteiro do mouse sobre as frases do artigo para ver o texto original. Mais informações.
Tradução
Original

Biblioteca de padrões paralelos (PPL)

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

O Classe task e tipos relacionados que são definidos em ppltasks são portáteis em plataformas. Os contêineres e algoritmos paralelos não são portáteis.

A PPL fornece os seguintes recursos:

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

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

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

A PPL fornece um modelo de programação que se parece com o modelo Biblioteca STL (Standard). O exemplo a seguir demonstra vários recursos da PPL. Ele calcula vários números 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 serial usa STL std::for_each algoritmo para atravessar a matriz e armazena os resultados em uma 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 uma 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 ao contêiner.

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

Observe que o exemplo usa um método simples para calcular números Fibonacci; No entanto, esse método ilustra como o tempo de execução 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 (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 é para um computador com quatro processadores.

              
                tempo serial: ms 9250
paralelo de tempo: ms 5726

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 é limitada pela operação de conclusão da última. Portanto, você não deve esperar melhorias de desempenho linear entre as versões seriais e paralelas deste exemplo.

Título

Descrição

Paralelismo de tarefa (tempo de execução de simultaneidade)

Descreve a função de tarefas e grupos de tarefas no PPL.

Algoritmos paralelos

Descreve como usar os algoritmos paralelos, como parallel_for e parallel_for_each.

Contêineres e objetos em paralelo

Descreve os vários contêineres paralelos e objetos que são fornecidos pelo PPL.

Cancelamento no PPL

Explica como cancelar o trabalho que está sendo executado por um algoritmo paralelo.

Tempo de Execução de Simultaneidade

Descreve o tempo de execução de simultaneidade, que simplifica a programação paralela e contém links para tópicos relacionados.

Contribuições da comunidade

Mostrar:
© 2015 Microsoft