Usar o temporizador em C++

1. Utilize a função clock() para implementar um temporizador em C++
2. Utilize a função gettimeofday para implementar um temporizador em C++

Este artigo irá demonstrar múltiplos métodos de como utilizar um temporizador em C++.

Utilize a função clock() para implementar um temporizador em C++

A função clock() é um método compatível com o POSIX para recuperar o tempo de processamento do programa. A função retorna o valor inteiro que precisa de ser dividido por uma constante macro-definida chamada CLOCKS_PER_SEC para converter para vários segundos.

O seguinte código de amostra implementa duas funções para encontrar o valor máximo num array de int. A função max_index faz a pesquisa com base no índice dos elementos, enquanto o max_value é baseado no valor. O objectivo é calcular quanto tempo gastam para encontrar o valor máximo de int no array de elementos 1.000.000 cheio de números inteiros aleatórios.

Repare que chamamos a função clock() duas vezes - antes da chamada max_index e depois da chamada. Este esquema de medição do tempo pode ser utilizado geralmente sem qualquer consideração pela função específica que recupera o tempo. Neste caso, podemos ver (dependendo do sistema de hardware) que o max_value faz o trabalho ligeiramente mais rápido do que a pesquisa baseada em índices. No entanto, estes algoritmos de pesquisa máxima têm O(N) complexidade e não devem ser empregues em qualquer base de código profissional, excepto talvez para experimentação.

#include <chrono>
#include <iostream>

using std::cout;
using std::endl;

int max_index(int arr[], int size) {
  size_t max = 0;

  for (int j = 0; j < size; ++j) {
    if (arr[j] > arr[max]) {
      max = j;
    }
  }
  return arr[max];
}

int max_value(int arr[], int size) {
  int max = arr[0];

  for (int j = 0; j < size; ++j) {
    if (arr[j] > max) {
      max = arr[j];
    }
  }
  return max;
}

constexpr int WIDTH = 1000000;

int main() {
  clock_t start, end;
  int max;

  int *arr = new int[WIDTH];

  std::srand(std::time(nullptr));
  for (size_t i = 0; i < WIDTH; i++) {
    arr[i] = std::rand();
  }

  start = clock();
  max = max_index(arr, WIDTH);
  end = clock();
  printf("max_index: %0.8f sec, max = %d\n",
         ((float)end - start) / CLOCKS_PER_SEC, max);

  start = clock();
  max = max_value(arr, WIDTH);
  end = clock();
  printf("max_value: %0.8f sec, max = %d\n",
         ((float)end - start) / CLOCKS_PER_SEC, max);

  exit(EXIT_SUCCESS);
}

Resultado:

max_value: 0.00131400 sec, max = 2147480499
max_value: 0.00089800 sec, max = 2147480499

Utilize a função gettimeofday para implementar um temporizador em C++

gettimeofday é uma função de recuperação de tempo altamente precisa em sistemas baseados em Linux, que também pode ser chamada a partir do código fonte C++. A função foi concebida para obter o tempo e os dados do fuso horário, mas este último foi depreciado durante algum tempo, e o segundo argumento deveria ser nullptr em vez do struct do fuso horário válido. A função gettimeofday armazena os dados de fuso horário no struct especial chamado timeval, que contém dois membros de dados tv_sec representando segundos e tv_usec para microssegundos.

Como regra geral, declaramos e inicializamos as duas estruturas timeval antes de chamar à função gettimeofday. Uma vez chamada a função, os dados devem ser armazenados com sucesso no strut correspondente, se o valor de retorno de gettimeofday for 0. Caso contrário, a falha é indicada pelo retorno do valor -1. Note que, depois de as estruturas serem preenchidas com dados, é necessário converter para o valor unitário comum do tempo. Este código de amostra implementa a função time_diff que devolve o tempo em segundos, que pode ser enviado para a consola conforme necessário.

#include <sys/time.h>

#include <ctime>
#include <iostream>

using std::cout;
using std::endl;

int max_index(int arr[], int size) {
  size_t max = 0;

  for (int j = 0; j < size; ++j) {
    if (arr[j] > arr[max]) {
      max = j;
    }
  }
  return arr[max];
}

int max_value(int arr[], int size) {
  int max = arr[0];

  for (int j = 0; j < size; ++j) {
    if (arr[j] > max) {
      max = arr[j];
    }
  }
  return max;
}

float time_diff(struct timeval *start, struct timeval *end) {
  return (end->tv_sec - start->tv_sec) + 1e-6 * (end->tv_usec - start->tv_usec);
}

constexpr int WIDTH = 1000000;

int main() {
  struct timeval start {};
  struct timeval end {};
  int max;

  int *arr = new int[WIDTH];

  std::srand(std::time(nullptr));
  for (size_t i = 0; i < WIDTH; i++) {
    arr[i] = std::rand();
  }

  gettimeofday(&start, nullptr);
  max = max_index(arr, WIDTH);
  gettimeofday(&end, nullptr);
  printf("max_index: %0.8f sec, max = %d\n", time_diff(&start, &end), max);

  gettimeofday(&start, nullptr);
  max = max_value(arr, WIDTH);
  gettimeofday(&end, nullptr);
  printf("max_value: %0.8f sec, max = %d\n", time_diff(&start, &end), max);

  exit(EXIT_SUCCESS);
}

Resultado:

max_value: 0.00126000 sec, max = 2147474877
max_value: 0.00093900 sec, max = 2147474877