Porady: korzystanie z kontenerów równoległych do zwiększania wydajności
W tym temacie pokazano, jak używać kontenerów równoległych do wydajnego przechowywania danych i uzyskiwania do nich dostępu równolegle.
Przykładowy kod oblicza równolegle zestaw liczb prime i Carmichael. Następnie dla każdej liczby Carmichael kod oblicza podstawowe czynniki tej liczby.
Przykład: określanie, czy wartość wejściowa jest liczbą pierwszą
W poniższym przykładzie is_prime pokazano funkcję, która określa, czy wartość wejściowa jest liczbą pierwszą, a is_carmichael funkcja określa, czy wartość wejściowa jest liczbą 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;
}
Przykład: Obliczanie liczb prime i Carmichael
W poniższym przykładzie użyto is_prime funkcji i is_carmichael do obliczenia zestawów liczb prime i Carmichael. W przykładzie użyto współbieżności::p arallel_invoke i concurrency::p arallel_for algorytmów do obliczenia każdego zestawu równolegle. Aby uzyskać więcej informacji na temat algorytmów równoległych, zobacz Parallel Algorithms (Algorytmy równoległe).
W tym przykładzie użyto obiektu współbieżności::concurrent_queue do przechowywania zestawu liczb Carmichael, ponieważ później będzie on używać tego obiektu jako kolejki roboczej. Używa on obiektu współbieżności::concurrent_vector do przechowywania zestawu liczb pierwszych, ponieważ później będzie iterować przez ten zestaw w celu znalezienia czynników pierwszych.
// 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);
}
});
});
Przykład: znajdowanie wszystkich czynników pierwszych danej wartości
W poniższym przykładzie pokazano prime_factors_of funkcję, która używa podziału próbnego do znalezienia wszystkich głównych czynników danej wartości.
Ta funkcja używa algorytmu concurrency::p arallel_for_each , aby iterować przez kolekcję liczb pierwszych. Obiekt concurrent_vector umożliwia pętli równoległej równoczesne dodawanie czynników pierwszych do wyniku.
// 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;
}
Przykład: przetwarza każdy element w kolejce numerów Carmichael
W tym przykładzie każdy element jest przetwarzany w kolejce numerów Carmichael przez wywołanie prime_factors_of funkcji w celu obliczenia jej czynników pierwszych. Używa grupy zadań do równoległego wykonywania tej pracy. Aby uzyskać więcej informacji na temat grup zadań, zobacz Równoległość zadań.
W tym przykładzie są wyświetlane podstawowe czynniki dla każdej liczby Carmichael, jeśli liczba ta ma więcej niż cztery czynniki pierwsze.
// 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();
Przykład: Ukończono kod kontenera równoległego
Poniższy kod przedstawia kompletny przykład, który używa kontenerów równoległych do obliczania czynników pierwszych liczb 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();
}
W tym przykładzie są generowane następujące przykładowe dane wyjściowe.
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.
Kompilowanie kodu
Skopiuj przykładowy kod i wklej go w projekcie programu Visual Studio lub wklej go w pliku o nazwie carmichael-primes.cpp , a następnie uruchom następujące polecenie w oknie wiersza polecenia programu Visual Studio.
cl.exe /EHsc carmichael-primes.cpp
Zobacz też
Równoległe kontenery oraz obiekty
Równoległość zadań
concurrent_vector, klasa
concurrent_queue, klasa
parallel_invoke, funkcja
parallel_for, funkcja
task_group, klasa