System::ProcessDescriptor Class Reference

#include </builds/gaudi/Gaudi/GaudiKernel/src/Lib/ProcessDescriptor.h>

Classes
class	ProcessHandle

Public Member Functions
	ProcessDescriptor ()
virtual	~ProcessDescriptor ()
long	query (long pid, InfoType fetch, PROCESS_BASIC_INFORMATION *info)
long	query (long pid, InfoType fetch, POOLED_USAGE_AND_LIMITS *info)
long	query (long pid, InfoType fetch, KERNEL_USER_TIMES *info)
long	query (long pid, InfoType fetch, QUOTA_LIMITS *info)
long	query (long pid, InfoType fetch, VM_COUNTERS *info)
long	query (long pid, InfoType fetch, IO_COUNTERS *info)
long	query (long pid, InfoType fetch, long *info)

Detailed Description

Provides access to process information

Author

M.Frank

Sebastien Ponce

Definition at line 117 of file ProcessDescriptor.h.

Constructor & Destructor Documentation

ProcessDescriptor()

System::ProcessDescriptor::ProcessDescriptor

(

)

Definition at line 374 of file ProcessDescriptor.cpp.

                                           {
#ifdef _WIN32
  static bool first = true;
  if ( first ) {
    first    = false;
    void* mh = ::LoadLibrary( "NTDll.dll" );
    if ( mh ) {
      NtApi::NtQueryInformationProcess =
          ( NtApi::__NtQueryInformationProcess )::GetProcAddress( (HINSTANCE)mh, "NtQueryInformationProcess" );
    }
  }
#endif
}

~ProcessDescriptor()

System::ProcessDescriptor::~ProcessDescriptor ( )

virtual

Definition at line 388 of file ProcessDescriptor.cpp.

{}

Member Function Documentation

query() [1/7]

long System::ProcessDescriptor::query	(	long	pid,
		InfoType	fetch,
		IO_COUNTERS *	info
	)

Definition at line 390 of file ProcessDescriptor.cpp.

                                                                                 {
  if ( info == 0 ) return 0;
  long status = 1;
 
  if ( fetch == IO ) {
#if defined( _WIN32 ) && WINVER >= 0x0400 // Windows NT
    ProcessHandle h( pid );
    status = NtApi::NtQueryInformationProcess( h.handle(), ProcessIoCounters, info, sizeof( IO_COUNTERS ), 0 );
    status = ( status == 0 ) ? 1 : 0;
#elif defined( _WIN32 ) // Windows 95,98...
#elif defined( __linux )
    linux_proc prc;
    readProcStat( processID( pid ), prc );
    rusage usage;
    getrusage( RUSAGE_SELF, &usage );
    info->ReadOperationCount  = usage.ru_inblock;
    info->WriteOperationCount = usage.ru_oublock;
    info->OtherOperationCount = 0;
    info->ReadTransferCount   = usage.ru_inblock;
    info->WriteTransferCount  = usage.ru_oublock;
    info->OtherTransferCount  = 0;
#else  // All Other
    if ( pid ) {}
#endif // End ALL OS
  }
  return status;
}

query() [2/7]

long System::ProcessDescriptor::query	(	long	pid,
		InfoType	fetch,
		KERNEL_USER_TIMES *	info
	)

