Pesquisar no blog:

domingo, 12 de abril de 2015

Medir tempo de execução em C

Como medir o tempo de execução de um programa ou parte dele?
Talvez você já tenha precisado disso, como eu precisei e tive certa dificuldade. Na verdade é bem simples, oque gera confusão é que muitas vezes o programa é executado tão rapidamente que recebe-se o retorno 0, principalmente se o tempo for mostrado em segundos.
Para a maioria dos casos o ideal é mostra em milissegundos.

Biblioteca time.h

Para fazer uso da função que irá retornar o tempo de execução de um programa é necessário chamar a biblioteca time.h. Aqui no blog já falei sobre ela para fazer o uso das funções rand e srand, para geração de valores aleatórios.
Para chamar essa biblioteca basta por no cabeçalho do seu programa:
#include <time.h>

Dessa vez faremos o uso da função clock, do tipo clock_t, e da macro CLOCKS_PER_SEC.


Função clock() e a macro CLOCKS_PER_SEC

A função clock retorna o tempo de execução exato do momento em que ela foi chamada. Para encontrar o tempo de execução de um programa precisamos usar ela duas vezes, uma para capturar o tempo inicial e outra para capturar o tempo final da execução.
Se fizermos o tempo final - tempo inicial teremos o tempo de execução do programa em milissegundos. Dividindo esse valor pelo CLOCKS_PER_SEC teremos este valor em segundos, pois esta constante tem o valor de 1000000. Para obter o valor em milissegundos, pode-se dividir o CLOCKS_PER_SEC por 1000.
E onde se encaixo o clock_t?
A variável que irá armazenar o valor do tempo da função clock deve ser do tipo clock_t.
Vamos a um exemplo simples usando um algoritmo de ordenção bubble sort:
#include <stdio.h>
#include <stdlib.h>
#include <time.h> //clock(), CLOCKS_PER_SEC e clock_t

#define TAM 10000 //constante para tamanho do vetor

int RandomInteger(int low, int high)
{
    int k;
    srand( (unsigned)time(NULL) );
    k = (rand() % high) + low;
    return k;
}

void bubbleSort (int v[TAM]) {
    int a, b, aux;
    for (a=TAM-1; a>=1; a--) {
        for (b=0; b<a; b++) {
            if (v[b]>v[b+1]) {
                aux = v[b];
                v[b] = v[b+1];
                v[b+1] = aux;
            }
        }
    }
}

int main(){
 clock_t t; //variável para armazenar tempo
 int vetor[TAM]; //vetor com 10000 posições
 int p, r, a;
 p = 0;
 r = TAM;

  //geração aleatório dos valores do vetor
 for(a = 0; a < TAM; a++)
  vetor[a] = RandomInteger(0, TAM);

    //Verificando tempo de execução do bubble sort=> t2
 t = clock(); //armazena tempo
 bubbleSort(vetor);
 t = clock() - t; //tempo final - tempo inicial
 //imprime o tempo na tela
 printf("Tempo de execucao: %lf", ((double)t)/((CLOCKS_PER_SEC/1000))); //conversão para double
}

Observe que ao imprimir o tempo em segundos, como explicado anteriormente, o CLOCKS_PER_SEC foi dividido por 1000, para apresentar o tempo em milissegundos.

Nenhum comentário:

Postar um comentário