---

/Go4ProfileTimer/TGo4ProfileTimer.cxx

Go to the documentation of this file.

//---------------------------------------------------------------
//        Go4 Release Package v2.10-5 (build 21005) 
//                      03-Nov-2005
//---------------------------------------------------------------
//       The GSI Online Offline Object Oriented (Go4) Project
//       Experiment Data Processing at DVEE department, GSI
//---------------------------------------------------------------
//
//Copyright (C) 2000- Gesellschaft f. Schwerionenforschung, GSI
//                    Planckstr. 1, 64291 Darmstadt, Germany
//Contact:            http://go4.gsi.de
//----------------------------------------------------------------
//This software can be used under the license agreements as stated
//in Go4License.txt file which is part of the distribution.
//----------------------------------------------------------------
#include "TGo4ProfileTimer.h"

#include <iostream.h>
#include <string.h>
#include <unistd.h>

ClassImp(TGo4ProfileTimer)

// start: set begin and last time
// stop: set last and end time
// stop() ... stop() ... stop()
// elapsed_rusage(ru): resource usage between last start()/stop() and now (end)
// elapsed_time(et):   time elapsed from start() (begin) to stop() (end)



Int_t TGo4ProfileTimer::Start(void)
{
  gettimeofday (&this->fxBeginTime, 0);
  this->fxLastTime = this->fxBeginTime;
  getrusage (RUSAGE_SELF, &this->fxBeginUsage);
  this->fxLastUsage = this->fxBeginUsage;
  return 0;
}


Int_t TGo4ProfileTimer::Stop(void)
{
  this->fxLastTime = this->fxEndTime;
  gettimeofday (&this->fxEndTime, 0);
  this->fxLastUsage = this->fxEndUsage;
  getrusage (RUSAGE_SELF, &this->fxEndUsage);

  return 0;
}

// Terminate the interval timer.

TGo4ProfileTimer::~TGo4ProfileTimer (void)
{
}

void
TGo4ProfileTimer::Dump (void) const
{
}

// Give short timing resume

void
TGo4ProfileTimer::Resume (void)
{
  int rc;
  TGo4ElapsedTime et;
  TGo4ProfileTimer::Rusage ru;

  // between begin and end
  rc = this->ElapsedTime(et);
  // between last stop() and end
  this->ElapsedRusage(ru);

  cout << "\nResource Usage: Timing [s]\n";
  cout << "Real:\t" << et.fdRealTime << endl;
  //cout << "\nUser:\t" << et.fdUserTime << endl;
  cout << "User:\t" << (float)(ru.ru_utime.tv_sec + (float)ru.ru_utime.tv_usec/1000000.)  << endl;
  //cout << "\nSystem:\t" << et.fdSystemTime << endl;
  cout << "System:\t" << (float)(ru.ru_stime.tv_sec + (float)ru.ru_stime.tv_usec/1000000.)   << endl;
  cout << "\n";
}


// Give short memory resume

void
TGo4ProfileTimer::Memory (void)
{
  TGo4ProfileTimer::Rusage ru;

  // between last stop() and end
  this->ElapsedRusage(ru);

  cout << "\nResource Usage: Memory etc.\n";
  cout << "maximum resident set size     \t";
  cout << ru.ru_maxrss << endl;
  cout << "integral shared memory size   \t";
  cout << ru.ru_ixrss << endl;
  cout << "integral unshared data        \t";
  cout << ru.ru_idrss << endl;
  cout << "integral unshared stack       \t";
  cout << ru.ru_isrss << endl;
  cout << "page reclaims - total vmfaults\t";
  cout << ru.ru_minflt << endl;
  cout << "page faults                   \t";
  cout << ru.ru_majflt << endl;
  cout << "swaps                         \t";
  cout << ru.ru_nswap << endl;
  cout << "block input operations        \t";
  cout << ru.ru_inblock << endl;
  cout << "block output operations       \t";
  cout << ru.ru_oublock << endl;
  cout << "messages sent                 \t";
  cout << ru.ru_msgsnd << endl;
  cout << "messages received             \t";
  cout << ru.ru_msgrcv << endl;
  cout << "signals received              \t";
  cout << ru.ru_nsignals << endl;
  cout << "voluntary context switches    \t";
  cout << ru.ru_nvcsw << endl;
  cout << "involuntary context switches  \t";
  cout << ru.ru_nivcsw << endl;
  cout << "\n";
}


// Initialize interval timer.

TGo4ProfileTimer::TGo4ProfileTimer (void)
{
  memset (&this->fxEndUsage, 0, sizeof this->fxEndUsage);
  memset (&this->fxBeginUsage, 0, sizeof this->fxBeginUsage);
  memset (&this->fxLastUsage, 0, sizeof this->fxLastUsage);

  memset (&this->fxBeginTime, 0, sizeof this->fxBeginTime);
  memset (&this->fxEndTime, 0, sizeof this->fxEndTime);
  memset (&this->fxLastTime, 0, sizeof this->fxLastTime);

  char buf[20];
  snprintf (buf,19, "/proc/%d", getpid ());

  cout << "Profile_Timer created for (" << buf << ")" << endl;
}

