printf plus de 5 fois plus rapide que std::cout?

#include <iostream>
#include <cstdlib>
#include <cstdio>
#include <ctime>

int main(int argc, char* argv[])
{
    std::clock_t start;
    double duration;    

    std::cout << "Starting std::cout test." << std::endl;
    start = std::clock();

    for (int i = 0; i < 1000; i++)
    {
        std::cout << "Hello, World! (" << i << ")" << std::endl;
    }

    duration = (std::clock() - start) / (double) CLOCKS_PER_SEC;

    std::cout << "Ending std::cout test." << std::endl;
    std::cout << "Time taken: " << duration << std::endl;

    std::system("pause");

    std::cout << "Starting std::printf test." << std::endl;
    start = std::clock();

    for (int i = 0; i < 1000; i++)
    {
        std::printf("Hello, World! (%i)\n", i);
        std::fflush(stdout);
    }

    duration = (std::clock() - start) / (double) CLOCKS_PER_SEC;

    std::cout << "Ending std::printf test." << std::endl;
    std::cout << "Time taken: " << duration << std::endl;

    system("pause");

    return 0;
}

Maintenant, voici les temps pour les cinq premières pistes:

std::cout test: 1.125 s ; printf test: 0.195 s
std::cout test: 1.154 s ; printf test: 0.230 s
std::cout test: 1.142 s ; printf test: 0.216 s
std::cout test: 1.322 s ; printf test: 0.221 s
std::cout test: 1.108 s ; printf test: de 0,232 s

Comme vous pouvez le voir, à l'aide de printf et puis fflushing prend environ 5 fois moins de temps que l'utilisation std::cout.

Bien que je ne l'attends à l'aide de std::cout's << opérateur pour être peut-être un peu plus lent (presque minimale) , je n'étais pas préparé à cette énorme différence. Suis-je faire un test juste? Si oui, alors ce qui fait le premier test beaucoup plus lent que la seconde, si ils font essentiellement la même chose?

Il n'a encastré dans le printf version trop bien, donc ça ne peut pas être?
Le double question ne répond pas à ma question principale, **what makes** the first test so much slower than the second one... je.e pourquoi est exactement le printf plus vite?
Il y a peut-être pas une seule bonne réponse autre que la qualité de la mise en œuvre de bibliothèque que vous utilisez. Il y a eu des questions similaires, tels que lié. Lire et les questions connexes des liens vers elle.
Notez que std::cout << "Hello, World! (" << i << ")" << std::endl; est de 4 appels de fonction, tandis que printf est seul. Essayez de faire printf 5 fois, comme avec cout et voir ce qui se passe. Ensuite, vous vous rendrez compte comment une grande partie de la performance de l'échec est dû à des appels de fonction, et combien, en raison de la bibliothèque elle-même.
Votre timings sont vide de sens que le std::cout est synchronisé avec la sortie standard (stdout) et n'a donc beaucoup de "plus" du travail pour maintenir la synchronisation. Si vous dissociez eux, vous pourrez voir une accélération (c'est encore plus lent) std::cout.sync_with_stdio(false);

OriginalL'auteur ApprenticeHacker | 2012-08-20

c++cout performance printf

9

Pour un véritable pommes avec des pommes comparaison, de ré-écrire votre essai de sorte que le seulement chose de changer entre les cas de test est la fonction d'impression utilisé:
```
int main(int argc, char* argv[])
{
    const char* teststring = "Test output string\n";
    std::clock_t start;
    double duration;

    std::cout << "Starting std::cout test." << std::endl;
    start = std::clock();

    for (int i = 0; i < 1000; i++)
        std::cout << teststring;
    /* Display timing results, code trimmed for brevity */

    for (int i = 0; i < 1000; i++) {
        std::printf(teststring);
        std::fflush(stdout);
    }
    /* Display timing results, code trimmed for brevity */
    return 0;
}
```
Avec cela, vous serez tests de rien, mais les différences entre les printf et cout appels de fonction. Vous n'aurez pas à supporter les différences dues à de multiples << appels, etc. Si vous essayez cela, je soupçonne que vous obtiendrez un résultat différent.

Hmm, maintenant, c'est seulement une différence d'environ 0,06 s. Devinez qui répond à ma question.
il semble injuste de test. Pour printf section vous rinçage stdout après chaque itération, mais le std::cout de code n'est pas. Devrait probablement ajouter << std::flush(); std::cout de la section.
Ajoutez la ligne suivante: std::cout.sync_with_stdio(false);
Ce n'est pas une comparaison utile si la différence de performances entre cout et de printf est due à la mise en forme du numéro d'une chaîne de caractères.
Si la différence est due à exiger beaucoup plus de << appels que printf d'appels, il est tout à fait pertinent de les comparer de cette façon. Il n'est pas réaliste pour simplifier le test à la mesure que vous avez.

