timers.cc

Go to the documentation of this file.

// SPDX-FileCopyrightText: Copyright (c) NumeriCor GmbH
// SPDX-License-Identifier: Apache-2.0
 
#include "timers.h"
 
#include <cstddef>
#include <cstdio>
#include <string>
#include "basics.h"
 
namespace opencarp
{
 
void lin_solver_stats::init_logger(const char* filename)
{
  logger = f_open(filename, "w");
 
  const char* h1 = "          ----- ----- -------  -----  ----- | ---- ----- --------- --------- --------- |";
  const char* h2 = "          mn it mx it  avg it    its  ttits |   ss    ts        st      stps     stpit |";
 
  if (logger == NULL)
    log_msg(NULL, 3, 0, "%s error: Could not open file %s in %s. Turning off logging.\n",
            __func__, filename);
  else {
    log_msg(logger, 0, 0, "%s", h1);
    log_msg(logger, 0, 0, "%s", h2);
  }
}
 
void lin_solver_stats::log_stats(double tm, bool cflg)
{
  if (!this->logger) return;
 
  // make sure this->solves is > 0
  if (!this->solves) this->solves++;
 
  char itbuf[256];
  char stbuf[64];
 
  // iterations in this period
  float its = (this->tot - this->last_tot);
 
  // total solver time spent in this period
  float tstm = this->slvtime - this->lastSlvtime;
 
  // solver time per solve
  float stm = tstm / this->solves;
 
  // solver time per iteration
  float itm = its ? tstm / its : 0.;
 
  if (!its)
    this->min = 0;
  this->totsolves += this->solves;
 
  snprintf(itbuf, sizeof itbuf, "%5d %5d %7.1f %6d %6d",
           this->min, this->max, (float)(its / this->solves),
           this->tot - this->last_tot, this->tot);
  snprintf(stbuf, sizeof stbuf, "%4d %5d %9.4f %9.4f %9.4f", this->solves, this->totsolves,
           (float)tstm, stm, itm);
 
  unsigned char flag = cflg ? ECHO : 0;
  log_msg(this->logger, 0, flag | FLUSH | NONL, "%9.3f %s | %s |\n", tm, itbuf, stbuf);
 
  this->min         = INT_MAX;
  this->max         = 0;
  this->last_tot    = this->tot;
  this->solves      = 0;
  this->lastSlvtime = this->slvtime;
}
 
void lin_solver_stats::update_iter(const int curiter)
{
  if (curiter > max) max = curiter;
  if (curiter < min) min = curiter;
  tot += curiter;
  solves++;
}
 
void generic_timing_stats::init_logger(const char* filename)
{
  logger = f_open(filename, "w");
 
  const char* h1 = "          ----- ----- | --------- --------- |";
  const char* h2 = "            cls ttcls |      time  tot time |";
 
  if (logger == NULL)
    log_msg(NULL, 3, 0, "%s error: Could not open file %s in %s. Turning off logging.\n",
            __func__, filename);
  else {
    log_msg(logger, 0, 0, "%s", h1);
    log_msg(logger, 0, 0, "%s", h2);
  }
}
 
void generic_timing_stats::log_stats(double tm, bool cflg)
{
  if (!this->logger) return;
 
  char cbuf[256];
  char tbuf[256];
 
  // time spent in this period
  float ctm = this->tot_time - this->last_tot_time;
  this->tot_calls += this->calls;
 
  snprintf(cbuf, sizeof cbuf, "%5d %5d", this->calls, this->tot_calls);
  snprintf(tbuf, sizeof tbuf, "%9.4f %9.4f", ctm, this->tot_time);
 
  unsigned char flag = cflg ? ECHO : 0;
  log_msg(this->logger, 0, flag | FLUSH | NONL, "%9.3f %s | %s |\n", tm, cbuf, tbuf);
 
  this->last_tot_time = this->tot_time;
  this->calls         = 0;
}
 
void eikonal_solver_stats::init_logger(const char* filename)
{
  logger = f_open(filename, "w");
 
  const char* h1 = "          CycFIM (Step A) ------ ------  ---------  --------- | Idiff (Step B) ------ | Repol. times (Step D)";
  const char* h2 = "            mn AT   mx AT    its  ttits       time     tttime |       time     tttime |       time     tttime";
 
  if (logger == NULL)
    log_msg(NULL, 3, 0, "%s error: Could not open file %s in %s. Turning off logging.\n",
            __func__, filename);
  else {
    log_msg(logger, 0, 0, "%s", h1);
    log_msg(logger, 0, 0, "%s", h2);
  }
}
 
void eikonal_solver_stats::log_stats(double time, bool cflg)
{
  if (!this->logger) return;
 
  char abuf[256];
  char bbuf[256];
  char dbuf[256];
 
  // iterations in this period
  float its = (this->tot - this->last_tot);
 
  // total solver time spent in this period
  float tstm_A = this->slvtime_A - this->lastSlvtime_A;
  float tstm_B = this->slvtime_B - this->lastSlvtime_B;
  float tstm_D = this->slvtime_D - this->lastSlvtime_D;
 
  this->totsolves += this->solves;
 
  snprintf(abuf, sizeof abuf, "%7.2f %7.2f %6d %6d %10.4f %10.4f", this->minAT, this->maxAT, this->tot - this->last_tot, this->tot, tstm_A, this->slvtime_A);
  snprintf(bbuf, sizeof bbuf, "%10.4f %10.4f", tstm_B, this->slvtime_B);
  snprintf(dbuf, sizeof dbuf, "%10.4f %10.4f", tstm_D, this->slvtime_D);
 
  unsigned char flag = cflg ? ECHO : 0;
  log_msg(this->logger, 0, flag | FLUSH | NONL, "%9.3f %s | %s | %s\n", time, abuf, bbuf, dbuf);
 
  this->lastSlvtime_A = this->slvtime_A;
  this->lastSlvtime_B = this->slvtime_B;
  this->lastSlvtime_D = this->slvtime_D;
  this->last_tot    = this->tot;
  this->solves      = 0;
}
 
void eikonal_solver_stats::update_iter(const int curiter)
{
  tot += curiter;
  solves++;
}
 
void eikonal_solver_stats::update_cli(double time, bool cflg)
{
  char buf[256];
 
  // total solver time spent in this period
  float tstm_A = this->slvtime_A - this->lastSlvtime_A;
  float tstm_B = this->slvtime_B - this->lastSlvtime_B;
  float tstm_D = this->slvtime_D - this->lastSlvtime_D;
 
  snprintf(buf, sizeof buf, "EIK_CYC %d", this->cycle);
  log_msg(NULL, 0, ECHO | FLUSH, "%.2f\t----\t%.1f\t%15s", time, tstm_A+tstm_B+tstm_D, buf);
 
  if (param_globals::output_level > 1) {
    const char* end_out = "----\t----- \t----\t-------\t-------";
    log_msg(NULL, 0, ECHO | FLUSH, "minAT:\t%.2f -> %.2f", last_minAT, minAT);
    log_msg(NULL, 0, ECHO | FLUSH, "maxAT:\t%.2f -> %.2f", last_maxAT, maxAT);
    log_msg(NULL, 0, ECHO | FLUSH, "active list: %7i \tbc applied: %3s", this->activeList, this->bc_status ? "yes" : "no");
    log_msg(NULL, 0, ECHO | FLUSH, "%s", end_out);
  }
 
  this->cycle++;
  this->bc_status = false;
  this->last_minAT = this->minAT;
  this->last_maxAT = this->maxAT;
}
 
}  // namespace opencarp