Párhuzamos minták kódtára (PPL)

A párhuzamos minták kódtára (PPL) egy imperatív programozási modellt biztosít, amely elősegíti a skálázhatóságot és a könnyű használatot az egyidejű alkalmazások fejlesztéséhez. A PPL az egyidejűségi futtatókörnyezet ütemezési és erőforrás-kezelési összetevőire épül. Ez növeli az absztrakció szintjét az alkalmazáskód és a mögöttes szálkezelési mechanizmus között azáltal, hogy általános, típusbiztos algoritmusokat és tárolókat biztosít, amelyek párhuzamosan működnek az adatokon. A PPL lehetővé teszi az olyan alkalmazások fejlesztését is, amelyek skálázhatók a megosztott állapot alternatíváinak biztosításával.

A PPL a következő funkciókat biztosítja:

• Feladat-párhuzamosság: a Windows ThreadPool tetején működő mechanizmus több munkaelem (feladat) párhuzamos végrehajtásához

• Párhuzamos algoritmusok: olyan általános algoritmusok, amelyek az egyidejűségi futtatókörnyezeten működnek, hogy párhuzamosan működjenek az adatgyűjteményeken

• Párhuzamos tárolók és objektumok: általános tárolótípusok, amelyek biztonságos egyidejű hozzáférést biztosítanak az elemeikhez

példa

A PPL egy olyan programozási modellt biztosít, amely a C++ standard kódtárhoz hasonlít. Az alábbi példa a PPL számos funkcióját mutatja be. Több Fibonacci-számot számít ki sorosan és párhuzamosan. Mindkét számítás egy std::array objektumon működik. A példa azt az időt is kinyomtatja a konzolon, amely a két számítás elvégzéséhez szükséges.

A soros verzió a C++ Standard Library std:::for_each algoritmussal lépi át a tömböt, és egy std::vector objektumban tárolja az eredményeket. A párhuzamos verzió ugyanezt a feladatot hajtja végre, de a PPL concurrency::parallel_for_each algoritmust használja, és az eredményeket a concurrency::concurrent_vector objektumban tárolja. Az concurrent_vector osztály lehetővé teszi, hogy minden ciklus iteráció egyszerre adjon hozzá elemeket anélkül, hogy a tároló írási hozzáférésének szinkronizálására lenne szükség.

Mivel parallel_for_each egyidejűleg működik, a példa párhuzamos verziójának rendeznie kell az concurrent_vector objektumot, hogy ugyanazokat az eredményeket hozza létre, mint a soros verzió.

Vegye figyelembe, hogy a példa egy naiv módszerrel számítja ki a Fibonacci-számokat; Ez a módszer azonban azt mutatja be, hogy az egyidejűségi futtatókörnyezet hogyan javíthatja a hosszú számítások teljesítményé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;
   });
}

Az alábbi mintakimenet egy négy processzorral rendelkező számítógéphez készült.

serial time: 9250 ms
parallel time: 5726 ms

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

A ciklus minden iterációja eltérő időt igényel a befejezéshez. A teljesítményt parallel_for_each az utolsóként befejeződő művelet határolja. Ezért nem várható lineáris teljesítménybeli javulás a példa soros és párhuzamos verziói között.

Kapcsolódó témakörök