1. Usando la función intrínseca `cpu_time` (más simple, pero menos precisa):
Este es el método más fácil, construido directamente en Fortran. `CPU_Time` Devuelve el tiempo del procesador utilizado por el programa desde su inicio en segundos. Por lo general, es menos preciso que otros métodos, particularmente en sistemas de múltiples núcleos, donde podría no reflejar el verdadero tiempo de reloj de pared.
`` `FORTRAN
programa Timing_Example
Ninguno implícito
Real ::start_time, end_time, elapsed_time
Llame a CPU_Time (Start_time)
! Su código para ser cronometrado va aquí
! ... cálculos largos ...
Llame a cpu_time (end_time)
elpsed_time =end_time - start_time
Imprimir *, "Tiempo de CPU transcurrido:", Elapsed_time, "segundos"
Finalizar el programa Timing_Example
`` `` ``
2. Uso de la subrutina intrínseca `System_Clock` (más precisa, dependiente de la plataforma):
`System_clock` proporciona más control y una precisión potencialmente más alta. Le permite especificar las unidades del tiempo devuelto (por ejemplo, segundos, milisegundos, microsegundos). Sin embargo, las unidades y la precisión disponibles dependen del sistema.
`` `FORTRAN
programa Timing_example_System_Clock
Ninguno implícito
Integer, parámetro ::count_rate =1000! Tasa de conteo en milisegundos
entero ::start_count, end_count, elapsed_count
Real ::elpsed_time
Llame a System_clock (start_count, count_rate)
! Su código para ser cronometrado va aquí
! ... cálculos largos ...
Llame a System_clock (end_count, count_rate)
elpsed_count =end_count - start_count
elpsed_time =real (elpsed_count) / real (count_rate)
Imprima *, "Tiempo elapsado:", Elapsed_time, "segundos"
Finalizar el programa Timing_example_System_Clock
`` `` ``
3. Uso de bibliotecas específicas de la plataforma (más precisas, menos portátiles):
Para las mediciones de tiempo de calcetín de pared más alta y más precisa, es posible que deba interactuar con las bibliotecas específicas del sistema operativo. Este enfoque es menos portátil porque el código necesitará ajustes para diferentes sistemas (Linux, Windows, MacOS).
* Linux (usando `getTeofday`): Debería declarar una interfaz a la función `getTeofday` del archivo de encabezado`
`` `FORTRAN
programa Timing_example_gettimeOfday
Use iso_c_binding
Ninguno implícito
Incluya 'Time.h' // o use una alternativa adecuada para su compilador. Algunos compiladores no requieren incluyen explícitos.
escriba (c_ptr) ::tv
entero (c_int) ::rc
Doble precisión ::start_time, end_time, elsapsed_time
Asignar (TV)
rc =c_gettimeOfday (TV, C_NULL_PTR)! Iniciar tiempo
start_time =c_f_double (c_loc (tv)%time) + c_f_double (c_loc (tv)%tv_sec)
! Su código para ser cronometrado va aquí
! ... cálculos largos ...
rc =c_gettimeOfday (TV, C_NULL_PTR)! Obtenga el tiempo de finalización
end_time =c_f_double (c_loc (tv)%time) + c_f_double (c_loc (tv)%tv_sec)
DealLocate (TV)
elpsed_time =end_time - start_time
Imprima *, "Tiempo elapsado:", Elapsed_time, "segundos"
Finalizar el programa Timing_example_gettimeOfday
`` `` ``
Recuerde compilar con las banderas apropiadas para vincular con las bibliotecas necesarias (por ejemplo, `-LRT` para` getTeofday` en Linux). El comando de compilación exacta depende de su compilador (GFORTRAN, IFORT, etc.).
Elija el método que mejor se adapte a sus necesidades. Para el tiempo simple, `cpu_time` es suficiente. Para una mejor precisión, use `system_clock`. Para la mayor precisión y el tiempo de reloj de pared más preciso, considere usar bibliotecas específicas de la plataforma, pero tenga en cuenta las implicaciones de la portabilidad. Siempre tenga en cuenta que la resolución del temporizador varía mucho entre los sistemas. Por lo tanto, no debe esperar una precisión de microsegundos en todas las plataformas y configuraciones.