Postupy: Použití paralelních kontejnerů ke zvýšení účinnosti
Toto téma ukazuje, jak používat paralelní kontejnery k efektivnímu ukládání a přístupu k datům paralelně.
Ukázkový kód vypočítá sadu čísel prime a Carmichael paralelně. Pak kód pro každé číslo Carmichael vypočítá základní faktory tohoto čísla.
Příklad: Určení, jestli je vstupní hodnota primárním číslem
Následující příklad ukazuje is_prime funkci, která určuje, zda vstupní hodnota je primární číslo, a is_carmichael funkce, která určuje, zda vstupní hodnota je Číslo Carmichael.
// 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;
}
// Determines whether the input value is a Carmichael number.
bool is_carmichael(const int n)
{
if (n < 2)
return false;
int k = n;
for (int i = 2; i <= k / i; ++i)
{
if (k % i == 0)
{
if ((k / i) % i == 0)
return false;
if ((n - 1) % (i - 1) != 0)
return false;
k /= i;
i = 1;
}
}
return k != n && (n - 1) % (k - 1) == 0;
}
Příklad: Výpočetní čísla prime a Carmichael
Následující příklad používá is_prime a is_carmichael funkce k výpočtu množin čísel prime a Carmichael. Příklad používá souběžnost::p arallel_invoke a concurrency::p arallel_for algoritmy k výpočtu každé sady paralelně. Další informace o paralelních algoritmech naleznete v tématu Paralelní algoritmy.
Tento příklad používá souběžnost::concurrent_queue objekt k uložení sady čísel Carmichael, protože později použije tento objekt jako pracovní frontu. Používá souběžnost::concurrent_vector objekt k uložení sady primárních čísel, protože později iteruje touto sadou, aby našel základní faktory.
// The maximum number to test.
const int max = 10000000;
// Holds the Carmichael numbers that are in the range [0, max).
concurrent_queue<int> carmichaels;
// Holds the prime numbers that are in the range [0, sqrt(max)).
concurrent_vector<int> primes;
// Generate the set of Carmichael numbers and the set of prime numbers
// in parallel.
parallel_invoke(
[&] {
parallel_for(0, max, [&](int i) {
if (is_carmichael(i)) {
carmichaels.push(i);
}
});
},
[&] {
parallel_for(0, int(sqrt(static_cast<double>(max))), [&](int i) {
if (is_prime(i)) {
primes.push_back(i);
}
});
});
Příklad: Vyhledání všech hlavních faktorů dané hodnoty
Následující příklad ukazuje prime_factors_of funkci, která pomocí dělení zkušební verze najde všechny základní faktory dané hodnoty.
Tato funkce používá souběžnost::p arallel_for_each algoritmus k iteraci prostřednictvím kolekce primárních čísel. Objekt concurrent_vector umožňuje paralelní smyčce souběžně přidávat do výsledku základní faktory.
// Finds all prime factors of the given value.
concurrent_vector<int> prime_factors_of(int n,
const concurrent_vector<int>& primes)
{
// Holds the prime factors of n.
concurrent_vector<int> prime_factors;
// Use trial division to find the prime factors of n.
// Every prime number that divides evenly into n is a prime factor of n.
const int max = sqrt(static_cast<double>(n));
parallel_for_each(begin(primes), end(primes), [&](int prime)
{
if (prime <= max)
{
if ((n % prime) == 0)
prime_factors.push_back(prime);
}
});
return prime_factors;
}
Příklad: Zpracovává každý prvek ve frontě čísel Carmichael
Tento příklad zpracuje každý prvek ve frontě čísel Carmichael voláním prime_factors_of funkce pro výpočet jeho primárních faktorů. K provádění této práce používá skupinu úloh paralelně. Další informace o skupinách úloh naleznete v tématu Paralelismus úkolu.
Tento příklad vytiskne základní faktory pro každé číslo Carmichael, pokud má toto číslo více než čtyři základní faktory.
// Use a task group to compute the prime factors of each
// Carmichael number in parallel.
task_group tasks;
int carmichael;
while (carmichaels.try_pop(carmichael))
{
tasks.run([carmichael,&primes]
{
// Compute the prime factors.
auto prime_factors = prime_factors_of(carmichael, primes);
// For brevity, print the prime factors for the current number only
// if there are more than 4.
if (prime_factors.size() > 4)
{
// Sort and then print the prime factors.
sort(begin(prime_factors), end(prime_factors));
wstringstream ss;
ss << L"Prime factors of " << carmichael << L" are:";
for_each (begin(prime_factors), end(prime_factors),
[&](int prime_factor) { ss << L' ' << prime_factor; });
ss << L'.' << endl;
wcout << ss.str();
}
});
}
// Wait for the task group to finish.
tasks.wait();
Příklad: Dokončená ukázka paralelního kódu kontejneru
Následující kód ukazuje úplný příklad, který používá paralelní kontejnery k výpočtu primárních faktorů čísel Carmichael.
// carmichael-primes.cpp
// compile with: /EHsc
#include <ppl.h>
#include <concurrent_queue.h>
#include <concurrent_vector.h>
#include <iostream>
#include <sstream>
using namespace concurrency;
using namespace std;
// 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;
}
// Determines whether the input value is a Carmichael number.
bool is_carmichael(const int n)
{
if (n < 2)
return false;
int k = n;
for (int i = 2; i <= k / i; ++i)
{
if (k % i == 0)
{
if ((k / i) % i == 0)
return false;
if ((n - 1) % (i - 1) != 0)
return false;
k /= i;
i = 1;
}
}
return k != n && (n - 1) % (k - 1) == 0;
}
// Finds all prime factors of the given value.
concurrent_vector<int> prime_factors_of(int n,
const concurrent_vector<int>& primes)
{
// Holds the prime factors of n.
concurrent_vector<int> prime_factors;
// Use trial division to find the prime factors of n.
// Every prime number that divides evenly into n is a prime factor of n.
const int max = sqrt(static_cast<double>(n));
parallel_for_each(begin(primes), end(primes), [&](int prime)
{
if (prime <= max)
{
if ((n % prime) == 0)
prime_factors.push_back(prime);
}
});
return prime_factors;
}
int wmain()
{
// The maximum number to test.
const int max = 10000000;
// Holds the Carmichael numbers that are in the range [0, max).
concurrent_queue<int> carmichaels;
// Holds the prime numbers that are in the range [0, sqrt(max)).
concurrent_vector<int> primes;
// Generate the set of Carmichael numbers and the set of prime numbers
// in parallel.
parallel_invoke(
[&] {
parallel_for(0, max, [&](int i) {
if (is_carmichael(i)) {
carmichaels.push(i);
}
});
},
[&] {
parallel_for(0, int(sqrt(static_cast<double>(max))), [&](int i) {
if (is_prime(i)) {
primes.push_back(i);
}
});
});
// Use a task group to compute the prime factors of each
// Carmichael number in parallel.
task_group tasks;
int carmichael;
while (carmichaels.try_pop(carmichael))
{
tasks.run([carmichael,&primes]
{
// Compute the prime factors.
auto prime_factors = prime_factors_of(carmichael, primes);
// For brevity, print the prime factors for the current number only
// if there are more than 4.
if (prime_factors.size() > 4)
{
// Sort and then print the prime factors.
sort(begin(prime_factors), end(prime_factors));
wstringstream ss;
ss << L"Prime factors of " << carmichael << L" are:";
for_each (begin(prime_factors), end(prime_factors),
[&](int prime_factor) { ss << L' ' << prime_factor; });
ss << L'.' << endl;
wcout << ss.str();
}
});
}
// Wait for the task group to finish.
tasks.wait();
}
Tento příklad vytvoří následující ukázkový výstup.
Prime factors of 9890881 are: 7 11 13 41 241.
Prime factors of 825265 are: 5 7 17 19 73.
Prime factors of 1050985 are: 5 13 19 23 37.
Probíhá kompilace kódu
Zkopírujte ukázkový kód a vložte ho do projektu sady Visual Studio nebo ho vložte do pojmenovaného carmichael-primes.cpp souboru a potom v okně příkazového řádku sady Visual Studio spusťte následující příkaz.
cl.exe /EHsc carmichael-primes.cpp
Viz také
Paralelní kontejnery a objekty
Paralelismus úkolu
concurrent_vector – třída
concurrent_queue – třída
parallel_invoke – funkce
parallel_for – funkce
task_group – třída