Timing.cpp

Go to the documentation of this file.

//====================================================================
//  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 "GaudiKernel/Timing.h"
#include "ProcessDescriptor.h"

#include <climits>
#include <ctime>
#ifdef _WIN32
#include <windows.h>
#else
#include <sys/time.h>
#include <sys/times.h>
#include <unistd.h>
#endif

#ifdef _WIN32
static const longlong UNIX_BASE_TIME = 116444736000000000;
#else
static const longlong UNIX_BASE_TIME = 0;
#endif

// convert time from internal representation to the appropriate type
// Internal representation for WIN32: 100 nanosecond intervals
//                             Unix:    1 clock tick (usually 10 milliseconds)
longlong System::adjustTime( TimeType typ, longlong t )
{
  if ( t != -1 ) {
#ifndef _WIN32
//  t /= CLK_TCK ;     // needs division by clock tick unit

#endif
    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 );
    }
  }
  return t;
}

longlong System::tickCount()
{
  longlong count = 10000;
#ifdef _WIN32
  count *= ::GetTickCount(); // Number of milliSec since system startup
#else
  struct tms buf;
  count *= 10 * times( &buf );
#endif
  return count;
}

#include <iostream>

longlong 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>();
}

longlong System::systemStart( TimeType typ )
{
  static longlong sys_start = 0;
  if ( 0 == sys_start ) {
    longlong c = currentTime( microSec );
    longlong t = tickCount();
    sys_start  = 10 * c - t;
  }
  return adjustTime( typ, sys_start );
}

longlong System::upTime( TimeType typ )
{
  static longlong sys_start = 10 * systemStart( microSec );
  return adjustTime( typ, 10 * currentTime( microSec ) - sys_start );
}

longlong System::creationTime( TimeType typ, InfoType fetch, long pid )
{
  longlong created = 0;
  KERNEL_USER_TIMES info;
  if ( fetch != NoFetch && getProcess()->query( pid, fetch, &info ) ) {
    created = adjustTime( typ, info.CreateTime - UNIX_BASE_TIME );
  }
  return created;
}

longlong System::remainingTime( TimeType typ, InfoType fetch, long pid )
{
  longlong 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;
}

longlong System::ellapsedTime( TimeType typ, InfoType fetch, long pid )
{
  KERNEL_USER_TIMES info;
  longlong ellapsed = currentTime( microSec ) * 10;
  getProcess()->query( pid, fetch, &info );
  ellapsed = adjustTime( typ, ellapsed + UNIX_BASE_TIME - info.CreateTime );
  return ellapsed;
}

longlong System::kernelTime( TimeType typ, InfoType fetch, long pid )
{
  KERNEL_USER_TIMES info;
  longlong kerneltime = 0;
  if ( fetch != NoFetch && getProcess()->query( pid, fetch, &info ) ) {
    kerneltime = adjustTime( typ, info.KernelTime );
  }
  return kerneltime;
}

longlong System::userTime( TimeType typ, InfoType fetch, long pid )
{
  longlong usertime = 0;
  KERNEL_USER_TIMES info;
  if ( fetch != NoFetch && getProcess()->query( pid, fetch, &info ) ) {
    usertime = adjustTime( typ, info.UserTime );
  }
  return usertime;
}

longlong System::cpuTime( TimeType typ, InfoType fetch, long pid )
{
  longlong 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
  }
}