Comment : utiliser des conteneurs parallèles pour une efficacité accrue
Cette rubrique montre comment utiliser des conteneurs parallèles pour stocker et accéder efficacement aux données en parallèle.
L’exemple de code calcule l’ensemble de nombres premiers et Carmichael en parallèle. Ensuite, pour chaque nombre Carmichael, le code calcule les principaux facteurs de ce nombre.
Exemple : déterminer si une valeur d’entrée est un nombre premier
L’exemple suivant montre la is_prime fonction, qui détermine si une valeur d’entrée est un nombre premier et la is_carmichael fonction, qui détermine si la valeur d’entrée est un nombre 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;
}
Exemple : Nombres prime de calcul et Carmichael
L’exemple suivant utilise les fonctions et is_carmichael les is_prime fonctions pour calculer les jeux de nombres premiers et Carmichael. L’exemple utilise les algorithmes concurrency ::p arallel_invoke et concurrency ::p arallel_for pour calculer chaque jeu en parallèle. Pour plus d’informations sur les algorithmes parallèles, consultez Algorithmes parallèles.
Cet exemple utilise un objet concurrency ::concurrent_queue pour contenir l’ensemble des nombres Carmichael, car il utilise ultérieurement cet objet comme file d’attente de travail. Il utilise un objet concurrency ::concurrent_vector pour contenir l’ensemble de nombres premiers, car il effectue ultérieurement une itération dans cet ensemble pour rechercher des facteurs premiers.
// 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);
}
});
});
Exemple : Rechercher tous les principaux facteurs d’une valeur donnée
L’exemple suivant montre la fonction, qui utilise la prime_factors_of division d’évaluation pour rechercher tous les principaux facteurs de la valeur donnée.
Cette fonction utilise l’algorithme concurrency ::p arallel_for_each pour itérer dans la collection de nombres premiers. L’objet concurrent_vector permet à la boucle parallèle d’ajouter simultanément des facteurs premiers au résultat.
// 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;
}
Exemple : traite chaque élément dans la file d’attente des numéros Carmichael
Cet exemple traite chaque élément dans la file d’attente des nombres Carmichael en appelant la prime_factors_of fonction pour calculer ses principaux facteurs. Il utilise un groupe de tâches pour effectuer ce travail en parallèle. Pour plus d’informations sur les groupes de tâches, consultez Parallélisme des tâches.
Cet exemple montre comment imprimer les facteurs premiers de chaque nombre Carmichael si ce nombre comporte plus de quatre facteurs premiers.
// 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();
Exemple : exemple de code de conteneur parallèle terminé
Le code suivant montre l’exemple complet, qui utilise des conteneurs parallèles pour calculer les principaux facteurs des nombres 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();
}
Cet exemple génère l’exemple de sortie suivant.
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.
Compilation du code
Copiez l’exemple de code et collez-le dans un projet Visual Studio, ou collez-le dans un fichier nommé carmichael-primes.cpp , puis exécutez la commande suivante dans une fenêtre d’invite de commandes Visual Studio.
cl.exe /EHsc carmichael-primes.cpp
Voir aussi
Conteneurs et objets parallèles
Parallélisme des tâches
concurrent_vector, classe
concurrent_queue, classe
fonction parallel_invoke
fonction parallel_for
Classe task_group