Paralelní knihovnu vzorků (PPL)

Paralelní knihovnu vzorků (PPL) poskytuje naprosto programovací model, který propaguje-použití pro vývoj aplikací souběžných a škálovatelnosti.PPL staví na plánování a prostředků součásti řízení souběžnosti Runtime.Poskytnutím obecný, typ bezpečné algoritmy a kontejnery, které fungují na data paralelně ji zvýší úroveň abstrakce mezi kód aplikace a základní mechanismus podprocesů.PPL také umožňuje vývoj aplikací, které měřítko poskytnutím alternativy sdílený stav.

PPL poskytuje následující funkce:

• Úkol rovnoběžnosti: mechanismus paralelně provádět několik pracovních položek (úkoly)

• Paralelní algoritmy: Obecný působit na kolekcí dat. v paralelní algoritmy

• Paralelní kontejnerů a objektů: Obecný kontejner typy, které poskytují bezpečný souběžný přístup na jejich prvky

Příklad

PPL poskytuje programovací model, který se podobá standardní šablonu knihovny (STL).Následující příklad ukazuje mnoho funkcí PPL.Vrací několik čísel Fibonacci sériově a paralelní.Obě výpočty jednat std::array objektu.Příklad vytiskne také konzolu pro čas, který je vyžadován k provedení obou výpočty.

Sériové verze používá STL std::for_each algoritmus Procházet pole a ukládá výsledky std::vector objektu.Paralelní verze je proveden stejný úkol, ale používá PPL concurrency::parallel_for_each algoritmus a ukládá výsledky concurrency::concurrent_vector objektu.concurrent_vector Třídy umožňuje každé opakování smyčky souběžně přidat prvky bez požadavku na synchronizaci zápisu do kontejneru.

Protože parallel_for_each akty souběžně paralelní verze tohoto příkladu musí řadit concurrent_vector stejné výsledky jako sériové verze objektu.

Příklad používá metodu naïve k výpočtu Fibonacci čísla; Tato metoda však ukazuje, jak zlepšit výkon dlouhé výpočty Runtime souběžnosti.

// 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;
   });
}

Následující ukázkový výstup je pro počítač, který má čtyři procesory.

serial time: 9250 ms
parallel time: 5726 ms

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

Každé opakování smyčky vyžaduje jiné množství času na dokončení.Výkon parallel_for_each je ohraničena dokončí poslední operace.Proto nelze očekávat zlepšení výkonu lineární mezi verzemi tohoto příkladu sériové a paralelní.

Příbuzná témata

Title	Description
Úkol rovnoběžnosti (souběžnosti Runtime)	Popisuje úlohu skupiny úloh v PPL a úkolů.
Paralelní algoritmy	Popisuje způsob použití paralelní algoritmy jako parallel_for a parallel_for_each.
Paralelní kontejnerů a objektů	Popisuje různé paralelní kontejnerů a objektů, které jsou k dispozici PPL.
Zrušení v PPL	Vysvětluje, jak zrušit práce provádí paralelní algoritmus.
Souběžnost Runtime	Popisuje souběžnosti Runtime, která zjednodušuje paralelní programování a obsahuje odkazy na Příbuzná témata.