paraSysTimer.cpp

Go to the documentation of this file.

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
/*                                                                           */
/*          This file is part of the program and software framework          */
/*                    UG --- Ubquity Generator Framework                     */
/*                                                                           */
/*  Copyright Written by Yuji Shinano <shinano@zib.de>,                      */
/*            Copyright (C) 2021-2026 by Zuse Institute Berlin,              */
/*            licensed under LGPL version 3 or later.                        */
/*            Commercial licenses are available through <licenses@zib.de>    */
/*                                                                           */
/* This code is free software; you can redistribute it and/or                */
/* modify it under the terms of the GNU Lesser General Public License        */
/* as published by the Free Software Foundation; either version 3            */
/* of the License, or (at your option) any later version.                    */
/*                                                                           */
/* This program 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 Lesser General Public License for more details.                       */
/*                                                                           */
/* You should have received a copy of the GNU Lesser General Public License  */
/* along with this program.  If not, see <http://www.gnu.org/licenses/>.     */
/*                                                                           */
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 
/**@file    paraSysTimer.cpp
 * @brief   System timer.
 * @author  Yuji Shinano
 *
 *
 *
 */
 
/*---+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9----+----0----+----1----+----2*/
 
 
#include "paraSysTimer.h"
 
#include <ctime>
#if defined(__unix__) || defined(__APPLE__)
#include <sys/resource.h>
#elif defined(_MSC_VER)
#include <windows.h>   // GetProcessTimes() -- getrusage() is not available on the MS compiler
#endif
 
using namespace UG;
 
///
/// read the process' user / system CPU time in seconds
///
static void
readProcessCpuTime(
      double &userSeconds,
      double &systemSeconds
      )
{
#if defined(__unix__) || defined(__APPLE__)
   struct rusage ru;
   if( getrusage(RUSAGE_SELF, &ru) == 0 )
   {
      userSeconds   = (double)ru.ru_utime.tv_sec + (double)ru.ru_utime.tv_usec * 1e-6;
      systemSeconds = (double)ru.ru_stime.tv_sec + (double)ru.ru_stime.tv_usec * 1e-6;
      return;
   }
   userSeconds   = 0.0;
   systemSeconds = 0.0;
#elif defined(_MSC_VER)
   /// Windows / MS compiler: getrusage() is unavailable, so recover the GetProcessTimes() path
   /// that the std::chrono modernization (commit 06ea3d83) dropped. It reports the process'
   /// cumulative user and kernel (system) CPU time as FILETIMEs in 100-nanosecond units; combine
   /// each FILETIME's high/low halves (ULARGE_INTEGER avoids the signed-shift the old __int64 code
   /// used) and scale by 1e7 to get seconds.
   FILETIME ftCreationTime, ftExitTime, ftKernelTime, ftUserTime;
   if( GetProcessTimes( GetCurrentProcess(),
                        &ftCreationTime, &ftExitTime, &ftKernelTime, &ftUserTime ) )
   {
      ULARGE_INTEGER u, k;
      u.LowPart  = ftUserTime.dwLowDateTime;    u.HighPart  = ftUserTime.dwHighDateTime;
      k.LowPart  = ftKernelTime.dwLowDateTime;  k.HighPart  = ftKernelTime.dwHighDateTime;
      userSeconds   = (double)u.QuadPart / 1.0e7;   // 100-ns units -> seconds
      systemSeconds = (double)k.QuadPart / 1.0e7;
      return;
   }
   userSeconds   = 0.0;
   systemSeconds = 0.0;
#else
   /// portable fallback: std::clock() reports total processor time; there is no
   /// standard user/system split, so charge it all to user time.
   userSeconds   = (double)std::clock() / (double)CLOCKS_PER_SEC;
   systemSeconds = 0.0;
#endif
}
 
void
ParaSysTimer::start(
      void
      )
{
   startPoint = std::chrono::steady_clock::now();
   readProcessCpuTime(uTimeStart, sTimeStart);
}
 
void
ParaSysTimer::stop(
      void
      )
{
   stopPoint = std::chrono::steady_clock::now();
   readProcessCpuTime(uTimeStop, sTimeStop);
}
 
double
ParaSysTimer::getStartTime(
      void
      )
{
   return std::chrono::duration<double>( startPoint.time_since_epoch() ).count();
}
 
double
ParaSysTimer::getRTimeInterval(
      void
      )
{
   return std::chrono::duration<double>( std::chrono::steady_clock::now() - startPoint ).count();
}
 
double
ParaSysTimer::getRTime(
      void
      )
{
   return std::chrono::duration<double>( stopPoint - startPoint ).count();
}
 
double
ParaSysTimer::getUTime(
      void
      )
{
   return uTimeStop - uTimeStart;
}
 
double
ParaSysTimer::getSTime(
      void
      )
{
   return sTimeStop - sTimeStart;
}