Tempo de execução do programa C

Eu tenho um programa C que visa ser executado em paralelo em vários processadores. Preciso gravar o tempo de execução (que pode variar de 1 segundo a vários minutos). Procurei respostas, mas todas parecem sugerir o uso da clock()função, que envolve o cálculo do número de relógios que o programa levou dividido pelo Clocks_per_secondvalor.

Não tenho certeza de como o Clocks_per_secondvalor é calculado?

Em Java, apenas dedico o tempo atual em milissegundos antes e após a execução.

Existe algo semelhante em C? Eu dei uma olhada, mas não consigo encontrar uma maneira de obter algo melhor do que uma segunda resolução.

Também sei que um criador de perfil seria uma opção, mas estou procurando implementar um cronômetro.

obrigado

CLOCKS_PER_SECé uma constante que é declarada em <time.h>. Para obter o tempo de CPU usado por uma tarefa em um aplicativo C, use:

clock_t begin = clock();

/* here, do your time-consuming job */

clock_t end = clock();
double time_spent = (double)(end - begin) / CLOCKS_PER_SEC;

Observe que isso retorna a hora como um tipo de ponto flutuante. Isso pode ser mais preciso do que um segundo (por exemplo, você mede 4,52 segundos). A precisão depende da arquitetura; em sistemas modernos, você obtém facilmente 10ms ou menos, mas em máquinas Windows mais antigas (da era Win98), era mais próximo de 60ms.

clock()é padrão C; funciona "em qualquer lugar". Existem funções específicas do sistema, como getrusage()em sistemas similares ao Unix.

Java System.currentTimeMillis()não mede a mesma coisa. É um "relógio de parede": pode ajudá-lo a medir quanto tempo levou para a execução do programa, mas não informa quanto tempo de CPU foi usado. Em sistemas multitarefa (ou seja, todos eles), estes podem ser amplamente diferentes.

Se você estiver usando o shell Unix para execução, poderá usar o comando time.

fazendo

$ time ./a.out

assumindo a.out como o executável lhe dará o tempo necessário para executar este

Em baunilha C simples:

#include <time.h>
#include <stdio.h>

int main()
{
    clock_t tic = clock();

    my_expensive_function_which_can_spawn_threads();

    clock_t toc = clock();

    printf("Elapsed: %f seconds\n", (double)(toc - tic) / CLOCKS_PER_SEC);

    return 0;
}

Você deseja funcionalmente isso:

#include <sys/time.h>

struct timeval  tv1, tv2;
gettimeofday(&tv1, NULL);
/* stuff to do! */
gettimeofday(&tv2, NULL);

printf ("Total time = %f seconds\n",
         (double) (tv2.tv_usec - tv1.tv_usec) / 1000000 +
         (double) (tv2.tv_sec - tv1.tv_sec));

Observe que isso mede em microssegundos, não apenas em segundos.

A maioria dos programas simples possui tempo de computação em milissegundos. Então, suponho, você achará isso útil.

#include <time.h>
#include <stdio.h>

int main(){
    clock_t start = clock();
    // Execuatable code
    clock_t stop = clock();
    double elapsed = (double)(stop - start) * 1000.0 / CLOCKS_PER_SEC;
    printf("Time elapsed in ms: %f", elapsed);
}

Se você deseja calcular o tempo de execução de todo o programa e você estiver em um sistema Unix, execute o programa usando o comando time como estetime ./a.out

Muitas respostas foram sugeridas clock()e depois a CLOCKS_PER_SECpartir de time.h. Provavelmente, essa é uma péssima idéia, porque é isso que meu /bits/time.harquivo diz:

/* ISO/IEC 9899:1990 7.12.1: <time.h>
The macro `CLOCKS_PER_SEC' is the number per second of the value
returned by the `clock' function. */
/* CAE XSH, Issue 4, Version 2: <time.h>
The value of CLOCKS_PER_SEC is required to be 1 million on all
XSI-conformant systems. */
#  define CLOCKS_PER_SEC  1000000l

#  if !defined __STRICT_ANSI__ && !defined __USE_XOPEN2K
/* Even though CLOCKS_PER_SEC has such a strange value CLK_TCK
presents the real value for clock ticks per second for the system.  */
#   include <bits/types.h>
extern long int __sysconf (int);
#   define CLK_TCK ((__clock_t) __sysconf (2))  /* 2 is _SC_CLK_TCK */
#  endif

