Temps d'exécution du programme C


209

J'ai un programme C qui vise à être exécuté en parallèle sur plusieurs processeurs. Je dois pouvoir enregistrer le temps d'exécution (qui peut aller de 1 seconde à plusieurs minutes). J'ai cherché des réponses, mais elles semblent toutes suggérer d'utiliser la clock()fonction, ce qui implique ensuite de calculer le nombre d'horloges prises par le programme divisé par la Clocks_per_secondvaleur.

Je ne sais pas comment la Clocks_per_secondvaleur est calculée?

En Java, je prends juste l'heure actuelle en millisecondes avant et après l'exécution.

Y a-t-il une chose similaire en C? J'ai jeté un coup d'œil, mais je n'arrive pas à trouver un moyen d'obtenir quelque chose de mieux qu'une deuxième résolution.

Je suis également conscient qu'un profileur serait une option, mais je cherche à implémenter un minuteur moi-même.

Merci


3
Quels frameworks OS / API utilisez-vous / disponibles? Tout simplement C?
typo.pl

4
C'est un programme assez petit, tout simplement C
Roger

J'ai écrit en détail sur la mise en œuvre d'une solution portable dans cette réponse: stackoverflow.com/questions/361363/…
Alexander Saprykin

temps nécessaire pour exécuter une fonction complète stackoverflow.com/a/40380118/6180077
Abdullah Farweez

Réponses:


344

CLOCKS_PER_SECest une constante qui est déclarée en <time.h>. Pour obtenir le temps CPU utilisé par une tâche dans une application C, utilisez:

clock_t begin = clock();

/* here, do your time-consuming job */

clock_t end = clock();
double time_spent = (double)(end - begin) / CLOCKS_PER_SEC;

Notez que cela renvoie l'heure comme un type à virgule flottante. Cela peut être plus précis qu'une seconde (par exemple, vous mesurez 4,52 secondes). La précision dépend de l'architecture; sur les systèmes modernes, vous obtenez facilement 10 ms ou moins, mais sur les machines Windows plus anciennes (de l'ère Win98), elle était plus proche de 60 ms.

clock()est la norme C; ça marche "partout". Il existe des fonctions spécifiques au système, telles quegetrusage() sur les systèmes de type Unix.

Java System.currentTimeMillis()ne mesure pas la même chose. Il s'agit d'une "horloge murale": elle peut vous aider à mesurer le temps nécessaire au programme pour s'exécuter, mais elle ne vous indique pas combien de temps CPU a été utilisé. Sur un système multitâche (c'est-à-dire tous), ceux-ci peuvent être très différents.


1
Cela me donne un résultat très aléatoire - j'obtiens un mélange de grand / petit / nombre négatif sur le même morceau de code. GCC 4.7 Linux 3.2 AMD64

3
Oui: clock()renvoie une heure dans une échelle interne appelée "horloges", et CLOCKS_PER_SECest le nombre d'horloges par seconde, donc la division par CLOCKS_PER_SECdonne une heure en secondes. Dans le code ci-dessus, la valeur est un doubleafin que vous puissiez la mettre à l'échelle à volonté.
Thomas Pornin

18
Gros avertissement: clock () renvoie le temps que le système d'exploitation a passé à exécuter votre processus, et non le temps réel écoulé. Cependant, c'est bien pour chronométrer un bloc de code, mais pas pour mesurer le temps qui s'écoule dans le monde réel.

2
Il a dit qu'il voulait mesurer un programme multi-thread. Je ne suis pas sûr qu'une horloge () convienne à cela, car elle résume les temps d'exécution de tous les threads, donc le résultat ressemblera si le code a été exécuté séquentiellement. Pour de telles choses, j'utilise omp_get_wtime (), mais bien sûr, je dois m'assurer que le système n'est pas occupé avec d'autres processus.
Youda008

1
Je devrais mentionner certaines choses même si ce fil était plus pertinent il y a un an: CLOCKS_PER_SECest un long intavec la valeur 1000000, donnant le temps en microsecondes lorsqu'il n'est pas divisé; pas les cycles d'horloge du processeur. Par conséquent, il n'a pas besoin de tenir compte de la fréquence dynamique car l'horloge ici est en microsecondes (peut-être des cycles d'horloge pour un processeur à 1 MHz?) J'ai fait un court programme C en imprimant cette valeur et c'était 1000000 sur mon ordinateur portable i7-2640M, avec une fréquence dynamique permettant de 800 MHz à 2,8 GHz, même en utilisant Turbo Boost pour aller jusqu'à 3,5 GHz.
DDPWNAGE

