Timing.cpp

Go to the documentation of this file.

/***********************************************************************************\
* (c) Copyright 1998-2025 CERN for the benefit of the LHCb and ATLAS collaborations *
*                                                                                   *
* This software is distributed under the terms of the Apache version 2 licence,     *
* copied verbatim in the file "LICENSE".                                            *
*                                                                                   *
* In applying this licence, CERN does not waive the privileges and immunities       *
* granted to it by virtue of its status as an Intergovernmental Organization        *
* or submit itself to any jurisdiction.                                             *
\***********************************************************************************/
//====================================================================
//  Timing.cpp
//--------------------------------------------------------------------
//
//  Package    : System (The LHCb System service)
//
//  Description: Implementation of Systems internals
//
//  Author     : M.Frank
//  Created    : 13/1/99
//  Changes    :
//====================================================================
#define GAUDIKERNEL_TIMING_CPP
 
#include "ProcessDescriptor.h"
#include <GaudiKernel/Timing.h>
 
#include <climits>
#include <ctime>
#include <sys/time.h>
#include <sys/times.h>
#include <unistd.h>
 
static const long long UNIX_BASE_TIME = 0;
 
// convert time from internal representation to the appropriate type
// Internal representation for Unix:    1 clock tick (usually 10 milliseconds)
long long System::adjustTime( TimeType typ, long long t ) {
  if ( t != -1 ) {
    //  t /= CLK_TCK ;     // needs division by clock tick unit
 
    switch ( typ ) {
    case Year:
      return adjustTime<Year>( t );
    case Month:
      return adjustTime<Month>( t );
    case Day:
      return adjustTime<Day>( t );
    case Hour:
      return adjustTime<Hour>( t );
    case Min:
      return adjustTime<Min>( t );
    case Sec:
      return adjustTime<Sec>( t );
    case milliSec:
      return adjustTime<milliSec>( t );
    case microSec:
      return adjustTime<microSec>( t );
    case nanoSec:
      return adjustTime<nanoSec>( t );
    case Native:
      return adjustTime<Native>( t );
    default:
      return t;
    }
  }
  return t;
}
 
long long System::tickCount() {
  long long  count = 10000;
  struct tms buf;
  count *= 10 * times( &buf );
  return count;
}
 
#include <iostream>
 
long long System::currentTime( TimeType typ ) {
  switch ( typ ) {
  case Year:
    return currentTime<Year>();
  case Month:
    return currentTime<Month>();
  case Day:
    return currentTime<Day>();
  case Hour:
    return currentTime<Hour>();
  case Min:
    return currentTime<Min>();
  case Sec:
    return currentTime<Sec>();
  case milliSec:
    return currentTime<milliSec>();
  case microSec:
    return currentTime<microSec>();
  case nanoSec:
    return currentTime<nanoSec>();
  case Native:
    return currentTime<Native>();
  }
  return currentTime<Native>();
}
 
long long System::systemStart( TimeType typ ) {
  static long long sys_start = 0;
  if ( 0 == sys_start ) {
    long long c = currentTime( microSec );
    long long t = tickCount();
    sys_start   = 10 * c - t;
  }
  return adjustTime( typ, sys_start );
}
 
long long System::upTime( TimeType typ ) {
  static long long sys_start = 10 * systemStart( microSec );
  return adjustTime( typ, 10 * currentTime( microSec ) - sys_start );
}
 
long long System::creationTime( TimeType typ, InfoType fetch, long pid ) {
  long long         created = 0;
  KERNEL_USER_TIMES info;
  if ( fetch != NoFetch && getProcess()->query( pid, fetch, &info ) ) {
    created = adjustTime( typ, info.CreateTime - UNIX_BASE_TIME );
  }
  return created;
}
 
long long System::remainingTime( TimeType typ, InfoType fetch, long pid ) {
  long long    left = 0;
  QUOTA_LIMITS quota;
  if ( fetch != NoFetch && getProcess()->query( pid, fetch, &quota ) ) {
    if ( left == -1 ) {
      // left = _I64_MAX;
    } else {
      left = adjustTime( typ, quota.TimeLimit );
    }
  }
  return left;
}
 
long long System::ellapsedTime( TimeType typ, InfoType fetch, long pid ) {
  KERNEL_USER_TIMES info;
  long long         ellapsed = currentTime( microSec ) * 10;
  if ( getProcess()->query( pid, fetch, &info ) ) {
    ellapsed = adjustTime( typ, ellapsed + UNIX_BASE_TIME - info.CreateTime );
  }
  return ellapsed;
}
 
long long System::kernelTime( TimeType typ, InfoType fetch, long pid ) {
  KERNEL_USER_TIMES info;
  long long         kerneltime = 0;
  if ( fetch != NoFetch && getProcess()->query( pid, fetch, &info ) ) {
    kerneltime = adjustTime( typ, info.KernelTime );
  }
  return kerneltime;
}
 
long long System::userTime( TimeType typ, InfoType fetch, long pid ) {
  long long         usertime = 0;
  KERNEL_USER_TIMES info;
  if ( fetch != NoFetch && getProcess()->query( pid, fetch, &info ) ) { usertime = adjustTime( typ, info.UserTime ); }
  return usertime;
}
 
long long System::cpuTime( TimeType typ, InfoType fetch, long pid ) {
  long long         cputime = 0;
  KERNEL_USER_TIMES info;
  if ( fetch != NoFetch && getProcess()->query( pid, fetch, &info ) ) {
    cputime = adjustTime( typ, info.KernelTime + info.UserTime );
  }
  return cputime;
}
 
namespace System {
  ProcessTime getProcessTime( long pid ) {
    KERNEL_USER_TIMES info;
    if ( getProcess()->query( pid, Times, &info ) ) {
      return ProcessTime( info.KernelTime, info.UserTime, currentTime<Native>() - info.CreateTime );
    }
    return ProcessTime(); // return 0s in case of problems
  }
} // namespace System