Definition at line 610 of file ProcessDescriptor.cpp.

                                                                                       {
  if ( info == 0 ) return 0;
  long status = 1;
 
  if ( fetch == Times ) {
#if defined( _WIN32 ) && WINVER >= 0x0400 // Windows NT
    ProcessHandle h( pid );
    status = NtApi::NtQueryInformationProcess( h.handle(), ProcessTimes, info, sizeof( KERNEL_USER_TIMES ), 0 );
    status = ( status == 0 ) ? 1 : 0;
#elif defined( _WIN32 )  // Windows 95,98...
#elif defined( __linux ) // Linux
    static long long prc_start         = 0;
    bool             myself            = pid <= 0 || pid == ::getpid(); // avoid unnecessary calls to getpid if pid<0
    if ( myself && prc_start == 0 ) {                                   // called only once to set prc_start
      linux_proc prc;
      readProcStat( processID( pid ), prc );
      // prc.startup is in ticks since system start, need to offset for absolute time
      tms              tmsb;
      static long long offset =
          100 * static_cast<long long>( time( nullptr ) ) - static_cast<long long>( times( &tmsb ) );
      prc_start = ( prc.starttime + offset ) * TICK_TO_100NSEC;
    }
 
    if ( myself ) { // myself
      tms tmsb;
      times( &tmsb );
      info->UserTime   = tmsb.tms_utime * TICK_TO_100NSEC;
      info->KernelTime = tmsb.tms_stime * TICK_TO_100NSEC;
      info->CreateTime = prc_start;
    } else { // other process
      linux_proc prc;
      readProcStat( processID( pid ), prc );
      tms              tmsb;
      static long long offset =
          100 * static_cast<long long>( time( nullptr ) ) - static_cast<long long>( times( &tmsb ) );
 
      tms t;
      times( &t );
      info->UserTime   = t.tms_utime * TICK_TO_100NSEC;
      info->KernelTime = t.tms_stime * TICK_TO_100NSEC;
      info->CreateTime = ( prc.starttime + offset ) * TICK_TO_100NSEC;
    }
    info->ExitTime = 0;
 
    status = 1;
 
#elif defined( __APPLE__ )
    if ( pid ) {}
// FIXME (MCl): Make an alternative function get timing on OSX
// times() seems to cause a segmentation fault
#else // no /proc file system: assume sys_start for the first call
    tms              tmsb;
    static clock_t   sys_start = times( 0 );
    static long long offset    = 100 * long long( time( 0 ) ) - sys_start;
    clock_t          now       = times( &tmsb );
    info->CreateTime           = offset + now;
    info->UserTime             = tmsb.tms_utime;
    info->KernelTime           = tmsb.tms_stime;
    info->CreateTime *= TICK_TO_100NSEC;
    info->UserTime *= TICK_TO_100NSEC;
    info->KernelTime *= TICK_TO_100NSEC;
    info->ExitTime = 0;
    status         = 1;
#endif
  }
 
  return status;
}

query() [3/7]

long System::ProcessDescriptor::query	(	long	pid,
		InfoType	fetch,
		long *	info
	)

Definition at line 461 of file ProcessDescriptor.cpp.

                                                                          {
 
  if ( info == 0 ) return 0;
  long status = 1;
 
  switch ( fetch ) {
  case PriorityBoost:
#if defined( _WIN32 ) && WINVER >= 0x0400 // Windows NT
    ProcessHandle h( pid );
    status = NtApi::NtQueryInformationProcess( h.handle(), ProcessPriorityBoost, info, sizeof( long ), 0 );
#elif defined( _WIN32 ) // Windows 95,98...
    if ( pid ) {}
#else
    // Not applicable
    if ( pid > 0 ) status = 0; // to avoid compiler warning
    status                = 0;
    *info                 = 0;
#endif // End ALL OS
    status = ( status == 0 ) ? 1 : 0;
    break;
  default:
    status = -1;
    *info  = -1;
    break;
  }
  return status;
}

query() [4/7]

long System::ProcessDescriptor::query	(	long	pid,
		InfoType	fetch,
		POOLED_USAGE_AND_LIMITS *	info
	)

