Temps en millisecondes

En utilisant le code suivant:

#include #include int main() { clock_t start, stop; int i; start = clock(); for(i=0; i<2000;i++) { printf("%d", (i*1)+(1^4)); } printf("\n\n"); stop = clock(); //(double)(stop - start) / CLOCKS_PER_SEC printf("%6.3f", start); printf("\n\n%6.3f", stop); return 0; } 

Je reçois la sortie suivante:



   2.169

   2.169
  1. Les heures de début et de fin sont les mêmes. Cela signifie-t-il que l’exécution du programme prend à peine du temps?

  2. Si 1. est faux, alors au moins le nombre de chiffres au-delà du (.) Devrait différer, ce qui ne se produit pas ici. Est-ce que ma logique est correcte?

Remarque: Je dois calculer le temps nécessaire à l’exécution, et donc le code ci-dessus.

    Oui, ce programme a probablement utilisé moins d’une millième de seconde. Essayez d’utiliser une résolution en microsecondes avec timeval .

    par exemple:

     #include  struct timeval stop, start; gettimeofday(&start, NULL); //do stuff gettimeofday(&stop, NULL); printf("took %lu\n", stop.tv_usec - start.tv_usec); 

    Vous pouvez ensuite interroger la différence (en microsecondes) entre stop.tv_usec - start.tv_usec . Notez que cela ne fonctionnera que toutes les secondes (car tv_usec sera en boucle). Pour le cas général, utilisez une combinaison de tv_sec et tv_usec .

    Éditer le 19/08/2016

    Une approche plus appropriée sur un système avec support clock_gettime serait:

     struct timespec start, end; clock_gettime(CLOCK_MONOTONIC_RAW, &start); //do stuff clock_gettime(CLOCK_MONOTONIC_RAW, &end); uint64_t delta_us = (end.tv_sec - start.tv_sec) * 1000000 + (end.tv_nsec - start.tv_nsec) / 1000; 

    Quelques facteurs peuvent affecter les résultats que vous voyez:

    1. Vous clock_t comme un type à virgule flottante, je ne pense pas.
    2. Vous pourriez vous attendre à ce que ( 1^4 ) fasse autre chose que calculer le XOR au niveau du bit de 1 à 4, c’est-à-dire qu’il s’agit de 5.
    3. Comme le XOR est constitué de constantes, il est probablement plié par le compilateur , ce qui signifie qu’il ne nécessite pas beaucoup de travail au moment de l’exécution.
    4. Étant donné que la sortie est mise en mémoire tampon (il ne s’agit que de formater la chaîne et de l’écrire dans la mémoire), l’opération est très rapide.

    Vous ne spécifiez pas la vitesse de votre machine, mais il n’est pas déraisonnable que cela s’exécute très rapidement sur du matériel moderne, non.

    Si vous l’avez, essayez d’append un appel à sleep() entre les instantanés de démarrage / arrêt. Notez que sleep() est POSIX cependant, pas standard C.

    Cet extrait de code peut être utilisé pour afficher une durée en secondes, millisecondes et microsecondes:

     #include  struct timeval start, stop; double secs = 0; gettimeofday(&start, NULL); // Do stuff here gettimeofday(&stop, NULL); secs = (double)(stop.tv_usec - start.tv_usec) / 1000000 + (double)(stop.tv_sec - start.tv_sec); printf("time taken %f\n",secs); 

    Vous pouvez utiliser gettimeofday() avec la fonction timedifference_msec() ci-dessous pour calculer le nombre de millisecondes écastings entre deux échantillons:

     #include  #include  float timedifference_msec(struct timeval t0, struct timeval t1) { return (t1.tv_sec - t0.tv_sec) * 1000.0f + (t1.tv_usec - t0.tv_usec) / 1000.0f; } int main(void) { struct timeval t0; struct timeval t1; float elapsed; gettimeofday(&t0, 0); /* ... YOUR CODE HERE ... */ gettimeofday(&t1, 0); elapsed = timedifference_msec(t0, t1); printf("Code executed in %f milliseconds.\n", elapsed); return 0; } 

    Notez que lorsque vous utilisez gettimeofday() , vous devez prendre en compte les secondes, même si vous vous souciez uniquement des différences en microsecondes, car tv_usec reviendra à zéro toutes les secondes et vous ne pouvez pas savoir à l’avance à quel point en une seconde chaque échantillon est. obtenu.

    Voici ce que j’écris pour obtenir l’horodatage en millions de secondes.

     #include long long timeInMilliseconds(void) { struct timeval tv; gettimeofday(&tv,NULL); return (((long long)tv.tv_sec)*1000)+(tv.tv_usec/1000); } 

    De l’ horloge homme :

    La fonction clock () renvoie une approximation du temps processeur utilisé par le programme.

    Donc, rien n’indique que vous devriez le traiter en millisecondes. Certaines normes nécessitent une valeur précise de CLOCKS_PER_SEC , vous pouvez donc vous en fier, mais je ne pense pas que cela soit recommandé. La deuxième chose est que, comme @unwind l’a déclaré, il n’est pas float / double. Man times suggère que ce sera un int. Notez également que:

    cette fonction retournera la même valeur environ toutes les 72 minutes

    Et si vous êtes malchanceux, vous pouvez bash au moment où il est sur le sharepoint commencer à compter à partir de zéro, obtenant ainsi une valeur négative ou énorme (selon que vous stockez le résultat en tant que valeur signée ou non signée).

    Ce:

     printf("\n\n%6.3f", stop); 

    Est-ce que le plus probable est d’imprimer des ordures comme traiter n’importe quel int en tant que float n’est vraiment pas un comportement défini (et je pense que c’est là que la plupart de vos problèmes viennent). Si vous voulez vous assurer que vous pouvez toujours faire:

     printf("\n\n%6.3f", (double) stop); 

    Cependant, je préférerais l’imprimer aussi long long int au début:

     printf("\n\n%lldf", (long long int) stop); 

    Les processeurs modernes sont trop rapides pour enregistrer le temps d’exécution. Par conséquent, il peut retourner zéro. Dans ce cas, le temps que vous avez commencé et terminé est trop petit et les deux temps sont donc les mêmes après chaque tour.