1. Utilizzando la funzione intrinseca `cpu_time` (più semplice, ma meno precisa):
Questo è il metodo più semplice, costruito direttamente in Fortran. `Cpu_time` restituisce il tempo del processore utilizzato dal programma dal suo inizio in secondi. È generalmente meno preciso rispetto ad altri metodi, in particolare sui sistemi multi-core in cui potrebbe non riflettere il vero tempo da parete.
`` `Fortran
Programma timing_example
implicito nessuno
reale ::start_time, end_time, elased_time
Chiama cpu_time (start_time)
! Il tuo codice da essere a tempo va qui
! ... lunghi calcoli ...
Chiama cpu_time (end_time)
elased_time =end_time - start_time
Stampa *, "Tempo della CPU trascorso:", elsed_time, "secondi"
Fine Program Timing_Example
`` `
2. Utilizzando la subroutine intrinseca `System_Clock` (più precisa, dipendente dalla piattaforma):
`System_Clock` fornisce maggiore controllo e una precisione potenzialmente maggiore. Ti consente di specificare le unità del tempo restituito (ad esempio secondi, millisecondi, microsecondi). Tuttavia, le unità disponibili e la precisione sono dipendenti dal sistema.
`` `Fortran
Programma timing_example_system_clock
implicito nessuno
Integer, parametro ::count_rate =1000! Conta del tasso in millisecondi
Integer ::start_count, end_count, elapsed_count
reale ::elased_time
Call System_Clock (start_count, count_rate)
! Il tuo codice da essere a tempo va qui
! ... lunghi calcoli ...
Call System_Clock (end_count, count_rate)
elapsed_count =end_count - start_count
elapsed_time =reale (elased_count) / reale (count_rate)
Stampa *, "tempo trascorso:", elsed_time, "secondi"
Fine Program Timing_Example_System_Clock
`` `
3. Utilizzando librerie specifiche della piattaforma (più precise, meno portatili):
Per la massima precisione e le misurazioni del tempo più accurate del tempo a parete, potrebbe essere necessario interfacciarsi con le librerie operative specifiche del sistema. Questo approccio è meno portatile perché il codice avrà bisogno di regolazioni per diversi sistemi (Linux, Windows, MacOS).
* Linux (usando `getTimeofday`): Dovresti dichiarare un'interfaccia alla funzione `getTimeofday` dal file`
`` `Fortran
Programma timing_example_getTimeofday
Usa ISO_C_Binding
implicito nessuno
Includi 'time.h' // o usa un'alternativa adatta per il compilatore. Alcuni compilatori non richiedono espliciti include.
Tipo (C_PTR) ::TV
Integer (c_int) ::rc
Double Precision ::start_time, end_time, elapsed_time
Allocate (TV)
rc =c_getTimeofDay (TV, c_null_ptr)! Ottieni tempo di inizio
start_time =c_f_double (c_loc (tv)%time) + c_f_double (c_loc (TV)%TV_SEC)
! Il tuo codice da essere a tempo va qui
! ... lunghi calcoli ...
rc =c_getTimeofDay (TV, c_null_ptr)! Ottieni tempo di fine
end_time =c_f_double (c_loc (TV)%time) + c_f_double (c_loc (TV)%TV_SEC)
DealLocate (TV)
elased_time =end_time - start_time
Stampa *, "tempo trascorso:", elsed_time, "secondi"
Fine Program Timing_Example_GetTimeofDay
`` `
Ricorda di compilare con flag appropriati per collegarsi contro le librerie necessarie (ad esempio, `-lrt` per` getTimeofday` su Linux). Il comando di compilazione esatta dipende dal compilatore (Gfortran, iFort, ecc.).
Scegli il metodo che si adatta meglio alle tue esigenze. Per una semplice tempistica, `cpu_time` è sufficiente. Per una migliore precisione, utilizzare `System_Clock`. Per la massima precisione e il tempo più accurato, considera l'utilizzo di librerie specifiche della piattaforma ma sii consapevole delle implicazioni di portabilità. Sii sempre consapevole che la risoluzione del timer varia notevolmente tra i sistemi. Pertanto, non dovresti aspettarti una precisione di microsecondi su tutte le piattaforme e le configurazioni.
Informazioni correlate
software © www.354353.com