Comment beaucoup de différence de performances lors de l'utilisation chaîne vs char tableau?

Faisons tourner les chiffres:

Le code (j'ai utilisé PAPI des Chronomètres)

main.cpp

#include <iostream>
#include <string>
#include <stdio.h>
#include "papi.h"
#include <vector>
#include <cmath>
#define TRIALS 10000000
class Clock
{
public:
typedef long_long time;
time start;
Clock() : start(now()){}
void restart(){ start = now(); }
time usec() const{ return now() - start; }
time now() const{ return PAPI_get_real_usec(); }
};
int main()
{
int eventSet = PAPI_NULL;
PAPI_library_init(PAPI_VER_CURRENT);
if(PAPI_create_eventset(&eventSet)!=PAPI_OK) 
{
std::cerr << "Failed to initialize PAPI event" << std::endl;
return 1;
}
Clock clock;
std::vector<long_long> usecs;
const char* baseLocation = "baseLocation";
//std::string baseLocation = "baseLocation";
char fname[255] = {};
for (int i=0;i<TRIALS;++i)
{
clock.restart();
snprintf(fname, 255, "%s_test_no.%d.txt", baseLocation, i);
//std::string fname = baseLocation + "_test_no." + std::to_string(i) + ".txt";
usecs.push_back(clock.usec());
}
long_long sum = 0;
for(auto vecIter = usecs.begin(); vecIter != usecs.end(); ++vecIter)
{
sum+= *vecIter;
}
double average = static_cast<double>(sum)/static_cast<double>(TRIALS);
std::cout << "Average: " << average << " microseconds" << std::endl;
//compute variance
double variance = 0;
for(auto vecIter = usecs.begin(); vecIter != usecs.end(); ++vecIter)
{
variance += (*vecIter - average) * (*vecIter - average);
}
variance /= static_cast<double>(TRIALS);
std::cout << "Variance: " << variance << " microseconds" << std::endl;
std::cout << "Std. deviation: " << sqrt(variance) << " microseconds" << std::endl;
double CI = 1.96 * sqrt(variance)/sqrt(static_cast<double>(TRIALS));
std::cout << "95% CI: " << average-CI << " usecs to " << average+CI << " usecs" << std::endl;  
}

Jouer avec les commentaires d'obtenir d'une façon ou de l'autre.
10 millions d'itérations de ces deux méthodes sur ma machine avec la ligne de compilation:

g++ main.cpp -lpapi -DUSE_PAPI -std=c++0x -O3

À l'aide de char tableau:

Average: 0.240861 microseconds
Variance: 0.196387microseconds
Std. deviation: 0.443156 microseconds
95% CI: 0.240586 usecs to 0.241136 usecs

L'aide de la chaîne approche:

Average: 0.365933 microseconds
Variance: 0.323581 microseconds
Std. deviation: 0.568842 microseconds
95% CI: 0.365581 usecs to 0.366286 usecs

Ainsi, au moins sur MA machine avec MON code et MON compilateur paramètres, j'ai vu environ 50% de ralentissement lors du déplacement de chaînes de caractères. que des tableaux de caractères de subir une 34% de l'accélération sur les chaînes à l'aide de la formule suivante:

((le temps de la chaîne) - (temps de char array) ) /(temps de chaîne)

Qui donne la différence de temps entre les approches en pourcentage sur le temps pour cordes seules. Mon pourcentage était correcte; j'ai utilisé le tableau de caractères approche comme un point de référence au lieu de cela, ce qui montre une 52% ralentissement lors du passage à la chaîne, mais j'ai trouvé qu'il était erroné.

Je vais prendre tout et tous les commentaires pour la façon dont je l'ai fait de mal 🙂

---

Edit: Compilé avec GCC 4.8.4:

chaîne

Average: 0.338876 microseconds
Variance: 0.853823 microseconds
Std. deviation: 0.924026 microseconds
95% CI: 0.338303 usecs to 0.339449 usecs

tableau de caractères

Average: 0.239083 microseconds
Variance: 0.193538 microseconds
Std. deviation: 0.439929 microseconds
95% CI: 0.238811 usecs to 0.239356 usecs

De sorte que le tableau de caractères approche reste nettement plus rapide bien que moins. Dans ces tests, il était d'environ 29% plus rapide.

OriginalL'auteur AndyG

Si c'est VRAIMENT important, de mesurer les deux solutions. Si non, selon ce que vous pensez que plus de sens à partir de ce que les données que vous avez, de l'entreprise privée/style de codage des normes, etc. Assurez-vous d'utiliser de manière optimale construire, avec la même optimisation que vous allez utiliser dans la production réelle de construire, pas -O3 parce que c'est le plus élevé, si votre production de construire est aide -O1]

Je pense que les deux sont assez proches si vous ne faites qu'un peu. Si vous disposez de plusieurs millions, il peut y avoir une différence. Ce qui est plus rapide? Je suppose que le second [1], mais cela dépend de la personne qui a écrit la mise en œuvre de snprintf et qui a écrit le std::string mise en œuvre. Les deux ont certainement le potentiel pour prendre beaucoup plus de temps que vous attendez d'une approche naïve de la façon dont la fonction fonctionne (et peut-être courir plus vite que vous attendez)

[1] Parce que j'ai travaillé avec printf, et ce n'est pas une simple fonction, il passe beaucoup de temps à bricoler avec divers groking de la chaîne de format. Ce n'est pas très efficace (et j'ai regardé ceux de la glibc et ces trop, et ils ne sont pas nettement mieux).
D'autre part std::string fonctions sont souvent incorporé depuis qu'ils sont modèle implémentations, ce qui améliore l'efficacité. Le joker dans le pack est de savoir si l'allocation de mémoire pour std::string qui est susceptible de se produire. Bien sûr, si en quelque sorte baselocation s'avère être plutôt grand, vous ne voulez probablement pas à le stocker en tant que fixe la taille des locaux de la matrice de toute façon, ce qui égalise dans ce cas.

OriginalL'auteur Mats Petersson