OriginalL'auteur bta

Essayez ceci:

#include <cstdlib>
#include <cstdio>
#include <ctime>
#include <iostream>

int main(int argc, char* argv[])
{
#if defined(NOSYNC)
    std::cout.sync_with_stdio(false);
#endif

    std::cout << "Starting std::cout test." << std::endl;

    std::clock_t start = std::clock();

    for (int i = 0; i < 1000; i++)
    {   
        std::cout << "Hello, World! (" << i << ")" << std::endl;
    }   

    clock_t mid = std::clock();

    for (int i = 0; i < 1000; i++)
    {   
        std::printf("Hello, World! (%i)\n", i); 
        std::fflush(stdout);
    }   

    std::clock_t end = std::clock();

    std::cout << "Time taken: P1 " << ((mid-start)*1.0/CLOCKS_PER_SEC) << std::endl;

    std::cout << "Time taken: P2 " << ((end-mid)*1.0/CLOCKS_PER_SEC) << std::endl;


    return 0;
}

Puis-je obtenir:

> g++ -O3 t13.cpp
> ./a.out
# lots of lines deleted
Time taken: P1 0.002517
Time taken: P2 0.001872

> g++ -O3 t13.cpp -DNOSYNC   
> ./a.out
# lots of lines deleted
Time taken: P1 0.002398
Time taken: P2 0.001878

De sorte que le P2 ne changent pas.

Mais vous obtenez une amélioration de la P1 fois (c'est à dire std::cout) à l'aide de std::cout.sync_with_stdio(false);. Parce que le code n'essaie plus de garder les deux flux (std::cout stdout) synchronisée. Qui, si vous l'écriture de C++ pur, et n'utiliser std::cout n'est pas un problème.

OriginalL'auteur Martin York

3

utilisation
```
cout << "\n";
```
pour empêcher la mise en mémoire tampon. beaucoup plus rapide

OriginalL'auteur Jason
1

Y a environ 10 ans, Scott Meyers testé l'efficacité de iostream et scanf/printf. Dépend du compilateur et de l'environnement, parfois scanf/printf est 20% plus rapide que iostream, parfois même à 200% plus rapide. Mais iostream n'a jamais été plus rapide que scanf/printf. Selon deux autres exemples donnés, scanf/printf est encore plus rapide que iostream.
Cependant, Meyers a dit que "vraiment Sur un programme utile, il n'y aurait pas de différences."
Selon Google,"s style de programmation([http://google-styleguide.googlecode.com/svn/trunk/cppguide.html%5D), les flux ne doit pas être utilisée, sauf pour l'enregistrement.
Un remplacement pour iostream est à encapsule scanf/printf vous-même.

OriginalL'auteur Tianze.Chen
0

Je n'ai qu'une programmation de gamme de 1 ordinateur, donc pas beaucoup de tests. De toute façon, std::cout est beaucoup plus rapide sur mon build en utilisant exactement les verbose code. Je suis à l'aide de Cpp14.

Je pense juste que certaines personnes ont une reprise pour le C++. Oui C est une grande langue, mais, logiquement, je ne vois pas comment printf peuvent être plus rapides que les mst cout. Printf a faire des conversions de type de void pointeur sur l'exécution. Le Cout n'est qu'au moment de la compilation.

Si iostreams sont en effet plus rapide sur votre plate-forme, il serait utile de savoir ce que cette plate-forme est. La raison que iostreams ont tendance à être beaucoup plus lent que printf, c'est que iostreams utiliser un grand nombre d'appels de fonctions, y compris beaucoup de virtuel appels de fonction (un iostream ne pas le faire tout, par lui-même, il transmet le tout à un streambuf fonction virtuelle). C'est très utile si vous avez besoin de rediriger le flux, mais un gaspillage si vous ne l'utilisez pas.
Bon, je ne sais pas vraiment quelle plate-forme vous vous référez, mais je suis à l'aide de Win 10, Intel Celeron CPU G3900, 4go de Ram, RPC 14. Vous devez vous souvenir du RPC évolue tous les trois ans. Beaucoup d'appels de fonction sont compilés à l'écart.
Le compilateur et qui C++ de la bibliothèque standard sont des éléments très importants de la plate-forme... le CPU (dont vous avez parlé, et contient également des informations sur le cache) et la RAM (dont vous avez parlé seulement la taille, mais pas la fréquence d'horloge, DDR génération, le nombre de canaux, ou latence) sont de moins en moins important dans ce cas, mais peut parfois avoir un grand effet sur la performance et l'optimisation.

OriginalL'auteur Javene CPP McGowan

Vous devez vous connecter pour publier un commentaire.