Portanto, CLOCKS_PER_SECpode ser definido como 1000000, dependendo de quais opções você usa para compilar e, portanto, não parece ser uma boa solução.

A resposta de Thomas Pornin como macros:

#define TICK(X) clock_t X = clock()
#define TOCK(X) printf("time %s: %g sec.\n", (#X), (double)(clock() - (X)) / CLOCKS_PER_SEC)

Use-o assim:

TICK(TIME_A);
functionA();
TOCK(TIME_A);

TICK(TIME_B);
functionB();
TOCK(TIME_B);

Resultado:

time TIME_A: 0.001652 sec.
time TIME_B: 0.004028 sec.

Você deve levar em consideração que medir o tempo que levou a execução de um programa depende muito da carga que a máquina possui naquele momento específico.

Sabendo que, a maneira de obter o tempo atual em C pode ser alcançada de diferentes maneiras, é mais fácil:

#include <time.h>

#define CPU_TIME (getrusage(RUSAGE_SELF,&ruse), ruse.ru_utime.tv_sec + \
  ruse.ru_stime.tv_sec + 1e-6 * \
  (ruse.ru_utime.tv_usec + ruse.ru_stime.tv_usec))

int main(void) {
    time_t start, end;
    double first, second;

    // Save user and CPU start time
    time(&start);
    first = CPU_TIME;

    // Perform operations
    ...

    // Save end time
    time(&end);
    second = CPU_TIME;

    printf("cpu  : %.2f secs\n", second - first); 
    printf("user : %d secs\n", (int)(end - start));
}

Espero que ajude.

Saudações!

(Todas as respostas aqui estão ausentes, se o administrador do sistema alterar a hora do sistema ou se o fuso horário tiver horários diferentes de inverno e de verão. Portanto ...)

No uso do linux: clock_gettime(CLOCK_MONOTONIC_RAW, &time_variable); não será afetado se o administrador do sistema alterar a hora ou se você mora em um país com horário de inverno diferente do horário de verão etc.

#include <stdio.h>
#include <time.h>

#include <unistd.h> /* for sleep() */

int main() {
    struct timespec begin, end;
    clock_gettime(CLOCK_MONOTONIC_RAW, &begin);

    sleep(1);      // waste some time

    clock_gettime(CLOCK_MONOTONIC_RAW, &end);

    printf ("Total time = %f seconds\n",
            (end.tv_nsec - begin.tv_nsec) / 1000000000.0 +
            (end.tv_sec  - begin.tv_sec));

}

man clock_gettime afirma:

CLOCK_MONOTONIC
              Clock  that  cannot  be set and represents monotonic time since some unspecified starting point.  This clock is not affected by discontinuous jumps in the system time
              (e.g., if the system administrator manually changes the clock), but is affected by the incremental adjustments performed by adjtime(3) and NTP.

O ANSI C especifica apenas as funções de segunda hora de precisão. No entanto, se você estiver executando em um ambiente POSIX, poderá usar a função gettimeofday () que fornece microssegundos de resolução de tempo passado desde a época do UNIX.

Como uma observação lateral, eu não recomendaria o uso de clock (), pois ele é mal implementado em muitos sistemas (se não todos?) E não é preciso, além do fato de que se refere apenas ao tempo que o seu programa passou na CPU e não o tempo de vida total do programa, que, de acordo com sua pergunta, é o que suponho que você gostaria de medir.

Todas as soluções não estão funcionando no meu sistema.

Eu posso usar

#include <time.h>

double difftime(time_t time1, time_t time0);

    #include<time.h>
    #include<stdio.h>
    int main(){
clock_t begin=clock();

    int i;
for(i=0;i<100000;i++){
printf("%d",i);

}
clock_t end=clock();
printf("Time taken:%lf",(double)(end-begin)/CLOCKS_PER_SEC);
}

Este programa funcionará como charme.

Descobri que o relógio usual (), todo mundo recomenda aqui, por algum motivo se desvia muito de uma corrida para outra, mesmo para código estático sem efeitos colaterais, como desenhar na tela ou ler arquivos. Pode ser porque a CPU altera os modos de consumo de energia, OS dando prioridades diferentes, etc ...

