Microsecondes C ++

Pour obtenir un temps d'exécution précis dans un programme C ++, le langage de programmation C ++ offre plusieurs options. Vous pouvez écrire votre code personnalisé pour obtenir le temps d'exécution précis, ou vous pouvez utiliser la fonction intégrée pour gagner du temps et de l'énergie. La fonction intégrée fournie par le langage de programmation C ++ aide le développeur à implémenter des processus complexes avec une seule fonction. Dans cet article, nous apprendrons à obtenir le temps d'exécution précis et précis en microsecondes en utilisant les fonctions intégrées C ++. Il existe différentes façons de trouver le temps d'exécution en microsecondes.

Calcul du temps d'exécution du programme C ++ en microsecondes

Malheureusement, il n'y a pas de méthodes pour déterminer le temps d'exécution précis qui fonctionne pour tout le monde. Pour cela, vous devez choisir la solution en fonction de la situation. La mesure du temps d'exécution précise d'un programme C ++ peut être difficile dans certaines situations en raison de problèmes de portabilité. La sélection des bonnes méthodes qui correspondent à votre système d'exploitation et à votre version du compilateur est essentielle pour obtenir un moment précis. Plus important encore, vous devez comprendre ce que vous entendez exactement par «temps» afin que vous puissiez choisir la méthode en conséquence.

Ici, vous trouverez une liste complète de certaines options faciles, simples et meilleures disponibles pour trouver le temps d'exécution d'un programme C ++. Nous énumérons également les limites des fonctions pour vous donner une tête-à-tête avant de commencer à utiliser cette fonction dans votre programme.

J'espère que vous obtiendrez la meilleure option parfaitement adaptée à votre système d'exploitation et à votre version du compilateur.

Exemple 1:

Nous examinerons le temps du mur avec la fonction. La fonction est l'un des moyens les plus portables de trouver le temps du mur dans un programme C ++. Il ne fonctionne qu'avec les versions C ++ 11 et ultérieures. Si vous avez une version plus ancienne, améliorez votre compilateur avant d'utiliser cette fonction. Il a accès à différents types d'horloges dans la machine ayant des caractéristiques et des objectifs différentes.

Ici, nous utilisons le high_resolution_clock pour trouver le temps du mur car il utilise l'horloge la plus élevée disponible qui est probablement adéquate pour la plupart des systèmes. Reportez-vous au code ci-dessous:

#inclure
#inclure
int main ()
double s = 0, a = 1;
auto start = std :: chrono :: high_resolution_clock :: maintenant ();
int it = 1000 * 1000 * 1000;
pour (int i = 0; is + = a;
a / = 2.0;

auto end = std :: chrono :: high_resolution_clock :: maintenant ();
auto elapsed = std :: chrono :: durée_cast (fin - démarrage);
printf ("l'horloge commence à =%.2f \ n ", s);
printf ("Le temps mesuré est =%.3f secondes.\ n ", écoulé.count () * 1e-6);
retour 0;

Le programme commence par deux fichiers d'en-tête stdio.H et Chrono. Le stdio.La bibliothèque H est utilisée conjointement avec les méthodes d'entrée et de sortie standard. La bibliothèque Chrono vous permet d'utiliser la fonction dans votre programme. L'ensemble du programme est écrit dans la fonction principale où toute l'exécution se produit.

Le programme principal commence par l'initialisation de deux variables 'S' et 'A' qui sera utilisée pour garder une trace du temps. La variable 'start' est initialisée avec l'heure actuelle avec la fonction 'Chrono :: High_reolution_clock :: Now ()'.

La variable 'it = 1000 * 1000 * 1000' est initialisée avec le nombre d'itérations qui doivent être effectuées et calcule le temps écoulé en microsecondes. L'action suivante sera effectuée par la boucle «pour» car elle itère de 0 à 1000 * 1000 * 1000 fois.

Une autre variable «fin» est initialisée avec l'heure actuelle pour vérifier le temps écoulé. Lorsque vous calculez «fin - démarrer», vous obtiendrez le temps d'exécution écoulé. Les «chrono :: microsecondes» fourniront le temps d'exécution en microsecondes qui sera converti en secondes avec `` écoulé.count () * 1e-6 'calcul. Les instructions printf () imprimeront l'heure de début et l'heure écoulée. Et enfin, l'instruction RETOUR 0 garantit que le programme est exécuté avec succès.

Lorsque vous exécutez le code complet, une sortie similaire sera produite en fonction de la vitesse d'exécution et de l'efficacité de votre système:

Exemple 2:

Dans le code ci-dessous, nous utilisons la fonction gettimeofday () pour trouver l'heure écoulée car l'heure de l'époque est «1er, janvier 1970, 00:00:00 UTC». La fonction getTimeOfday () renvoie l'heure dans les microsecondes et les secondes. Par conséquent, pour trouver le temps précis en microsecondes, les deux fois doivent être résumés ensemble. Le code ci-dessous vous aidera à calculer le temps d'exécution en microsecondes en utilisant

#inclure
#inclure
int main ()
double s = 0, a = 1;
Struct TimeVal Start, End;
getTimeOfday (& start, 0);
int it = 1000 * 1000 * 1000;
pour (int i = 0; is + = a;
a / = 2.0;

getTimeOfday (& end, 0);
long sec = fin.tv_sec - démarrer.tv_sec;
Micro = fin.tv_usec - démarrer.tv_usec;
Double Elapsed = Sec + Micro * 1E-6;
printf ("l'horloge commence à =%.20f \ n ", s);
printf ("Le temps mesuré est =%.3f secondes.\ n ", écoulé);
retour 0;

La fonction getTimeOfday () est incluse dans le fichier d'en-tête.

Le «struct timeval» est une structure temporelle utilisée pour représenter le temps écoulé.

Le temps calculé en secondes et microsecondes est ajouté pour obtenir le temps d'exécution exact en microsecondes. La fonction 'TV_SEC' offre le temps en secondes et 'TV_USEC' fournit l'heure en microsecondes. Pour convertir les secondes en microsecondes, multipliez les microsecondes par 1E-6. Après cela, ajoutez les deux fois en secondes et microsecondes pour obtenir le temps d'exécution précis en microsecondes.

Maintenant, cliquez sur l'icône Compiler et Exécuter dans la barre d'icône du logiciel Dev C ++. Appuyez sur la touche F11 sur le clavier pour exécuter le programme. La sortie exécutée est donnée ci-dessous:

Exemple 3:

Dans cet exemple, nous utilisons la bibliothèque et sa fonction Time (). La fonction Time () fonctionne de manière similaire à la fonction gettimeofday () offrant l'heure écoulée depuis l'heure de l'époque. Cependant, il ne mesure que des secondes complètes et vous ne pouvez pas définir le fuseau horaire. Par conséquent, si les intervalles mesurés sont supérieurs à une seconde, la fonction Time () est logique. Ce n'est peut-être pas la première préférence pour obtenir les microsecondes et vous pouvez utiliser d'autres fonctions à la place. Voir le code ci-dessous:

#inclure
#inclure
int main ()
double s = 0, a = 1;
Time_t start, end;
Time (& Start);
int it = 1000 * 1000 * 1000;
pour (int i = 0; is + = a;
a / = 2.0;

Temps (& fin);
Time_t elapsed = end - start;
printf ("Résultat:%.20f \ n ", s);
printf ("Temps mesuré:% ld secondes.\ n ", écoulé);
retour 0;

La fonction Time () fournira l'heure de début et de fin de l'exécution et le temps écoulé peut facilement être calculé avec une instruction «fin - démarrage». Voir le résultat ci-dessous:

Notez que le temps écoulé calculé avec la fonction Time () est 6S, pas le 6 exact.833 microsecondes. La différence dans le résultat de la fonction Time () est observée dans la sortie.

Conclusion

Diverses méthodes calculent le temps d'exécution du système à l'aide d'un programme C ++. Cependant, aucune solution n'est parfaite pour chaque situation et chaque fonction fonctionne différemment dans différentes situations. Ici, nous avons appris à utiliser le temps (), getTimeOfday () et les fonctions pour obtenir le temps d'exécution en microsecondes.