// Return the resource utilization.

void
TGo4ProfileTimer::GetRusage (TGo4ProfileTimer::Rusage &usage)
{
  usage = this->fxEndUsage;
}

// Compute the amount of resource utilization since the start time.

void
TGo4ProfileTimer::ElapsedRusage (TGo4ProfileTimer::Rusage &usage)
{
  //  maximum resident set size
  usage.ru_maxrss = this->fxEndUsage.ru_maxrss - this->fxLastUsage.ru_maxrss;
  // integral shared memory size
  usage.ru_ixrss = this->fxEndUsage.ru_ixrss - this->fxLastUsage.ru_ixrss;
  // integral unshared data
  usage.ru_idrss = this->fxEndUsage.ru_idrss - this->fxLastUsage.ru_idrss;
  // integral unshared stack
  usage.ru_isrss = this->fxEndUsage.ru_isrss - this->fxLastUsage.ru_isrss;
  // page reclaims - total vmfaults
  usage.ru_minflt = this->fxEndUsage.ru_minflt - this->fxLastUsage.ru_minflt;
  // page faults
  usage.ru_majflt = this->fxEndUsage.ru_majflt - this->fxLastUsage.ru_majflt;
  // swaps
  usage.ru_nswap = this->fxEndUsage.ru_nswap - this->fxLastUsage.ru_nswap;
  // block input operations
  usage.ru_inblock = this->fxEndUsage.ru_inblock -
                       this->fxLastUsage.ru_inblock;
  // block output operations
  usage.ru_oublock = this->fxEndUsage.ru_oublock -
                       this->fxLastUsage.ru_oublock;
  // messages sent
  usage.ru_msgsnd = this->fxEndUsage.ru_msgsnd - this->fxLastUsage.ru_msgsnd;
  // messages received
  usage.ru_msgrcv = this->fxEndUsage.ru_msgrcv - this->fxLastUsage.ru_msgrcv;
  // signals received
  usage.ru_nsignals = this->fxEndUsage.ru_nsignals -
                        this->fxLastUsage.ru_nsignals;
  // voluntary context switches
  usage.ru_nvcsw = this->fxEndUsage.ru_nvcsw - this->fxLastUsage.ru_nvcsw;
  // involuntary context switches
  usage.ru_nivcsw = this->fxEndUsage.ru_nivcsw - this->fxLastUsage.ru_nivcsw;
  this->Subtract (usage.ru_utime, this->fxEndUsage.ru_utime, this->fxLastUsage.ru_utime);
  this->Subtract (usage.ru_stime, this->fxEndUsage.ru_stime, this->fxLastUsage.ru_stime);
}

// Compute the elapsed time.

void
TGo4ProfileTimer::ComputeTimes (TGo4ElapsedTime &et)
{
  timeval td;

  //Profile_Timer::Rusage &end = this->end_usage_;
  //Profile_Timer::Rusage &begin = this->begin_usage_;

  this->Subtract (td, this->fxEndTime, this->fxBeginTime);
  et.fdRealTime = td.tv_sec + ((double) td.tv_usec) / ONE_SECOND_IN_USECS;

  this->Subtract (td, this->fxEndUsage.ru_utime, this->fxBeginUsage.ru_utime);
  et.fdUserTime = td.tv_sec + ((double) td.tv_usec) / ONE_SECOND_IN_USECS;

  this->Subtract (td, this->fxEndUsage.ru_stime,  this->fxBeginUsage.ru_stime);
  et.fdSystemTime = td.tv_sec + ((double) td.tv_usec) / ONE_SECOND_IN_USECS;
}

// Determine the difference between T1 and T2.

void
TGo4ProfileTimer::Subtract (timeval &tdiff, timeval &t1, timeval &t0)
{
  tdiff.tv_sec  = t1.tv_sec - t0.tv_sec;
  tdiff.tv_usec = t1.tv_usec - t0.tv_usec;

  // Normalize the time.

  while (tdiff.tv_usec < 0)
    {
      tdiff.tv_sec--;
      tdiff.tv_usec += ONE_SECOND_IN_USECS;
    }
}

// Compute the amount of time that has elapsed between start and stop.

Int_t
TGo4ProfileTimer::ElapsedTime (TGo4ElapsedTime &et)
{
  this->ComputeTimes (et);
  return 0;
}
TGo4ProfileTimer::TGo4ElapsedTime::TGo4ElapsedTime(): fdRealTime(0.), fdUserTime(0.), fdSystemTime(0.)
{

}




//----------------------------END OF GO4 SOURCE FILE ---------------------

---