Microssegundos C ++

Para obter um tempo de execução preciso em um programa C ++, a linguagem de programação C ++ fornece várias opções. Você pode escrever seu código personalizado para obter o tempo de execução preciso ou pode usar a função interna salvando seu tempo e energia. A função interna fornecida pela linguagem de programação C ++ ajuda o desenvolvedor a implementar processos complexos com apenas uma única função. Neste artigo, aprenderemos a obter o tempo de execução preciso e preciso em microssegundos usando as funções internas C ++. Existem diferentes maneiras de encontrar o tempo de execução em microssegundos.

Cálculo do tempo de execução do programa C ++ em microssegundos

Infelizmente, não há métodos para descobrir o tempo preciso de execução que funciona para todos. Para isso, você precisa escolher a solução de acordo com a situação. Medir o tempo de execução preciso de um programa C ++ pode ser difícil em algumas situações devido a problemas de portabilidade. Selecionar os métodos certos que se encaixam no seu sistema operacional e na versão do compilador é essencial para obter um tempo preciso. Mais importante, você precisa entender o que exatamente você quer dizer com 'tempo' para poder escolher o método de acordo.

Aqui, você encontrará uma lista abrangente de algumas opções fáceis, simples e melhores disponíveis para encontrar o tempo de execução de um programa C ++. Também listaremos as limitações das funções para lhe dar um heads-up antes de começar a usar essa função em seu programa.

Felizmente, você terá a melhor opção perfeitamente adequada para o seu sistema operacional e versão do compilador.

Exemplo 1:

Vamos examinar o tempo da parede com a função. A função é uma das maneiras mais portáteis de encontrar o tempo de parede em um programa C ++. Funciona apenas com as versões C ++ 11 e posteriores. Se você tiver uma versão mais antiga, atualize seu compilador antes de usar esta função. Tem acesso a vários tipos de relógios na máquina com características e propósitos diferentes.

Aqui, estamos usando o high_resolution_clock para encontrar o tempo de parede, pois ele usa o relógio de maior resolução disponível, o que provavelmente é adequado para a maioria dos sistemas. Consulte o código fornecido abaixo:

#incluir
#incluir
int main ()
duplo s = 0, a = 1;
Auto start = std :: crono :: high_resolution_clock :: agora ();
int it = 1000*1000*1000;
para (int i = 0; is += a;
a /= 2.0;

Auto final = std :: crono :: high_resolution_clock :: agora ();
Auto decorrido = std :: crono :: duration_cast (end - start);
printf ("O relógio começa em = %.2f \ n ", s);
printf ("O tempo medido é = %.3f segundos.\ n ", decorrido.count () * 1e-6);
retornar 0;

O programa começa com dois arquivos de cabeçalho Stdio.H e Chrono. O stdio.A biblioteca H é usada em conjunto com os métodos de entrada e saída padrão. A biblioteca Chrono permite que você use a função em seu programa. Todo o programa está escrito na função principal, onde toda a execução acontece.

O programa principal começa com a inicialização de duas variáveis ​​'s' e 'a' que serão usadas para acompanhar o tempo. A variável 'start' é inicializada com a hora atual com 'Chrono :: high_reolution_clock :: agora ()' função.

A variável 'it = 1000*1000*1000' é inicializada com o número de iterações que precisam ser executadas e calcula o tempo decorrido em microssegundos. A ação a seguir será realizada pelo loop "for", pois itera de 0 a 1000*1000*1000 vezes.

Outra variável 'end' é inicializada com o horário atual para verificar o tempo decorrido. Ao calcular 'fim - iniciar', você terá o tempo decorrido de execução. O 'Chrono :: Microssegunds' fornecerá o tempo de execução em microssegundos que serão convertidos em segundos com 'decorrido.cálculo count ()*1e-6 '. As instruções PRIMF () imprimirão a hora de início e o tempo decorrido. E, finalmente, a declaração de retorno 0 garante que o programa seja executado com sucesso.

Quando você executa o código completo, uma saída semelhante será produzida, dependendo da velocidade de execução e da eficiência do seu sistema:

Exemplo 2:

No código fornecido abaixo, estamos usando a função gettimeofday () para encontrar o tempo decorrido, já que o tempo da época é '1º, janeiro de 1970, 00:00:00 UTC'. A função gettimeofday () retorna o tempo em microssegundos e segundos. Portanto, para encontrar o tempo preciso em microssegundos, ambas as vezes precisam ser resumidas juntas. Abaixo, o código anexado o ajudará a calcular o tempo de execução em microssegundos usando

#incluir
#incluir
int main ()
duplo s = 0, a = 1;
struct timeval Start, fim;
gettimeOfday (& start, 0);
int it = 1000*1000*1000;
para (int i = 0; is += a;
a /= 2.0;

gettimeOfday (& end, 0);
longa seg = fim.TV_SEC - Iniciar.tv_sec;
Micro longo = fim.TV_USEC - Iniciar.TV_USEC;
duplo decorrido = seg + micro*1e-6;
printf ("O relógio começa em = %.20f \ n ", s);
printf ("O tempo medido é = %.3f segundos.\ n ", decorrido);
retornar 0;

A função gettimeofday () está incluída no arquivo de cabeçalho.

O 'struct timeval' é uma estrutura de tempo usada para representar o tempo decorrido.

O tempo calculado em segundos e microssegundos é adicionado para obter o tempo de execução exato em microssegundos. A função 'tv_sec' fornece o tempo em segundos e 'tv_usec' fornece o tempo em microssegundos. Para converter os segundos em microssegundos, multiplique os microssegundos por 1e-6. Depois disso, adicione as duas vezes em segundos e microssegundos para obter o tempo de execução preciso em microssegundos.

Agora, clique no ícone de compilação e execute na barra de ícones do software Dev C ++. Pressione a tecla F11 no teclado para executar o programa. A saída executada é dada abaixo:

Exemplo 3:

Neste exemplo, estamos usando a biblioteca e sua função de tempo (). A função Time () funciona de maneira semelhante à função gettimeofday () que fornece o tempo decorrido desde o horário da época. No entanto, ele mede apenas segundos completos e você não pode definir o fuso horário. Portanto, se os intervalos medidos forem mais de um segundo, então o tempo () função faz sentido. Esta pode não ser a primeira preferência para obter os microssegundos e você pode usar outras funções. Veja o código abaixo:

#incluir
#incluir
int main ()
duplo s = 0, a = 1;
time_t iniciar, fim;
tempo (& start);
int it = 1000*1000*1000;
para (int i = 0; is += a;
a /= 2.0;

tempo (e final);
time_t decorrido = end - start;
printf ("Resultado: %.20f \ n ", s);
printf ("tempo medido: %ld segundos.\ n ", decorrido);
retornar 0;

A função Time () fornecerá o horário de início e término da execução e o tempo decorrido pode ser facilmente calculado com uma instrução 'final - start'. Veja o resultado abaixo:

Observe que o tempo decorrido calculado com a função de tempo () é 6s, não os 6 exatos.833 microssegundos. A diferença no resultado da função do tempo () é vista na saída.

Conclusão

Vários métodos calculam o tempo de execução do sistema usando um programa C ++. No entanto, nenhuma solução é perfeita para cada situação e cada função tem um desempenho diferente em diferentes situações. Aqui aprendemos a usar o tempo (), gettimeofday () e funções para obter o tempo de execução em microssegundos.