PMonSD Namespace Reference

Classes
class	CmpEntries
class	CompDataBasic
class	CompDataExtended
struct	CompDataStdSteps
struct	Count
struct	Entry
class	FastStrCmp
struct	Meas
class	SemiDetHelper
class	StepWrapper
class	StepWrapperOther
class	StepWrapperStd

Typedefs
typedef std::pair< std::string, std::string >	OtherKey
typedef std::map< std::string, CompDataStdSteps, FastStrCmp >	MapStdSteps
typedef std::map< OtherKey, CompDataBasic, FastStrCmp >	MapOtherSteps

Functions
void	get_vmem_rss_kb (double &vmem, double &rss, bool vmemonly=false)
double get_malloc_kb	ATLAS_NOT_THREAD_SAFE ()
double	get_vmem_kb ()
double	get_rss_kb ()
double	get_cpu_ms ()
double	get_wall_ms ()
void	setUTCTimeString (std::string &s, double offset_ms=0)
unsigned	vmpeak ()
std::string	get_field (const char *filename, const std::string &fieldname, char space='_')
int64_t	clock_nooverflow ()
std::string	cpu_model ()
int	bogomips ()
const char *	envvar (const char *e, const char *def="")
bool	envvar_is_set (const char *e)
unsigned long	system_boot_time_seconds ()
double	get_absolute_wall_ms ()
double	secs_per_jiffy ()
double	jobstart_jiffy2unix_ms (const std::string &s)
const char *	symb2lib (const char *symbol, const char *failstr="unknown")

Typedef Documentation

MapOtherSteps

typedef std::map<OtherKey,CompDataBasic,FastStrCmp> PMonSD::MapOtherSteps

Definition at line 210 of file SemiDetMisc.h.

MapStdSteps

typedef std::map<std::string,CompDataStdSteps,FastStrCmp> PMonSD::MapStdSteps

Definition at line 208 of file SemiDetMisc.h.

OtherKey

typedef std::pair<std::string,std::string> PMonSD::OtherKey

Definition at line 191 of file SemiDetMisc.h.

Function Documentation

ATLAS_NOT_THREAD_SAFE()

double get_malloc_kb PMonSD::ATLAS_NOT_THREAD_SAFE

(

)

bogomips()

int PMonSD::bogomips ( )

inline

Definition at line 367 of file SemiDetMisc.h.

  {
    std::string bm=get_field("/proc/cpuinfo","bogomips",' ');
    if (bm=="unknown")
      return 0;
    return int(atof(bm.c_str())+0.5);
  }

clock_nooverflow()

int64_t PMonSD::clock_nooverflow ( )

inline

Definition at line 523 of file SemiDetMisc.h.

                                        {
  //In gnu, clock_t is a long and CLOCKS_PER_SECOND 1000000 so clock()
  //will overflow in 32bit builds after a few thousands of seconds. To
  //avoid this, we have the following method instead which notices when
  //overflow occurs and corrects for it (it won't notice if it doesn't
  //get called for >4000ms, but this should be ok for almost all of our
  //use cases):
  assert(std::numeric_limits<clock_t>::is_integer);
  if (sizeof(clock_t)>=sizeof(int64_t))
    return clock();//64bit builds shouldn't have overflow issues.
 
  //not so clean with statics i guess:
  static clock_t last=clock();
  static int64_t offset=0;
  clock_t c=clock();
  if (c<last)
    offset+=int64_t(std::numeric_limits<unsigned>::max())-int64_t(std::numeric_limits<unsigned>::min());
  last=c;
  return offset+c;
}

cpu_model()

std::string PMonSD::cpu_model ( )

inline

Definition at line 361 of file SemiDetMisc.h.

  {
    std::stringstream s;
    s<<get_field("/proc/cpuinfo","model name",'_')<<"/"<<get_field("/proc/cpuinfo","cache size",'_');
    return s.str();
  }

envvar()

