gettime.c

/***********************************************************************
 * Copyright (C) 2002,2003,2004,2005,2006,2007,2008 Carsten Urbach
 * Copyright (C) 2012 Bartosz Kostrzewa (gettime.[c,h])
 *
 * This file is part of tmLQCD.
 *
 * tmLQCD is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * tmLQCD is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with tmLQCD.  If not, see <http://www.gnu.org/licenses/>.
 ***********************************************************************/

#ifdef HAVE_CONFIG_H
#include <tmlqcd_config.h>
#endif
#ifdef HAVE_CLOCK_GETTIME
#ifndef _POSIX_C_SOURCE
#define _POSIX_C_SOURCE 199309L
#endif
#include <sys/time.h>
// #  include <bits/time.h>
#endif
#include <time.h>
#ifdef TM_USE_MPI
#include <mpi.h>
#endif

#include "fatal_error.h"
#include "gettime.h"
#include "global.h"

#include <string.h>

double gettime(void) {
  double t;
#if defined TM_USE_MPI

  t = MPI_Wtime();

#elif (defined HAVE_CLOCK_GETTIME)

  struct timespec ts;

  clock_gettime(CLOCK_MONOTONIC, &ts);
  t = ts.tv_sec + 1.0e-9 * ts.tv_nsec;

#else
  /* This number is completely unreliable because the operating system and other processes
     make the clock tick too. This is especially true with multiple threads where the number
     of clock ticks will be multiplied by roughly the number of threads, but not quite, making
     the measurement useless!  */

  t = (double)clock() / (CLOCKS_PER_SEC);

#endif

  return t;
}

void tm_stopwatch_push(tm_timers_t* const timers, const char* const name, const char* group) {
  if (timers->lvl + 1 >= TM_TIMING_MAX_LEVELS) {
    fatal_error("attempted push would let timers->lvl exceed TM_TIMING_MAX_LEVELS",
                "tm_stopwatch_push");
  }
  timers->t[++(timers->lvl)] = gettime();
  if (strcmp(name, "") == 0) {
    char msg[200];
    snprintf(msg, 200, "name may not be empty! (group: %s)", group);
    fatal_error(msg, __func__);
  } else {
    const int empty_group = strcmp(group, "") == 0;
    snprintf(timers->callstack[timers->lvl], TM_TIMING_STACK_PATH_LENGTH, "%s/%s%s%s",
             timers->lvl - 1 >= 0 ? timers->callstack[timers->lvl - 1] : "",
             empty_group ? "" : group, empty_group ? "" : ":", name);
    snprintf(timers->name[timers->lvl], TM_TIMING_NAME_LENGTH, "%s", name);
  }
}

void tm_stopwatch_pop(tm_timers_t* const timers, const int proc_id, const int dbg_level_threshold,
                      const char* const prefix) {
  if ((timers->lvl - 1) < -1) {
    fatal_error("attempted pop would let timers->lvl drop below the lowest possible value",
                "tm_stopwatch_pop");
  }
  if (g_proc_id == proc_id && g_debug_level >= dbg_level_threshold) {
    printf("# %s: Time for %s %e s level: %d proc_id: %d %s\n", prefix, timers->name[timers->lvl],
           gettime() - timers->t[timers->lvl], timers->lvl, g_proc_id,
           timers->callstack[timers->lvl]);
  }
  (timers->lvl)--;
}