Parallel Patterns Library (PPL)Parallel Patterns Library (PPL)

Die Parallel Patterns Library (PPL) stellt ein obligatorisches Programmiermodell bereit, das die Skalierbarkeit und Benutzerfreundlichkeit beim Entwickeln gleichzeitiger Anwendungen fördert.The Parallel Patterns Library (PPL) provides an imperative programming model that promotes scalability and ease-of-use for developing concurrent applications. Die PPL baut auf den Planungs- und Ressourcenverwaltungskomponenten der Concurrency Runtime auf.The PPL builds on the scheduling and resource management components of the Concurrency Runtime. Sie stuft die Abstraktionebene zwischen dem Anwendungscode und dem zugrunde liegenden Threadingmechanismus herauf, indem sie generische, typsichere Algorithmen und Container bereitstellt, die Daten parallel verarbeiten.It raises the level of abstraction between your application code and the underlying threading mechanism by providing generic, type-safe algorithms and containers that act on data in parallel. Mit der PPL können Sie auch Anwendungen entwickeln, die durch die Bereitstellung von Alternativen zum freigegebenen Status skalieren.The PPL also lets you develop applications that scale by providing alternatives to shared state.

Die PPL bietet die folgenden Funktionen:The PPL provides the following features:

  • Aufgabenparallelität: ein Mechanismus, der auf der Windows-ThreadPool Grundlage auf mehrere Arbeitselemente (Aufgaben) parallel ausgeführt werden.Task Parallelism: a mechanism that works on top of the Windows ThreadPool to execute several work items (tasks) in parallel

  • Parallele Algorithmen: generische Algorithmen, die über die Concurrency Runtime fungieren Auflistungen von Daten parallel funktioniertParallel algorithms: generic algorithms that works on top of the Concurrency Runtime to act on collections of data in parallel

  • Parallele Container und Objekte: generische Containertypen, die sicheren gleichzeitigen Zugriff auf ihre Elemente bietenParallel containers and objects: generic container types that provide safe concurrent access to their elements

BeispielExample

Die PPL bietet ein Programmiermodell, das die C++-Standardbibliothek ähnelt.The PPL provides a programming model that resembles the C++ Standard Library. Im folgenden Beispiel werden zahlreiche PPL-Funktionen veranschaulicht.The following example demonstrates many features of the PPL. Darin werden mehrere Fibonacci-Zahlen seriell sowie parallel berechnet.It computes several Fibonacci numbers serially and in parallel. Beide Berechnungen werden für eine Std:: Array Objekt.Both computations act on a std::array object. Das Beispiel gibt außerdem die Zeit, die zum Ausführen beider Berechnungen benötigt wird, in der Konsole aus.The example also prints to the console the time that is required to perform both computations.

Verwendet die serielle Version der C++ Standardbibliothek Std:: for_each Algorithmus durchläuft das Array und speichert die Ergebnisse in einem Std:: vector Objekt.The serial version uses the C++ Standard Library std::for_each algorithm to traverse the array and stores the results in a std::vector object. Die parallele Version führt die gleiche Aufgabe, verwendet jedoch den PPL- Concurrency:: parallel_for_each Algorithmus und speichert die Ergebnisse in einem Concurrency:: concurrent_vector Objekt.The parallel version performs the same task, but uses the PPL concurrency::parallel_for_each algorithm and stores the results in a concurrency::concurrent_vector object. Die concurrent_vector-Klasse aktiviert die einzelnen Schleifeniterationen, Elemente gleichzeitig hinzuzufügen, ohne dass erforderlich ist, den Schreibzugriff auf den Container zu synchronisieren.The concurrent_vector class enables each loop iteration to concurrently add elements without the requirement to synchronize write access to the container.

Da parallel_for_each gleichzeitig ausführt, muss die parallele Version dieses Beispiels das concurrent_vector-Objekt so sortieren, dass die gleichen Ergebnisse wie bei der seriellen Version erzielt werden.Because parallel_for_each acts concurrently, the parallel version of this example must sort the concurrent_vector object to produce the same results as the serial version.

Beachten Sie, dass in dem Beispiel die Fibonacci-Zahlen mithilfe einer naiven Methode berechnet werden; diese Methode veranschaulicht jedoch, wie die Concurrency Runtime die Leistung bei langen Berechnungen verbessern kann.Note that the example uses a naïve method to compute the Fibonacci numbers; however, this method illustrates how the Concurrency Runtime can improve the performance of long computations.

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

Die folgende Beispielausgabe entspricht einem Ergebnis auf einem Computer mit vier Prozessoren.The following sample output is for a computer that has four processors.

serial time: 9250 ms
parallel time: 5726 ms

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

Jede Iteration der Schleife erfordert eine unterschiedliche Zeit zum Beenden.Each iteration of the loop requires a different amount of time to finish. Die Leistung von parallel_for_each wird von der Operation bestimmt, die als Letztes beendet wird.The performance of parallel_for_each is bounded by the operation that finishes last. Daher sollten Sie keine linearen Leistungsverbesserungen zwischen den seriellen und parallelen Versionen dieses Beispiels erwarten.Therefore, you should not expect linear performance improvements between the serial and parallel versions of this example.

TitelTitle BeschreibungDescription
AufgabenparallelitätTask Parallelism Beschreibt die Rolle von Aufgaben und Aufgabengruppen in der PPL.Describes the role of tasks and task groups in the PPL.
Parallele AlgorithmenParallel Algorithms Beschreibt die Verwendung parallele Algorithmen, wie z. B. parallel_for und parallel_for_each.Describes how to use parallel algorithms such as parallel_for and parallel_for_each.
Parallele Container und ObjekteParallel Containers and Objects Beschreibt die verschiedenen parallelen Container und die Objekte, die von der PPL bereitgestellt werden.Describes the various parallel containers and objects that are provided by the PPL.
Abbruch in der PPLCancellation in the PPL Erläutert, wie die von einem parallelen Algorithmus ausgeführte Verarbeitung abgebrochen wird.Explains how to cancel the work that is being performed by a parallel algorithm.
Concurrency RuntimeConcurrency Runtime Beschreibt die Concurrency Runtime, die die parallele Programmierung vereinfacht, und stellt Links zu verwandten Themen bereit.Describes the Concurrency Runtime, which simplifies parallel programming, and contains links to related topics.