const char* PMonSD::envvar ( const char *  e, const char *  def = ""  )

inline

Definition at line 374 of file SemiDetMisc.h.

  {
    const char * c = getenv(e);
    return c ? c : def;
  }

envvar_is_set()

bool PMonSD::envvar_is_set ( const char *  e )

inline

Definition at line 379 of file SemiDetMisc.h.

                                          {
    const char * c = getenv(e);
    if (!c) return false;
    return strncmp(c,"1",2)==0;
  }

get_absolute_wall_ms()

double PMonSD::get_absolute_wall_ms ( )

inline

Definition at line 402 of file SemiDetMisc.h.

  {
    timeval  tv;
    int err=gettimeofday(&tv, 0);
    if (err!=0)
      return 0.0;
    uint64_t res_usec=uint64_t(tv.tv_sec)*1000000 + uint64_t(tv.tv_usec);
    return 0.001*res_usec;
  }

get_cpu_ms()

double PMonSD::get_cpu_ms ( )

inline

Definition at line 544 of file SemiDetMisc.h.

{ return clock_nooverflow()*(1000.0/CLOCKS_PER_SEC); }

get_field()

std::string PMonSD::get_field ( const char *  filename, const std::string &  fieldname, char  space = '_'  )

inline

Definition at line 318 of file SemiDetMisc.h.

  {
    //nb: not hyper-optimised
    FILE* file = fopen(filename, "r");
    if (!file)
      return "unknown";
    std::string result;
    result.reserve(128);
    result="unknown";
    char line[256];
    while (fgets(line, 256, file) != NULL){
      if (strncmp(line, fieldname.c_str(), fieldname.size()) == 0) {
    size_t pos = std::string(line).find( ':', fieldname.size() );
    if (pos==std::string::npos) {
      fclose(file);
      return result;
    }
    result.clear();
    bool ignore_nextspace=true;
    ++pos;
    for (;pos<256;++pos) {
      if (line[pos]=='\n')
        break;
      if (line[pos]==' '||line[pos]=='\t') {
        if (ignore_nextspace)
          continue;
        ignore_nextspace=true;
        result+=space;
      } else {
        result+=line[pos];
        ignore_nextspace=false;
      }
    }
    break;
       }
     }
     fclose(file);
     //make sure there are no trailing "spaces":
     while (!result.empty()&&result.at(result.size()-1)==space)
       result.resize(result.size()-1);
     return result;
  }

get_rss_kb()

double PMonSD::get_rss_kb ( )

inline

Definition at line 473 of file SemiDetMisc.h.

{ double v,r;get_vmem_rss_kb(v,r); return r; }

get_vmem_kb()

double PMonSD::get_vmem_kb ( )

inline

Definition at line 472 of file SemiDetMisc.h.

{ double v,r;get_vmem_rss_kb(v,r,true); return v; }

get_vmem_rss_kb()

void PMonSD::get_vmem_rss_kb ( double &  vmem, double &  rss, bool  vmemonly = false  )

inline

Definition at line 447 of file SemiDetMisc.h.

                                                                        {
  vmem=rss=0.0;
#ifndef __linux
  vmemonly=false;//avoid compile warning
  return;
#else
  //It would be a lot faster without this open call...
  int fd = open("/proc/self/statm", O_RDONLY);
  if (fd<0) return;
  char data[32];
  int l = read(fd, data, sizeof(data));
  close(fd);
  if (l<4) return;//Failure or suspiciously short
  static const float pg_size_in_kb = sysconf(_SC_PAGESIZE)/1024.0;
  //Assume that the first field is vmem and the second is rss.
  vmem=atoi(data)*pg_size_in_kb;
  if (vmemonly)
    return;
  for (unsigned i=0;i+1<sizeof(data);++i)
    if (data[i]==' ') {
      rss=atoi(&(data[i+1]))*pg_size_in_kb;
      return;
    }
#endif
}

get_wall_ms()

