Biblioteka desenie równoległe (PPL)

Biblioteka desenie równoległe (PPL) zapewnia nadrzędnych model programowania, który promuje skalowalność i łatwość użycia opracowywanie aplikacji równoczesnych.PPL opiera się na składniki zarządzania planowania i zasobów Runtime współbieżności.On podwyższa poziom abstrakcji między kodu aplikacji i podstawowej mechanizm wątka podając algorytmy rodzajowy, typ palety i pojemniki, które działają na dane równolegle.PPL pozwala także aplikacje, które poprzez zapewnienie alternatywy do stanu udostępnionego.

PPL udostępnia następujące funkcje:

• Równoległości prostych zadań: mechanizm wykonanie kilku elementów pracy (zadania) równolegle

• Algorytmy równoległe: generic algorytmów, które działają na zbiory danych równolegle

• Równoległe kontenery i obiekty: typy kontenerem, które zapewniają bezpieczne równoczesny dostęp do ich elementów

Przykład

PPL udostępnia model programowania, który przypomina standardowy szablon biblioteki (STL).Poniższy przykład ilustruje wiele funkcji PPL.Sposób i równocześnie, oblicza kilka liczb Fibonacciego.Obliczenia zarówno działania na std::array obiektu.Przykład drukuje do konsoli również czas wymagany do wykonania obu obliczenia.

Szeregowy wersji używa STL std::for_each algorytm przechodzenia tablicy i zapisuje wyniki w std::vector obiektu.Równoległe wersja wykonuje to samo zadanie, ale używa PPL concurrency::parallel_for_each algorytm i zapisuje wyniki w concurrency::concurrent_vector obiektu.concurrent_vector Klasy umożliwia każdej iteracji pętli jednocześnie dodać elementy bez wymogu, aby zsynchronizować dostęp zapisu do kontenera.

Ponieważ parallel_for_each aktów współbieżnie, równolegle wersja tego przykładu należy posortować concurrent_vector obiekt, aby uzyskać wyniki szeregowego wersji.

Należy zauważyć, że w przykładzie użyto metody naïve do obliczania liczby Fibonacciego; Jednakże metoda ta ilustruje, jak Runtime współbieżności może zwiększyć wydajność obliczeń długie.

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

Następujące przykładowe dane wyjściowe jest na komputerze z czterema procesorami.

serial time: 9250 ms
parallel time: 5726 ms

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

Każdej iteracji pętli wymaga różnych ilości czasu na zakończenie.Wydajność parallel_for_each jest ograniczone przez operację, która zakończy się ostatnio.W związku z tym należy raczej nie poprawia wydajność liniowej między wersjami szeregowe i równoległe w tym przykładzie.

Tematy pokrewne

Tytuł	Opis
Zadanie równoległości (współbieżności Runtime)	Opisuje rolę zadań i grup zadań w PPL.
Algorytmy równoległe	Opisuje sposób używania algorytmy równoległe, takich jak parallel_for i parallel_for_each.
Równoległe kontenerów i obiektów	Zawiera opis różnych równoległych kontenerów i obiektów, które są udostępniane przez PPL.
Anulowanie w PPL	Wyjaśniono, jak anulować pracy, która jest wykonywana przez algorytm równolegle.
Współbieżność Runtime	W tym artykule opisano Runtime współbieżności, który upraszcza programowania równoległego i zawiera łącza do tematów pokrewnych.