Knihovna PPL (Parallel Patterns Library)

Knihovna PPL (Parallel Patterns Library) poskytuje imperativní programovací model, který podporuje škálovatelnost a snadné použití při vývoji souběžných aplikací. PPL vychází ze součástí plánování a správy prostředků modulu Concurrency Runtime. Zvýší úroveň abstrakce mezi kódem aplikace a základním mechanismem threadingu tím, že poskytuje obecné algoritmy a kontejnery, které fungují na datech paralelně. PPL také umožňuje vyvíjet aplikace, které se škálují, tím, že poskytují alternativy ke sdílenému stavu.

PPL poskytuje následující funkce:

• Paralelismus úloh: Mechanismus, který funguje nad fondem vláken systému Windows, paralelně spouštět několik pracovních položek (úkolů)

• Paralelní algoritmy: obecné algoritmy, které fungují nad modulem Concurrency Runtime a pracují s kolekcemi dat paralelně

• Paralelní kontejnery a objekty: obecné typy kontejnerů, které poskytují bezpečný souběžný přístup k jejich prvkům

Příklad

PPL poskytuje programovací model, který se podobá standardní knihovně C++. Následující příklad ukazuje mnoho funkcí PPL. Vypočítá několik Fibonacciho čísel sériově a paralelně. Oba výpočty fungují na objektu std::array . Příklad se také vytiskne do konzoly čas potřebný k provedení obou výpočtů.

Sériová verze používá algoritmus std::for_each knihovny C++ k procházení pole a ukládá výsledky do objektu std::vector. Paralelní verze provádí stejnou úlohu, ale používá souběžnost PPL ::p arallel_for_each algoritmu a ukládá výsledky do objektu concurrency::concurrent_vector . Třída concurrent_vector umožňuje každé iteraci smyčky souběžně přidávat prvky bez nutnosti synchronizovat přístup k zápisu do kontejneru.

Vzhledem k tomu parallel_for_each , že funguje souběžně, musí paralelní verze tohoto příkladu concurrent_vector seřadit objekt, aby se vytvořily stejné výsledky jako sériová verze.

Všimněte si, že v příkladu se k výpočtu fibonacciových čísel používá naivní metoda; Tato metoda však ukazuje, jak může Concurrency Runtime zlepšit výkon dlouhých výpočtů.

// 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č se čtyřmi procesory.

serial time: 9250 ms
parallel time: 5726 ms

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

Každá iterace smyčky vyžaduje jinou dobu, než se dokončí. parallel_for_each Výkon je vázán operací, která končí naposledy. Proto byste neměli očekávat vylepšení lineárního výkonu mezi sériovými a paralelními verzemi tohoto příkladu.

Příbuzná témata

Titulek	Popis
Paralelismus úkolu	Popisuje roli úkolů a skupin úkolů v PPL.
Paralelní algoritmy	Popisuje, jak používat paralelní algoritmy, jako parallel_forparallel_for_eachje a .
Paralelní kontejnery a objekty	Popisuje různé paralelní kontejnery a objekty, které poskytuje PPL.
Zrušení v knihovně PPL	Vysvětluje, jak zrušit práci prováděnou paralelním algoritmem.
Concurrency Runtime	Popisuje modul Concurrency Runtime, který zjednodušuje paralelní programování a obsahuje odkazy na související témata.