Definition at line 418 of file ProcessDescriptor.cpp.

                                                                                             {
  if ( info == 0 ) return 0;
  long status = 1;
 
  if ( fetch == Quota ) {
#if defined( _WIN32 ) && WINVER >= 0x0400 // Windows NT
    ProcessHandle h( pid );
    status = NtApi::NtQueryInformationProcess( h.handle(), ProcessPooledUsageAndLimits, info,
                                               sizeof( POOLED_USAGE_AND_LIMITS ), 0 );
    status = ( status == 0 ) ? 1 : 0;
#elif defined( _WIN32 )  // Windows 95,98...
#elif defined( __linux ) // Linux
    // rusage usage;
    // getrusage(RUSAGE_SELF, &usage);
    rlimit lim;
 
    getrlimit( RLIMIT_DATA, &lim );
    if ( lim.rlim_max == RLIM_INFINITY ) lim.rlim_max = 0xFFFFFFFF;
    info->PeakPagedPoolUsage = lim.rlim_cur;
    info->PagedPoolUsage     = lim.rlim_cur;
    info->PagedPoolLimit     = lim.rlim_max;
 
    getrlimit( RLIMIT_STACK, &lim );
    if ( lim.rlim_max == RLIM_INFINITY ) lim.rlim_max = 0xFFFFFFFF;
    info->PeakNonPagedPoolUsage = lim.rlim_cur;
    info->NonPagedPoolUsage     = lim.rlim_cur;
    info->NonPagedPoolLimit     = lim.rlim_max;
 
    linux_proc prc;
    readProcStat( processID( pid ), prc );
    info->PeakPagefileUsage = prc.rss * pg_size;
    info->PagefileUsage     = prc.rss * pg_size;
    info->PagefileLimit     = 0xFFFFFFFF;
#elif defined( __APPLE__ )
    if ( pid ) {}
#else  // All Other
    if ( pid ) {}
#endif // End ALL OS
  }
 
  return status;
}

query() [5/7]

long System::ProcessDescriptor::query	(	long	pid,
		InfoType	fetch,
		PROCESS_BASIC_INFORMATION *	info
	)

Definition at line 578 of file ProcessDescriptor.cpp.

                                                                                               {
  if ( info == 0 ) return 0;
  long status = 1;
 
  if ( fetch == ProcessBasics ) {
#if defined( _WIN32 ) && WINVER >= 0x0400 // Windows NT
    ProcessHandle h( pid );
    status = NtApi::NtQueryInformationProcess( h.handle(), ProcessBasicInformation, info,
                                               sizeof( PROCESS_BASIC_INFORMATION ), 0 );
    status = ( status == 0 ) ? 1 : 0;
#elif defined( _WIN32 )  // Windows 95,98...
#elif defined( __linux ) // Linux
    linux_proc prc;
    pid = processID( pid );
    readProcStat( pid, prc );
    info->ExitStatus     = 0;
    info->PebBaseAddress = (PPEB)prc.startcode;
    info->BasePriority   = 2 * 15 - prc.priority;
    // std::cout << "Base Priority=" << info->BasePriority << "|"
    // << prc.priority << std::endl;
    info->AffinityMask = prc.flags;
    // std::cout << "Flags        =" << info->AffinityMask << "|"
    // << prc.flags << std::endl;
    info->UniqueProcessId              = pid;
    info->InheritedFromUniqueProcessId = prc.ppid;
#else                    // All Other
    if ( pid ) {}
#endif                   // End ALL OS
  }
  return status;
}

query() [6/7]

long System::ProcessDescriptor::query	(	long	pid,
		InfoType	fetch,
		QUOTA_LIMITS *	info
	)

