Como posso encontrar o tempo de execução de uma seção do meu programa em C?

Question

Eu estou tentando encontrar uma maneira de obter o tempo de execução de uma seção do código em C. Eu já tentei tanto tempo () e relógio () de time.h, mas parece que o tempo () retorna segundos e relógio () parece-me dar milissegundos (ou centiseconds?) Eu gostaria de algo que mais precisa. Existe uma maneira que eu possa agarrar o tempo com pelo menos precisão microssegundo?

Isso só precisa ser capaz de compilar em Linux.

Answer 1

Você referido clock() e time() - você estava procurando gettimeofday()? Isso vai preencher um struct timeval, que contém segundos e microssegundos.

É claro que a resolução real é até o hardware.

Answer 2

Por que vale a pena, aqui está um que é apenas alguns macros:

#include <time.h>
clock_t startm, stopm;
#define START if ( (startm = clock()) == -1) {printf("Error calling clock");exit(1);}
#define STOP if ( (stopm = clock()) == -1) {printf("Error calling clock");exit(1);}
#define PRINTTIME printf( "%6.3f seconds used by the processor.", ((double)stopm-startm)/CLOCKS_PER_SEC);

Em seguida, basta usá-lo com:

main() {
  START;
  // Do stuff you want to time
  STOP;
  PRINTTIME;
}

A partir http://ctips.pbwiki.com/Timer

Answer 3

Você quer um href="http://en.wikipedia.org/wiki/Profiler_(computer_science)" rel="noreferrer"> aplicação .

Pesquisar palavras-chave no SO e os motores de busca: linux profiling

Answer 4

Tenha um olhar em gettimeofday , clock_ * , ou get / setitimer .

Answer 5

Tente "bench.h" ; ele permite que você coloque um start_timer; e STOP_TIMER ( "nome"); em seu código, permitindo-lhe referência arbitrariamente qualquer seção de código (nota: apenas recomendado para seções curtas e não as coisas que tomam dezenas de milissegundos ou mais). Sua precisas para o ciclo de clock, embora em alguns casos raros, pode mudar a forma como o código no meio é compilado, caso em que você é melhor fora com um profiler (embora profilers são geralmente mais esforço para uso para seções específicas do código).

Ele só funciona em x86.

Answer 6

Você pode querer google para um instrumentação ferramenta.

Answer 7

Você não vai encontrar uma chamada de biblioteca que lhe permite obter passado a resolução do relógio da sua plataforma. Ou usar um profiler (homem gprof) como outro cartaz sugerido, ou - rápida e suja - colocar um laço em torno da seção de ofender de código para executá-lo muitas vezes, e utilização do relógio ().

Answer 8

gettimeofday() fornece-lhe com uma resolução de microssegundos, enquanto clock_gettime() fornece-lhe com uma resolução de nanossegundos.

int clock_gettime(clockid_t clk_id, struct timespec *tp);

O clk_id identifica o relógio para ser usado. Use CLOCK_REALTIME se você quiser um relógio de todo o sistema visível para todos os processos. Use CLOCK_PROCESS_CPUTIME_ID para temporizador por processo e CLOCK_THREAD_CPUTIME_ID para um temporizador específico da thread.

Answer 9

Depende das condições .. Profilers são agradáveis ??para vistas gerais globais no entanto, se você realmente precisa de uma visão precisa minha recomendação é KISS. Basta executar o código em um loop de tal forma que leva um minuto ou mais para ser concluído. Em seguida, calcular uma média simples com base no tempo total de funcionamento e iterações executada.

Esta abordagem permite que você:

1. Obter resultados precisos com temporizadores de baixa resolução.

2. Não correr em questões onde interfere instrumentação com caches de Alta Velocidade (L2, L1, branch..etc) perto do processador. No entanto executar o mesmo código em um loop também pode fornecer resultados otimistas que podem não refletir as condições do mundo real.

Answer 10

Não sei qual ambiente / OS que está a trabalhar, mas o seu tempo pode ser impreciso se outro segmento, uma tarefa ou processo preempts seu código cronometrada no meio. Sugiro mecanismos que exploram tais como semáforos ou semáforos para evitar outros segmentos de preemting seu processo.

Answer 11

Se você estiver desenvolvendo em x86 ou x64 porque não usar o carimbo de tempo Contador: RDTSC .

Será mais confiável, então funções ANSI C como o tempo () ou relógio () como RDTSC é uma função atômica. Usando funções C para este fim pode apresentar problemas como você não tem garantia de que o fio que estão executando em não vai ser comutada para fora e como resultado o valor que eles retornam não vai ser uma descrição precisa do tempo de execução real que você está tentando medir .

Com RDTSC você pode medir melhor isso. Você vai precisar para converter o carrapato contagem de volta para um tempo legível H humana: M:. Formato de S, que dependerá da frequência de processadores relógio mas o Google ao redor e eu tenho certeza que você vai encontrar exemplos

No entanto, mesmo com RDTSC você será incluindo o tempo seu código foi comutada de execução, enquanto uma solução melhor do que usar o tempo () / relógio () se precisar de uma medida exata você terá que recorrer a um profiler que a vontade instrumento de seu código e ter em conta quando o seu código não é realmente executar devido a trocas de contexto ou o que quer.