A Fortran oferece várias maneiras de implementar um cronômetro para medir o tempo de execução. A melhor abordagem depende de suas necessidades de precisão e portabilidade. Aqui estão três métodos comuns:
1. Usando a função intrínseca `cpu_time` (mais simples, mas menos precisa): Este é o método mais fácil, construído diretamente em Fortran. `Cpu_time` retorna o tempo do processador usado pelo programa desde o seu início em segundos. Geralmente, é menos preciso do que outros métodos, principalmente em sistemas multi-core, onde pode não refletir o tempo verdadeiro de encrotamento da parede.
`` `fortran
Programa timing_example
implícito nenhum
Real ::start_time, end_time, suspenso_time
Ligue para CPU_TIME (start_time)
! Seu código a ser cronometrado vai aqui
! ... cálculos longos ...
Ligue para CPU_TIME (END_TIME)
suspensa_time =end_time - start_time
Print *, "Tempo decorrido da CPU:", Dasaped_time, "segundos"
final do programa Timing_Example
`` `
2. Usando a sub-rotina intrínseca `System_clock` (mais precisa, dependente da plataforma): `System_clock` fornece mais controle e precisão potencialmente mais alta. Permite especificar as unidades do tempo retornado (por exemplo, segundos, milissegundos, microssegundos). No entanto, as unidades disponíveis e a precisão são dependentes do sistema.
`` `fortran
Programa timing_example_system_clock
implícito nenhum
Inteiro, parâmetro ::count_rate =1000! Taxa de contagem em milissegundos
Inteiro ::start_count, end_count, elepsed_count
real ::suspensa_time
Call System_clock (start_count, count_rate)
! Seu código a ser cronometrado vai aqui
! ... cálculos longos ...
Call System_clock (end_count, count_rate)
Dasped_Count =end_count - start_count
suspensa_time =real (suspensa_count) / real (count_rate)
Imprima *, "Tempo decorrido:", DasaD_Time, "segundos"
Timing do programa final_example_system_clock
`` `
3. Usando bibliotecas específicas da plataforma (o mais preciso, menos portátil): Para as medições de tempo de maior precisão e mais precisas, pode ser necessário interagir com as bibliotecas específicas do sistema operacional. Essa abordagem é menos portátil porque o código precisará de ajustes para diferentes sistemas (Linux, Windows, MacOS).
*
Linux (usando `gettimeOfday`): Você precisaria declarar uma interface para a função `gettimeofday`" do arquivo de cabeçalho `
`. Isso envolve o uso do módulo `iso_c_binding` e manuseio cuidadoso de tipos. Exemplo (requer tratamento de erros para o código de produção):
`` `fortran
Programa timing_example_gettimeofday
Use ISO_C_Binding
implícito nenhum
inclua 'time.h' // ou use uma alternativa adequada para o seu compilador. Alguns compiladores não precisam de incluir explícitos.
TIPO (C_PTR) ::TV
Inteiro (c_int) ::rc
Double Precision ::start_time, end_time, elepsed_time
alocar (TV)
rc =c_getTimeOfday (tv, c_null_ptr)! Obtenha o horário de início
start_time =c_f_double (c_loc (tv)%tempo) + c_f_double (c_loc (tv)%tv_sec)
! Seu código a ser cronometrado vai aqui
! ... cálculos longos ...
rc =c_getTimeOfday (tv, c_null_ptr)! Obtenha o horário de término
end_time =c_f_double (c_loc (tv)%tempo) + c_f_double (c_loc (tv)%tv_sec)
Dealpor (TV)
suspensa_time =end_time - start_time
Imprima *, "Tempo decorrido:", DasaD_Time, "segundos"
final do programa Timing_Example_getTimeOfday
`` `
Lembre-se de compilar com os sinalizadores apropriados para vincular as bibliotecas necessárias (por exemplo, `-lrt` para` getTimeOfday` no Linux). O comando de compilação exato depende do seu compilador (Gfortran, ifort, etc.).
Escolha o método que melhor atenda às suas necessidades. Para um momento simples, `cpu_time` é suficiente. Para melhor precisão, use `System_clock`. Para a maior precisão e o tempo de parede mais preciso, considere o uso de bibliotecas específicas da plataforma, mas esteja atento às implicações de portabilidade. Esteja sempre ciente de que a resolução do timer varia bastante entre os sistemas. Portanto, você não deve esperar precisão de microssegundos em todas as plataformas e configurações.
