|
Fortran propose plusieurs façons d'implémenter un minuteur pour mesurer le temps d'exécution. La meilleure approche dépend de vos besoins de précision et de portabilité. Voici trois méthodes courantes :
1. Utilisation de la fonction intrinsèque `CPU_TIME` (la plus simple, mais moins précise) :
Il s'agit de la méthode la plus simple, intégrée directement dans Fortran. `CPU_TIME` renvoie le temps processeur utilisé par le programme depuis son démarrage en secondes. Elle est généralement moins précise que les autres méthodes, en particulier sur les systèmes multicœurs où elle peut ne pas refléter l'heure réelle de l'horloge murale.
```fortran
exemple de timing de programme
implicite aucun
réel : start_time, end_time, elapsed_time
appeler cpu_time (start_time)
! Votre code à chronométrer va ici
! ... de longs calculs ...
appeler cpu_time (end_time)
temps_écoulé =end_time - start_time
print *, "Temps CPU écoulé :", elapsed_time, " secondes"
exemple de timing de fin de programme
```
2. Utilisation du sous-programme intrinsèque `SYSTEM_CLOCK` (plus précis, dépendant de la plateforme) :
`SYSTEM_CLOCK` offre plus de contrôle et potentiellement une plus grande précision. Il vous permet de spécifier les unités du temps renvoyé (par exemple, secondes, millisecondes, microsecondes). Cependant, les unités disponibles et la précision dépendent du système.
```fortran
programme timing_example_system_clock
implicite aucun
entier, paramètre ::count_rate =1000 ! Taux de comptage en millisecondes
entier : start_count, end_count, elapsed_count
réel ::temps_elapsed
appelez system_clock (start_count, count_rate)
! Votre code à chronométrer va ici
! ... de longs calculs ...
appelez system_clock (end_count, count_rate)
elapsed_count =end_count - start_count
temps_écoulé =réel (compte_écoulé) / réel (compte_taux)
print *, "Temps écoulé :", elapsed_time, " secondes"
terminer le programme timing_example_system_clock
```
3. Utilisation de bibliothèques spécifiques à la plateforme (les plus précises, les moins portables) :
Pour obtenir la plus haute précision et les mesures de temps d'horloge murale les plus précises, vous devrez peut-être vous connecter à des bibliothèques spécifiques au système d'exploitation. Cette approche est moins portable car le code nécessitera des ajustements pour différents systèmes (Linux, Windows, macOS).
* Linux (en utilisant `gettimeofday`) : Vous devrez déclarer une interface à la fonction `gettimeofday` à partir du fichier d'en-tête ``. Cela implique l'utilisation du module `ISO_C_BINDING` et une gestion minutieuse des types. Exemple (nécessite une gestion des erreurs pour le code de production) :
```fortran
programme timing_example_gettimeofday
utiliser ISO_C_BINDING
implicite aucun
include 'time.h' // Ou utilisez une alternative appropriée pour votre compilateur. Certains compilateurs ne nécessitent pas d'inclusions explicites.
tapez(c_ptr) ::télé
entier(c_int) ::rc
double précision ::start_time, end_time, elapsed_time
allouer (tv)
rc =c_gettimeofday(tv, c_null_ptr) ! Obtenir l'heure de début
start_time =c_f_double(c_loc(tv)%time) + c_f_double(c_loc(tv)%tv_sec)
! Votre code à chronométrer va ici
! ... de longs calculs ...
rc =c_gettimeofday(tv, c_null_ptr) ! Obtenir l'heure de fin
end_time =c_f_double(c_loc(tv)%time) + c_f_double(c_loc(tv)%tv_sec)
désallouer (tv)
temps_écoulé =end_time - start_time
print *, "Temps écoulé :", elapsed_time, " secondes"
terminer le programme timing_example_gettimeofday
```
N'oubliez pas de compiler avec les indicateurs appropriés pour établir un lien avec les bibliothèques nécessaires (par exemple, `-lrt` pour `gettimeofday` sous Linux). La commande de compilation exacte dépend de votre compilateur (gfortran, ifort, etc.).
Choisissez la méthode qui correspond le mieux à vos besoins. Pour un timing simple, `CPU_TIME` est suffisant. Pour une meilleure précision, utilisez `SYSTEM_CLOCK`. Pour obtenir la plus haute précision et l'heure d'horloge murale la plus précise, envisagez d'utiliser des bibliothèques spécifiques à la plate-forme, mais soyez conscient des implications en matière de portabilité. Sachez toujours que la résolution de la minuterie varie considérablement selon les systèmes. Par conséquent, vous ne devriez pas vous attendre à une précision de l’ordre de la microseconde sur toutes les plates-formes et configurations.
|