Definition at line 532 of file ProcessDescriptor.cpp.

                                                                                  {
  if ( info == 0 ) return 0;
  long status = 1;
 
  if ( fetch == Quota ) {
#if defined( _WIN32 ) && WINVER >= 0x0400 // Windows NT
    ProcessHandle h( pid );
    status = NtApi::NtQueryInformationProcess( h.handle(), ProcessQuotaLimits, info, sizeof( QUOTA_LIMITS ), 0 );
    status = ( status == 0 ) ? 1 : 0;
#elif defined( _WIN32 )  // Windows 95,98...
#elif defined( __linux ) // Linux
    // On linux all this stuff typically is not set
    // (ie. rlim_max=RLIM_INFINITY...)
 
    if ( pid > 0 && pid != ::getpid() ) return 0; // only possible for myself
 
    rlimit lim;
    getrlimit( RLIMIT_DATA, &lim );
    if ( lim.rlim_max == RLIM_INFINITY ) lim.rlim_max = 0xFFFFFFFF;
    info->PagedPoolLimit = lim.rlim_max;
 
    getrlimit( RLIMIT_STACK, &lim );
    if ( lim.rlim_max == RLIM_INFINITY ) lim.rlim_max = 0xFFFFFFFF;
    info->NonPagedPoolLimit     = lim.rlim_max;
    info->MinimumWorkingSetSize = 0;
 
    getrlimit( RLIMIT_RSS, &lim );
    if ( lim.rlim_max == RLIM_INFINITY ) lim.rlim_max = 0xFFFFFFFF;
    info->MaximumWorkingSetSize = lim.rlim_max;
 
    getrlimit( RLIMIT_AS, &lim );
    if ( lim.rlim_max == RLIM_INFINITY ) lim.rlim_max = 0xFFFFFFFF;
    info->PagefileLimit = lim.rlim_max;
 
    getrlimit( RLIMIT_CPU, &lim );
    if ( lim.rlim_max == RLIM_INFINITY ) lim.rlim_max = 0xFFFFFFFF;
    info->TimeLimit = lim.rlim_max;
#elif defined( __APPLE__ )
    if ( pid ) {}
#else  // All Other
    if ( pid ) {}
#endif // End ALL OS
  }
  return status;
}

query() [7/7]

long System::ProcessDescriptor::query	(	long	pid,
		InfoType	fetch,
		VM_COUNTERS *	info
	)

Definition at line 489 of file ProcessDescriptor.cpp.

                                                                                 {
  if ( info == 0 ) return 0;
  long status = 1;
 
  if ( fetch == Memory ) {
#if defined( _WIN32 ) && WINVER >= 0x0400 // Windows NT
    ProcessHandle h( pid );
    status = NtApi::NtQueryInformationProcess( h.handle(), ProcessVmCounters, info, sizeof( VM_COUNTERS ), 0 );
    status = ( status == 0 ) ? 1 : 0;
#elif defined( _WIN32 )  // Windows 95,98...
#elif defined( __linux ) // Linux
    const ssize_t bufsize = 1024;
    char          buf[bufsize];
    pid = processID( pid );
    sprintf( buf, "/proc/%ld/statm", pid );
    long    size, resident, share, trs, lrs, drs, dt;
    int     fd    = open( buf, O_RDONLY );
    ssize_t nread = read( fd, buf, bufsize );
    close( fd );
    if ( nread < bufsize && nread >= 0 ) buf[nread] = '\0';
    fd = sscanf( buf, "%ld %ld %ld %ld %ld %ld %ld", &size, &resident, &share, &trs, &drs, &lrs, &dt );
    linux_proc prc;
    readProcStat( pid, prc );
    info->PeakVirtualSize            = prc.vsize;
    info->VirtualSize                = prc.vsize;
    info->PeakWorkingSetSize         = resident * pg_size;
    info->WorkingSetSize             = resident * pg_size;
    info->QuotaPeakPagedPoolUsage    = share * pg_size;
    info->QuotaPagedPoolUsage        = share * pg_size;
    info->QuotaNonPagedPoolUsage     = ( trs + drs ) * pg_size; // drs = data/stack size
    info->QuotaPeakNonPagedPoolUsage = ( trs + drs ) * pg_size; // trs = VmExe size
    info->PageFaultCount             = prc.majflt + prc.minflt;
    info->PagefileUsage              = prc.vsize - resident * pg_size;
    info->PeakPagefileUsage          = prc.vsize - resident * pg_size;
#elif defined( __APPLE__ )
    if ( pid ) {}
#else  // All Other
    if ( pid ) {}
#endif // End ALL OS
  }
  return status;
}

---

The documentation for this class was generated from the following files:

• GaudiKernel/src/Lib/ProcessDescriptor.h
• GaudiKernel/src/Lib/ProcessDescriptor.cpp