111

Si vous utilisez le shell Unix pour l'exécution, vous pouvez utiliser la commande time.

Faire

$ time ./a.out

en supposant a.out que l'exécutable vous donnera le temps nécessaire pour exécuter cette


3
@acgtyrant mais uniquement pour les programmes simples, car cela prendra tout le temps du programme, y compris les entrées, les sorties, etc.
phuclv

1
Si vous êtes sous Linux et que vous avez réduit votre (micro) benchmark à un programme avec une surcharge de démarrage négligeable, par exemple un exécutable statique qui exécute votre boucle chaude pendant quelques secondes, vous pouvez utiliser perf stat ./a.outpour obtenir des compteurs de performances matérielles pour les échecs de cache et les erreurs de prédiction des succursales et IPC.
Peter Cordes

61

En vanille nature C:

#include <time.h>
#include <stdio.h>

int main()
{
    clock_t tic = clock();

    my_expensive_function_which_can_spawn_threads();

    clock_t toc = clock();

    printf("Elapsed: %f seconds\n", (double)(toc - tic) / CLOCKS_PER_SEC);

    return 0;
}

6
Les meilleurs noms de variables que j'ai vus depuis un moment. tic = "time in clock", toc = "time out clock". Mais aussi tic-toc = "tick-tock". C'est ainsi que j'étiquette le temps gagné à partir de maintenant.
Logan Schelly

60

Vous voulez fonctionnellement cela:

#include <sys/time.h>

struct timeval  tv1, tv2;
gettimeofday(&tv1, NULL);
/* stuff to do! */
gettimeofday(&tv2, NULL);

printf ("Total time = %f seconds\n",
         (double) (tv2.tv_usec - tv1.tv_usec) / 1000000 +
         (double) (tv2.tv_sec - tv1.tv_sec));

Notez que cela mesure en microsecondes, pas seulement en quelques secondes.


2
Le compilateur MinGW est basé sur GCC. Donc ça va marcher dessus. Mais si vous utilisez le compilateur Visual C, vous obtiendrez une erreur.
user2550754

11
Oui, cela fonctionnera sur Windows avec une bibliothèque AC qui prend en charge l'appel gettimeofday. Peu importe le compilateur, il suffit de le lier à une bibliothèque libc décente. Ce qui, dans le cas de mingw, n'est pas celui de Windows par défaut.
Wes Hardaker

1
Cela fonctionne pour moi sur Windows XP avec cygwin gcc et Linux Ubuntu. C'est exactement ce que je voulais.
Amour et paix - Joe Codeswell

gettimeofdayest obsolète et n'est pas recommandé pour le nouveau code. Sa page de manuel POSIX recommande plutôt clock_gettime , ce qui vous permet de demander que CLOCK_MONOTONICcela ne soit pas affecté par les modifications de l'horloge système, et donc c'est mieux comme intervalle de temps. (Voir la réponse de JohnSll ). Sur les systèmes Linux modernes, par exemple, gettimeofday est essentiellement un wrapper pour clock_gettime qui convertit les nanosecondes en microsecondes.
Peter Cordes

12

La plupart des programmes simples ont un temps de calcul en millisecondes. Donc, je suppose que vous trouverez cela utile.

#include <time.h>
#include <stdio.h>

int main(){
    clock_t start = clock();
    // Execuatable code
    clock_t stop = clock();
    double elapsed = (double)(stop - start) * 1000.0 / CLOCKS_PER_SEC;
    printf("Time elapsed in ms: %f", elapsed);
}

Si vous souhaitez calculer le temps d'exécution de l'ensemble du programme et que vous êtes sur un système Unix, exécutez votre programme en utilisant la commande time comme celle-citime ./a.out


Sous Windows au moins le facteur est d'au moins 100 mais pas 1000 et ce n'est pas exact
boctulus

6
Cette réponse n'ajoute rien qui n'était pas dans la réponse d' Alexandre C de deux ans plus tôt.
Jonathan Leffler

3
@boctulus: 1s vaut toujours 1000 ms , également sur Windows.
alk

9

Beaucoup de réponses ont été suggérées clock(), puis CLOCKS_PER_SECde time.h. C'est probablement une mauvaise idée, car voici ce que /bits/time.hdit mon dossier:

/* ISO/IEC 9899:1990 7.12.1: <time.h>
The macro `CLOCKS_PER_SEC' is the number per second of the value
returned by the `clock' function. */
/* CAE XSH, Issue 4, Version 2: <time.h>
The value of CLOCKS_PER_SEC is required to be 1 million on all
XSI-conformant systems. */
#  define CLOCKS_PER_SEC  1000000l

#  if !defined __STRICT_ANSI__ && !defined __USE_XOPEN2K
/* Even though CLOCKS_PER_SEC has such a strange value CLK_TCK
presents the real value for clock ticks per second for the system.  */
#   include <bits/types.h>
extern long int __sysconf (int);
#   define CLK_TCK ((__clock_t) __sysconf (2))  /* 2 is _SC_CLK_TCK */
#  endif

Donc, CLOCKS_PER_SECpourrait être défini comme 1000000, selon les options que vous utilisez pour compiler, et cela ne semble donc pas être une bonne solution.


1
Merci pour l'information, mais existe-t-il encore une meilleure alternative?
ozanmuyes du

4
Ce n'est pas un problème pratique: oui, les systèmes Posix ont toujours CLOCK_PER_SEC==1000000, mais en même temps, ils utilisent tous une précision de 1 µs pour leur implémentation clock (); au fait, il a la belle propriété de réduire les problèmes de partage. Si vous souhaitez mesurer des événements potentiellement très rapides, disons en dessous de 1 ms, vous devez d'abord vous soucier de la précision (ou résolution) de la fonction horloge (), qui est nécessairement plus grossière que 1µs en Posix, mais est souvent aussi beaucoup plus grossière; la solution habituelle consiste à exécuter le test plusieurs fois; la question posée ne semble cependant pas l'exiger.
AntoineL

Pourquoi ne serait-ce pas une bonne solution? Vous obtenez une certaine valeur de clock(), si vous divisez cette valeur avec CLOCK_PER_SECvous, vous êtes assuré d'obtenir le temps en secondes que le processeur a pris. La responsabilité de mesurer la vitesse d'horloge réelle relève de la clock()fonction et non de la vôtre.
Zaffy

9

La réponse de Thomas Pornin sous forme de macros:

#define TICK(X) clock_t X = clock()
#define TOCK(X) printf("time %s: %g sec.\n", (#X), (double)(clock() - (X)) / CLOCKS_PER_SEC)

Utilisez-le comme ceci:

TICK(TIME_A);
functionA();
TOCK(TIME_A);

TICK(TIME_B);
functionB();
TOCK(TIME_B);

Production:

time TIME_A: 0.001652 sec.
time TIME_B: 0.004028 sec.

4

Vous devez tenir compte du fait que mesurer le temps exécution d'un programme dépend beaucoup de la charge de la machine à ce moment précis.

Sachant que, la manière d'obtenir l'heure actuelle en C peut être réalisée de différentes manières, la plus simple est:

#include <time.h>

#define CPU_TIME (getrusage(RUSAGE_SELF,&ruse), ruse.ru_utime.tv_sec + \
  ruse.ru_stime.tv_sec + 1e-6 * \
  (ruse.ru_utime.tv_usec + ruse.ru_stime.tv_usec))

int main(void) {
    time_t start, end;
    double first, second;

    // Save user and CPU start time
    time(&start);
    first = CPU_TIME;

    // Perform operations
    ...

    // Save end time
    time(&end);
    second = CPU_TIME;

    printf("cpu  : %.2f secs\n", second - first); 
    printf("user : %d secs\n", (int)(end - start));
}

J'espère que ça aide.

Cordialement!


4

