Procedure: Combinaties gebruiken om sets te combineren

In dit onderwerp wordt beschreven hoe u de gelijktijdigheidsklasse gebruikt::combineerbare klasse om de set priemgetallen te berekenen.

Voorbeeld

In het volgende voorbeeld wordt de set priemgetallen twee keer berekend. Elke berekening slaat het resultaat op in een std::bitset-object . In het voorbeeld wordt eerst de set serieel berekend en vervolgens wordt de set parallel berekend. In het voorbeeld wordt ook naar de console geprint hoeveel tijd er nodig is om beide berekeningen uit te voeren.

In dit voorbeeld worden de concurrency::parallel_for-algoritme en een combinable object gebruikt om thread-local sets te genereren. Vervolgens wordt de concurrency::combinable::combine_each methode gebruikt om de thread-local sets te combineren in de uiteindelijke set.

// parallel-combine-primes.cpp
// compile with: /EHsc
#include <windows.h>
#include <ppl.h>
#include <bitset>
#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;
}

// Determines whether the input value is prime.
bool is_prime(int n)
{
   if (n < 2)
      return false;
   for (int i = 2; i < n; ++i)
   {
      if ((n % i) == 0)
         return false;
   }
   return true;
}

const int limit = 40000;

int wmain()
{
   // A set of prime numbers that is computed serially.
   bitset<limit> primes1;

   // A set of prime numbers that is computed in parallel.
   bitset<limit> primes2;

   __int64 elapsed;

   // Compute the set of prime numbers in a serial loop.
   elapsed = time_call([&] 
   {
      for(int i = 0; i < limit; ++i) {
         if (is_prime(i))
            primes1.set(i);
      }
   });
   wcout << L"serial time: " << elapsed << L" ms" << endl << endl;

   // Compute the same set of numbers in parallel.
   elapsed = time_call([&] 
   {
      // Use a parallel_for loop and a combinable object to compute 
      // the set in parallel. 
      // You do not need to synchronize access to the set because the 
      // combinable object provides a separate bitset object to each thread.
      combinable<bitset<limit>> working;
      parallel_for(0, limit, [&](int i) {
         if (is_prime(i))
            working.local().set(i);
      });

      // Merge each thread-local computation into the final result.
      working.combine_each([&](bitset<limit>& local) {
         primes2 |= local;
      });
   });
   wcout << L"parallel time: " << elapsed << L" ms" << endl << endl;
}

De volgende voorbeelduitvoer is voor een computer met vier processors.

serial time: 312 ms

parallel time: 78 ms

De code compileren

Kopieer de voorbeeldcode en plak deze in een Visual Studio-project, of plak deze in een bestand met de naam parallel-combine-primes.cpp en voer vervolgens de volgende opdracht uit in een Visual Studio-opdrachtpromptvenster.

cl.exe /EHsc-parallel-combine-primes.cpp

Zie ook

parallelle containers en objecten
combineerbare klasse
combineerbaar::combineer_elke Methode