Je suis en train d'exécuter un simple programme de test sur un ordinateur Windows (compilé avec MSVS2015) et un serveur exécutant Solaris 10 (compilé avec GCC 4.9.3). Sous Windows, j'obtiens des augmentations de performances significatives en augmentant les threads de 1 à la quantité de cœurs disponibles; cependant, le même code ne voit aucun gain de performances sur Solaris 10.std :: performances asynchrones sous Windows et Solaris 10
La machine Windows dispose de 4 cœurs (8 logiques) et la machine Unix de 8 cœurs (16 logiques).
Quelle est la cause de ceci? Je compile avec -pthread, et est créant des discussions car il imprime tous les "S" es avant le premier "F". Je n'ai pas d'accès root sur la machine Solaris, et d'après ce que je peux voir il n'y a aucun outil installé que je peux utiliser pour voir l'affinité d'un processus.
code Exemple:
#include <iostream>
#include <vector>
#include <future>
#include <random>
#include <chrono>
std::default_random_engine gen(std::chrono::system_clock::now().time_since_epoch().count());
std::normal_distribution<double> randn(0.0, 1.0);
double generate_randn(uint64_t iterations)
{
// Print "S" when a thread starts
std::cout << "S";
std::cout.flush();
double rvalue = 0;
for (int i = 0; i < iterations; i++)
{
rvalue += randn(gen);
}
// Print "F" when a thread finishes
std::cout << "F";
std::cout.flush();
return rvalue/iterations;
}
int main(int argc, char *argv[])
{
if (argc < 2)
return 0;
uint64_t count = 100000000;
uint32_t threads = std::atoi(argv[1]);
double total = 0;
std::vector<std::future<double>> futures;
std::chrono::high_resolution_clock::time_point t1;
std::chrono::high_resolution_clock::time_point t2;
// Start timing
t1 = std::chrono::high_resolution_clock::now();
for (int i = 0; i < threads; i++)
{
// Start async tasks
futures.push_back(std::async(std::launch::async, generate_randn, count/threads));
}
for (auto &future : futures)
{
// Wait for tasks to finish
future.wait();
total += future.get();
}
// End timing
t2 = std::chrono::high_resolution_clock::now();
// Take the average of the threads' results
total /= threads;
std::cout << std::endl;
std::cout << total << std::endl;
std::cout << "Finished in " << std::chrono::duration_cast<std::chrono::milliseconds>(t2 - t1).count() << " ms" << std::endl;
}
Tout juste en haut de ma tête, essayez de déplacer les déclarations de 'gen' et' randn' dans 'generate_randn', de sorte qu'il y ait une instance RNG par thread au lieu d'un seul RNG partagé. Je serais également intéressé de voir la distribution complète des temps d'exécution par thread. – zwol
Vous aviez raison, ça a bien fonctionné après avoir déplacé gen et randn à l'intérieur de generate_randn! Ajoutez-le comme une réponse et je le marquerai. :) –