Portanto, a única maneira de obter o mesmo resultado sempre de forma confiável com clock () é executar o código medido em um loop várias vezes (por vários minutos), tomando precauções para impedir que o compilador o otimize: os compiladores modernos podem pré-calcular o código sem efeitos colaterais sendo executados em um loop e mova-o para fora do loop., como, por exemplo, usar entrada aleatória para cada iteração.

Depois que amostras suficientes são coletadas em uma matriz, uma classifica essa matriz e pega o elemento do meio, chamado mediana. A mediana é melhor que a média, porque elimina desvios extremos, como, por exemplo, antivírus que ocupam toda a CPU ou OS fazendo alguma atualização.

Aqui está um utilitário simples para medir o desempenho de execução do código C / C ++, com a média dos valores próximos da mediana: https://github.com/saniv/gauge

Ainda estou procurando uma maneira mais rápida e robusta de medir o código. Provavelmente, pode-se tentar executar o código em condições controladas no bare metal sem nenhum sistema operacional, mas isso dará um resultado irreal, porque, na realidade, o sistema operacional se envolve.

O x86 possui esses contadores de desempenho de hardware, que incluem o número real de instruções executadas, mas são difíceis de acessar sem a ajuda do SO, difíceis de interpretar e têm seus próprios problemas ( http://archive.gamedev.net/archive/reference/articles /article213.html ). Ainda assim, eles podem ser úteis para investigar a natureza do gargalo da garrafa (acesso a dados ou cálculos reais nesses dados).

Alguns podem achar útil um tipo diferente de entrada: recebi esse método de medir o tempo como parte de um curso universitário de programação GPGPU com a NVidia CUDA ( descrição do curso ). Ele combina os métodos vistos nas postagens anteriores, e eu simplesmente a publico porque os requisitos dão credibilidade:

unsigned long int elapsed;
struct timeval t_start, t_end, t_diff;
gettimeofday(&t_start, NULL);

// perform computations ...

gettimeofday(&t_end, NULL);
timeval_subtract(&t_diff, &t_end, &t_start);
elapsed = (t_diff.tv_sec*1e6 + t_diff.tv_usec);
printf("GPU version runs in: %lu microsecs\n", elapsed);

Suponho que você possa se multiplicar, por exemplo, 1.0 / 1000.0para obter a unidade de medida que atenda às suas necessidades.

Comparação do tempo de execução do tipo de bolha e do tipo de seleção Eu tenho um programa que compara o tempo de execução do tipo de bolha e do tipo de seleção. Para descobrir o tempo de execução de um bloco de código, calcule o tempo antes e depois do bloco,

 clock_t start=clock();
 …
 clock_t end=clock();
 CLOCKS_PER_SEC is constant in time.h library

Código de exemplo:

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
int main()
{
   int a[10000],i,j,min,temp;
   for(i=0;i<10000;i++)
   {
      a[i]=rand()%10000;
   }
   //The bubble Sort
   clock_t start,end;
   start=clock();
   for(i=0;i<10000;i++)
   {
     for(j=i+1;j<10000;j++)
     {
       if(a[i]>a[j])
       {
         int temp=a[i];
         a[i]=a[j];
         a[j]=temp;
       }
     }
   }
   end=clock();
   double extime=(double) (end-start)/CLOCKS_PER_SEC;
   printf("\n\tExecution time for the bubble sort is %f seconds\n ",extime);

   for(i=0;i<10000;i++)
   {
     a[i]=rand()%10000;
   }
   clock_t start1,end1;
   start1=clock();
   // The Selection Sort
   for(i=0;i<10000;i++)
   {
     min=i;
     for(j=i+1;j<10000;j++)
     {
       if(a[min]>a[j])
       {
         min=j;
       }
     }
     temp=a[min];
     a[min]=a[i];
     a[i]=temp;
   }
   end1=clock();
   double extime1=(double) (end1-start1)/CLOCKS_PER_SEC;
   printf("\n");
   printf("\tExecution time for the selection sort is %f seconds\n\n", extime1);
   if(extime1<extime)
     printf("\tSelection sort is faster than Bubble sort by %f seconds\n\n", extime - extime1);
   else if(extime1>extime)
     printf("\tBubble sort is faster than Selection sort by %f seconds\n\n", extime1 - extime);
   else
     printf("\tBoth algorithms have the same execution time\n\n");
}