(Toutes les réponses manquent ici, si votre administrateur système modifie l'heure système ou si votre fuseau horaire a des heures d'hiver et d'été différentes. Par conséquent ...)

Sur Linux: clock_gettime(CLOCK_MONOTONIC_RAW, &time_variable); Cela n'est pas affecté si l'administrateur système modifie l'heure, ou si vous vivez dans un pays avec une heure d'hiver différente de l'heure d'été, etc.

#include <stdio.h>
#include <time.h>

#include <unistd.h> /* for sleep() */

int main() {
    struct timespec begin, end;
    clock_gettime(CLOCK_MONOTONIC_RAW, &begin);

    sleep(1);      // waste some time

    clock_gettime(CLOCK_MONOTONIC_RAW, &end);

    printf ("Total time = %f seconds\n",
            (end.tv_nsec - begin.tv_nsec) / 1000000000.0 +
            (end.tv_sec  - begin.tv_sec));

}

man clock_gettime États:

CLOCK_MONOTONIC
              Clock  that  cannot  be set and represents monotonic time since some unspecified starting point.  This clock is not affected by discontinuous jumps in the system time
              (e.g., if the system administrator manually changes the clock), but is affected by the incremental adjustments performed by adjtime(3) and NTP.

Pouvez-vous expliquer le calcul que vous avez utilisé pour obtenir le nombre de secondes? Ce qui se passe n'est pas évident.
Colin Keenan

1
Cela ne (end.tv_nsec - begin.tv_nsec) / 1000000000.0résulterait -il pas 0toujours?
alk

@alk: non, la division par un doublelittéral déclenche int ou longen doubleconversion avant la division. Bien sûr, vous pouvez simplement vous en tenir à un entier et imprimer la tv_secpartie puis la partie fractionnaire avec zéro comme %ld.%09ld, mais la conversion en double est facile et 53 bits de précision sont généralement suffisants pour les temps de référence.
Peter Cordes

1
(Oups, la soustraction de la partie en nanosecondes peut devoir être appliquée à la partie des secondes, donc utiliser le double et le laisser négatif évite ce problème. Pour utiliser une chaîne de format entier pur, vous auriez besoin d'un timespec_subtractcomme celui timeval_subtractsuggéré dans le manuel de la glibc : gnu.org/software/libc/manual/html_node/Elapsed-Time.html )
Peter Cordes

3

ANSI C spécifie uniquement les secondes fonctions temporelles de précision. Cependant, si vous exécutez dans un environnement POSIX, vous pouvez utiliser gettimeofday () qui fournit une résolution en microsecondes du temps écoulé depuis l'époque UNIX.

En guise de remarque, je ne recommanderais pas d'utiliser clock () car il est mal implémenté sur de nombreux systèmes (sinon tous?) Et n'est pas précis, outre le fait qu'il se réfère uniquement au temps que votre programme a passé sur le CPU et pas la durée de vie totale du programme, ce qui, selon votre question, est ce que je suppose que vous aimeriez mesurer.


La norme ISO C (en supposant que c'est ce que signifie ANSI C ) ne spécifie pas exprès la précision des fonctions temporelles . Puis spécifiquement sur une implémentation POSIX, ou sur Windows, la précision des fonctions d' horloge murale (voir la réponse de Thomas) est en secondes. Mais la précision de clock () est généralement plus grande, et toujours 1µs en Posix (indépendamment de la précision.)
AntoineL

2

Toutes les solutions ne fonctionnent pas dans mon système.

Je peux utiliser

#include <time.h>

double difftime(time_t time1, time_t time0);

2
Cela donne la différence entre deux time_tvaleurs sous forme de double. Étant donné que les time_tvaleurs ne sont précises qu'à une seconde, elles ont une valeur limitée pour imprimer le temps pris par les programmes à exécution courte, bien qu'elles puissent être utiles pour les programmes qui s'exécutent sur de longues périodes.
Jonathan Leffler

Pour une raison quelconque, le passage d'une paire de clock_ts à difftimesemble fonctionner pour moi avec la précision d'un centième de seconde. C'est sur Linux x86. Je ne peux pas non plus obtenir la soustraction de stopet starttravailler.
ragerdl

@ragerdl: Vous devez passer à difftime() clock() / CLOCKS_PER_SEC, car il attend des secondes.
alk

2
    #include<time.h>
    #include<stdio.h>
    int main(){
clock_t begin=clock();

    int i;
for(i=0;i<100000;i++){
printf("%d",i);

}
clock_t end=clock();
printf("Time taken:%lf",(double)(end-begin)/CLOCKS_PER_SEC);
}

Ce programme fonctionnera comme un charme.


2

J'ai trouvé que l'horloge habituelle (), tout le monde le recommande ici, pour une raison quelconque, s'écarte énormément d'une exécution à l'autre, même pour du code statique sans aucun effet secondaire, comme dessiner à l'écran ou lire des fichiers. Cela pourrait être dû au fait que le processeur change les modes de consommation d'énergie, que le système d'exploitation donne différentes priorités, etc.

Ainsi, le seul moyen d'obtenir de manière fiable le même résultat à chaque fois avec clock () est d'exécuter le code mesuré en boucle plusieurs fois (pendant plusieurs minutes), en prenant des précautions pour empêcher le compilateur de l'optimiser: les compilateurs modernes peuvent précalculer le code sans effets secondaires en cours d'exécution dans une boucle, et déplacez-le hors de la boucle., comme c'est-à-dire en utilisant une entrée aléatoire pour chaque itération.

Une fois que suffisamment d'échantillons ont été collectés dans un tableau, on trie ce tableau et prend l'élément central, appelé médiane. La médiane est meilleure que la moyenne, car elle élimine les écarts extrêmes, comme par exemple l'antivirus occupant tout le processeur ou le système d'exploitation faisant une mise à jour.

Voici un utilitaire simple pour mesurer les performances d'exécution du code C / C ++, en faisant la moyenne des valeurs proches de la médiane: https://github.com/saniv/gauge

Je suis moi-même toujours à la recherche d'un moyen plus robuste et plus rapide de mesurer le code. On pourrait probablement essayer d'exécuter le code dans des conditions contrôlées sur du métal nu sans aucun système d'exploitation, mais cela donnera un résultat irréaliste, car en réalité, le système d'exploitation s'implique.

x86 a ces compteurs de performances matérielles, qui incluent le nombre réel d'instructions exécutées, mais ils sont difficiles à accéder sans l'aide du système d'exploitation, difficiles à interpréter et ont leurs propres problèmes ( http://archive.gamedev.net/archive/reference/articles /article213.html ). Ils pourraient tout de même être utiles pour enquêter sur la nature du col de la bouteille (accès aux données ou calculs réels sur ces données).


Oui, les processeurs x86 modernes tournent au ralenti beaucoup plus lentement que le turbo max. En fonction des paramètres du "gouverneur", la montée en fréquence jusqu'à la vitesse d'horloge maximale peut prendre une milliseconde (Skylake avec la gestion matérielle de l'état P, en particulier avec energy_performance_preference réglé sur performance) ou plusieurs dizaines de millisecondes. en.wikipedia.org/wiki/Dynamic_frequency_scaling . Et oui, la performance médiane est généralement un bon choix; le haut de gamme a généralement des pointes d'interférence.
Peter Cordes

Souvent, votre meilleur pari pour éviter que le travail ne soit optimisé est une entrée de ligne de commande et retourne le résultat. Ou écrivez une fonction dans un fichier séparé mainqui prend un argument et renvoie un résultat, et n'utilisez pas l'optimisation de la liaison. Ensuite, le compilateur ne peut pas l'intégrer dans l'appelant. Ne fonctionne que si la fonction inclut déjà une sorte de boucle, sinon la surcharge appel / ret est trop élevée.
Peter Cordes

Le compilateur peut toujours optimiser l'entrée de ligne de commande unique hors de la boucle, si vous la traitez avec du code statique sans aucun effet secondaire. Il est donc préférable de générer une entrée aléatoire pour chaque itération. Évidemment, rand () devrait être appelé en dehors du code mesuré, avant la première horloge (), car rand () pourrait également entraîner un appel système, en échantillonnant un générateur d'entropie matériel (qui sur les anciens systèmes était un mouvement de souris). N'oubliez pas d'imprimer chaque bit de la sortie, sinon le compilateur peut décider que vous n'avez pas besoin de toute la sortie en totalité ou en partie. Cela peut être fait avec disons CRC32.
SmugLispWeenie

Si votre code en cours de test est dans un fichier séparé et que vous n'utilisez pas l'optimisation de la liaison, il n'y a aucun moyen que le compilateur puisse effectuer le CSE pour optimiser entre les appels. L'appelant ne peut rien supposer que l'appelé n'ait aucun effet secondaire visible. Cela vous permet de mettre quelque chose de relativement court dans une boucle de répétition pour le rendre suffisamment long, avec juste un overhead call / ret. Si vous le laissez en ligne, vous devez vérifier l'asm généré pour vous assurer qu'il n'a pas sorti un calcul d'une boucle comme vous le dites.
Peter Cordes

La méthode spécifique au compilateur consiste à utiliser (par exemple) GNU C inline asm pour forcer un compilateur à matérialiser un résultat dans un registre, et / ou à oublier ce qu'il sait de la valeur d'une variable, sans introduire réellement d'instructions supplémentaires. L'équivalent "Escape" et "Clobber" dans MSVC renvoie à une vidéo sur le profilage et le micro-benchmarking (discours CppCon 2015 du développeur de clang Chandler Carruth) Il n'y a pas d'équivalent MSVC, mais la question elle-même montre les fonctions GNU C et comment les utiliser.
Peter Cordes

0

Certains pourraient trouver un autre type d'entrée utile: on m'a donné cette méthode de mesure du temps dans le cadre d'un cours universitaire sur la programmation GPGPU avec NVidia CUDA ( description du cours ). Il combine des méthodes vues dans des articles précédents, et je le poste simplement parce que les exigences lui donnent de la crédibilité:

unsigned long int elapsed;
struct timeval t_start, t_end, t_diff;
gettimeofday(&t_start, NULL);

// perform computations ...

gettimeofday(&t_end, NULL);
timeval_subtract(&t_diff, &t_end, &t_start);
elapsed = (t_diff.tv_sec*1e6 + t_diff.tv_usec);
printf("GPU version runs in: %lu microsecs\n", elapsed);

Je suppose que vous pourriez multiplier par exemple 1.0 / 1000.0pour obtenir l'unité de mesure qui convient à vos besoins.


1
gettimeofday est obsolète et déconseillé. Sa page de manuel POSIX recommande à la clock_gettimeplace, ce qui vous permet de demander que CLOCK_MONOTONICcela ne soit pas affecté par les modifications de l'horloge système, et donc c'est mieux comme minuterie d'intervalle. Sur les systèmes Linux modernes, par exemple, gettimeofdayest essentiellement un wrapper pour clock_gettimeconvertir les nanosecondes en microsecondes. (Voir la réponse de JohnSll).
Peter Cordes

Cette méthode a été ajoutée par @Wes Hardaker, la principale différence est l'utilisation timeval_subtract.
ワ イ き ん ぐ

Ok, donc la seule partie utile de votre réponse est le nom d'une fonction que vous ne définissez pas et qui n'est pas dans la bibliothèque standard. (Uniquement dans le manuel de la glibc: gnu.org/software/libc/manual/html_node/Elapsed-Time.html ).
Peter Cordes

-2

Comparaison du temps d'exécution du tri à bulles et du tri par sélection J'ai un programme qui compare le temps d'exécution du tri à bulles et du tri par sélection. Pour connaître l'heure d'exécution d'un bloc de code, calculer l'heure avant et après le bloc en

 clock_t start=clock();
 
 clock_t end=clock();
 CLOCKS_PER_SEC is constant in time.h library

Exemple de code:

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
int main()
{
   int a[10000],i,j,min,temp;
   for(i=0;i<10000;i++)
   {
      a[i]=rand()%10000;
   }
   //The bubble Sort
   clock_t start,end;
   start=clock();
   for(i=0;i<10000;i++)
   {
     for(j=i+1;j<10000;j++)
     {
       if(a[i]>a[j])
       {
         int temp=a[i];
         a[i]=a[j];
         a[j]=temp;
       }
     }
   }
   end=clock();
   double extime=(double) (end-start)/CLOCKS_PER_SEC;
   printf("\n\tExecution time for the bubble sort is %f seconds\n ",extime);

   for(i=0;i<10000;i++)
   {
     a[i]=rand()%10000;
   }
   clock_t start1,end1;
   start1=clock();
   // The Selection Sort
   for(i=0;i<10000;i++)
   {
     min=i;
     for(j=i+1;j<10000;j++)
     {
       if(a[min]>a[j])
       {
         min=j;
       }
     }
     temp=a[min];
     a[min]=a[i];
     a[i]=temp;
   }
   end1=clock();
   double extime1=(double) (end1-start1)/CLOCKS_PER_SEC;
   printf("\n");
   printf("\tExecution time for the selection sort is %f seconds\n\n", extime1);
   if(extime1<extime)
     printf("\tSelection sort is faster than Bubble sort by %f seconds\n\n", extime - extime1);
   else if(extime1>extime)
     printf("\tBubble sort is faster than Selection sort by %f seconds\n\n", extime1 - extime);
   else
     printf("\tBoth algorithms have the same execution time\n\n");
}

4
Cela n'ajoute vraiment quelque chose de nouveau par rapport à adimoh « s réponse , sauf qu'elle remplit « le code exécutable » bloc (ou deux d'entre eux) avec un code réel. Et cette réponse n'ajoute rien qui n'était pas dans la réponse d' Alexandre C de deux ans plus tôt.
Jonathan Leffler
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.