double PMonSD::get_wall_ms ( )

inline

Definition at line 628 of file SemiDetMisc.h.

{
  //don't care about timezone since we will just be doing differences
  //(ignore daylight savings issues...). Like clock() it returns 0.0
  //on first call in a process.
  double t=get_absolute_wall_ms();
  static const double offset = [&]() {
    return t;
  }();
  return t-offset;
}

jobstart_jiffy2unix_ms()

double PMonSD::jobstart_jiffy2unix_ms ( const std::string &  s )

inline

Definition at line 426 of file SemiDetMisc.h.

                                                           {
    const double d=strtod(&(s[0]),0); if (d<=0.) return 0;
    const unsigned long b=system_boot_time_seconds(); if (!b) return  0;
    const double spj = secs_per_jiffy(); if (!spj) return 0;
    return 1000.0*(d*spj+b);
  }

secs_per_jiffy()

double PMonSD::secs_per_jiffy ( )

inline

Definition at line 412 of file SemiDetMisc.h.

  {
#ifdef __linux
    //tick will almost certainly be one of 100, 250, 300 or 1000
    //depending on the kernel configuration (USER_HZ).
    long tick=sysconf(_SC_CLK_TCK);
    if (tick>=1&&tick<1000000)
      return 1.0/tick;
#endif
    //Fall-back to getting it the hard way:
    clock_t t0=clock(); clock_t t1=t0;  while (t1==t0) t1=clock();
    return double(t1-t0)/CLOCKS_PER_SEC;
  }

setUTCTimeString()

void PMonSD::setUTCTimeString ( std::string &  s, double  offset_ms = 0  )

inline

Definition at line 611 of file SemiDetMisc.h.

{
  //Encoded in ISO 8601 UTC time format. It can be decoded in python
  //(in a "naive" timezone unaware datetime object) with:
  //datetime.strptime(input,'%Y-%m-%dT%H:%M:%S+0000')
  time_t t = time(NULL);//unixtime in seconds
  if (offset_ms)
    t+=static_cast<time_t>(0.5+0.001*offset_ms);
  struct tm ptm;
  gmtime_r(&t, &ptm);
  s.clear();
  s.resize(26);
  size_t r = strftime(&(s[0]),25,"%Y-%m-%dT%H:%M:%S+0000",&ptm);
  if (r>0&&r<25) s.resize(r);
  else s="0000-00-00T00:00:00+0000";
}

symb2lib()

const char* PMonSD::symb2lib ( const char *  symbol, const char *  failstr = "unknown"  )

inline

Definition at line 433 of file SemiDetMisc.h.

                                                                                   {
    void * addr = dlsym(RTLD_DEFAULT,symbol);
    if (!addr) return failstr;
    Dl_info di;
    if (!dladdr(addr, &di)) return failstr;
    if (!di.dli_fname) return failstr;
    return di.dli_fname;
  }

system_boot_time_seconds()

unsigned long PMonSD::system_boot_time_seconds ( )

inline

Definition at line 384 of file SemiDetMisc.h.

  {
    FILE* file = fopen("/proc/stat", "r");
    if (!file)
      return 0;
    char line[32];
    while (fgets(line, 32, file) != NULL){
      if (strncmp(line, "btime ", 6) == 0) {
    unsigned long l;
    sscanf(&(line[6]),"%80lu",&l);
    fclose(file);
    return l;
      }
    }
    fclose(file);
    return 0;
  }

vmpeak()

unsigned PMonSD::vmpeak ( )

inline

Definition at line 302 of file SemiDetMisc.h.

  {
    FILE* file = fopen("/proc/self/status", "r");
    if (!file)
      return 0;
    unsigned result = 0;
    char line[256];
    while (fgets(line, 256, file) != NULL){
      if (strncmp(line, "VmPeak:", 7) == 0) {
    result=atoi(&(line[7]));
    break;
      }
    }
    fclose(file);
    return result;
  }