System::ProcessDescriptor Class Reference

#include <ProcessDescriptor.h>

Collaboration diagram for System::ProcessDescriptor:

[legend]

List of all members.

Detailed Description

Provides access to process information.

Author:: M.Frank
Sebastien Ponce

Definition at line 110 of file ProcessDescriptor.h.


Public Member Functions
	ProcessDescriptor ()
virtual	~ProcessDescriptor ()
long	query (long pid, InfoType info, PROCESS_BASIC_INFORMATION *buffer)
long	query (long pid, InfoType info, POOLED_USAGE_AND_LIMITS *buffer)
long	query (long pid, InfoType info, KERNEL_USER_TIMES *buffer)
long	query (long pid, InfoType info, QUOTA_LIMITS *buffer)
long	query (long pid, InfoType info, VM_COUNTERS *buffer)
long	query (long pid, InfoType info, IO_COUNTERS *buffer)
long	query (long pid, InfoType info, long *buffer)
Private Attributes
long	m_PRIORITYBOOST [2]
IO_COUNTERS	m_IO_COUNTERS [2]
VM_COUNTERS	m_VM_COUNTERS [2]
KERNEL_USER_TIMES	m_KERNEL_USER_TIMES [2]
POOLED_USAGE_AND_LIMITS	m_POOLED_USAGE_AND_LIMITS [2]
QUOTA_LIMITS	m_QUOTA_LIMITS [2]
PROCESS_BASIC_INFORMATION	m_PROCESS_BASIC_INFORMATION [2]
Classes
class	ProcessHandle

Constructor & Destructor Documentation

System::ProcessDescriptor::ProcessDescriptor ( )

Definition at line 256 of file ProcessDescriptor.cpp.

00257 {
00258 }

System::ProcessDescriptor::~ProcessDescriptor ( ) [virtual]

Definition at line 260 of file ProcessDescriptor.cpp.

00260                                               {
00261 }

Member Function Documentation

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

Definition at line 463 of file ProcessDescriptor.cpp.

00465                                                                           {
00466   long status = 1;
00467   ProcessHandle h(pid);
00468   PROCESS_BASIC_INFORMATION* vb = &m_PROCESS_BASIC_INFORMATION[h.item()];
00469   if ( fetch == ProcessBasics )   {
00470 #if defined(_WIN32) && WINVER>=0x0400     // Windows NT
00471     status = NtApi::NtQueryInformationProcess(h.handle(),
00472                                               ProcessBasicInformation,
00473                                               vb,
00474                                               sizeof(PROCESS_BASIC_INFORMATION),
00475                                               0);
00476     status = (status==0) ? 1 : 0;
00477 #elif _WIN32                              // Windows 95,98...
00478 #elif defined(linux)                      // Linux
00479     linux_proc prc;
00480     readProcStat( processID(pid), prc);
00481     vb->ExitStatus                   = 0;
00482     vb->PebBaseAddress               = (PPEB)prc.startcode;
00483     vb->BasePriority                 = 2*15-prc.priority;
00484     // std::cout << "Base Priority=" << vb->BasePriority << "|"
00485     // << prc.priority << std::endl;
00486     vb->AffinityMask                 = prc.flags;
00487     // std::cout << "Flags        =" << vb->AffinityMask << "|"
00488     // << prc.flags << std::endl;
00489     vb->UniqueProcessId              = processID(pid);
00490     vb->InheritedFromUniqueProcessId = prc.ppid;
00491 #else                                     // All Other
00492 #endif                                    // End ALL OS
00493   }
00494   if ( info ) *info = *vb;
00495   return status;
00496 }

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

Definition at line 296 of file ProcessDescriptor.cpp.

00298                                                                         {
00299   long status = 1;
00300   ProcessHandle h(pid);
00301   POOLED_USAGE_AND_LIMITS* vb = &m_POOLED_USAGE_AND_LIMITS[h.item()];
00302   if ( fetch == Quota )   {
00303 #if defined(_WIN32) && WINVER>=0x0400     // Windows NT
00304     status = NtApi::NtQueryInformationProcess(h.handle(),
00305                                               ProcessPooledUsageAndLimits,
00306                                               vb,
00307                                               sizeof(POOLED_USAGE_AND_LIMITS),
00308                                               0);
00309     status = (status==0) ? 1 : 0;
00310 #elif _WIN32                              // Windows 95,98...
00311 #elif defined(linux)                      // Linux
00312     //rusage usage;
00313     //getrusage(RUSAGE_SELF, &usage);
00314     rlimit lim;
00315 
00316     getrlimit(RLIMIT_DATA, &lim);
00317     if ( lim.rlim_max == RLIM_INFINITY ) lim.rlim_max = 0xFFFFFFFF;
00318     vb->PeakPagedPoolUsage = lim.rlim_cur;
00319     vb->PagedPoolUsage     = lim.rlim_cur;
00320     vb->PagedPoolLimit     = lim.rlim_max;
00321 
00322     getrlimit(RLIMIT_STACK, &lim);
00323     if ( lim.rlim_max == RLIM_INFINITY ) lim.rlim_max = 0xFFFFFFFF;
00324     vb->PeakNonPagedPoolUsage = lim.rlim_cur;
00325     vb->NonPagedPoolUsage     = lim.rlim_cur;
00326     vb->NonPagedPoolLimit     = lim.rlim_max;
00327 
00328     linux_proc prc;
00329     readProcStat(processID(pid), prc);
00330     vb->PeakPagefileUsage     = prc.rss * pg_size;
00331     vb->PagefileUsage         = prc.rss * pg_size;
00332     vb->PagefileLimit         = 0xFFFFFFFF;
00333 #elif defined(__APPLE__)
00334 #else                                     // All Other
00335 #endif                                    // End ALL OS
00336   }
00337   if ( info ) *info = *vb;
00338   return status;
00339 }

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

Definition at line 498 of file ProcessDescriptor.cpp.

00500                                                                  {
00501   long status = 1;
00502   ProcessHandle h(pid);
00503   KERNEL_USER_TIMES* tb = &m_KERNEL_USER_TIMES[h.item()];;
00504   if ( fetch == Times )   {
00505 #if defined(_WIN32) && WINVER>=0x0400     // Windows NT
00506     status = NtApi::NtQueryInformationProcess(h.handle(),
00507                                               ProcessTimes,
00508                                               tb,
00509                                               sizeof(KERNEL_USER_TIMES),
00510                                               0);
00511     status = (status==0) ? 1 : 0;
00512 #elif defined(_WIN32)                     // Windows 95,98...
00513 #elif defined(linux)                      // Linux
00514     // prc.startup is in ticks since system start :
00515     // need to offset for absolute time
00516     tms tmsb;
00517     static longlong prc_start = 0;
00518     //    static longlong offset = 100*longlong(time(0)) - longlong(times(0));
00519     static longlong offset = 100*longlong(time(0)) - longlong(times(&tmsb));
00520     if ( processID(pid) == s_myPid && prc_start == 0 ) {
00521       linux_proc prc;
00522       readProcStat( processID(pid), prc);
00523       prc_start = prc.starttime+offset;
00524     }
00525 
00526     if ( processID(pid) == s_myPid ) {
00527       struct rusage r;
00528       getrusage( RUSAGE_SELF, &r );
00529       const double utime = static_cast<double>(r.ru_utime.tv_sec )*1e6 +
00530                            static_cast<double>(r.ru_utime.tv_usec);
00531       const double stime = static_cast<double>(r.ru_stime.tv_sec )*1e6 +
00532                            static_cast<double>(r.ru_stime.tv_usec);
00533       tb->UserTime   = static_cast<longlong>( utime * 10. );
00534       tb->KernelTime = static_cast<longlong>( stime * 10. );
00535       tb->CreateTime = prc_start;
00536     }
00537     else {
00538       linux_proc prc;
00539       readProcStat( processID(pid), prc );
00540 
00541       tms t;
00542       times(&t);
00543       tb->UserTime   = t.tms_utime * TICK_TO_100NSEC;
00544       tb->KernelTime = t.tms_stime * TICK_TO_100NSEC;
00545       tb->CreateTime = (prc.starttime+offset);
00546     }
00547     tb->CreateTime *= TICK_TO_100NSEC;
00548     tb->ExitTime    = 0;
00549 
00550     status = 1;
00551 
00552 #elif defined(__APPLE__)
00553     // FIXME (MCl): Make an alternative function get timing on OSX
00554     // times() seems to cause a segmentation fault 
00555 #else  // no /proc file system: assume sys_start for the first call
00556     tms tmsb;
00557     static clock_t sys_start = times(0);
00558     static longlong offset = 100*longlong(time(0)) - sys_start;
00559     clock_t now = times(&tmsb);
00560     tb->CreateTime    = offset + now;
00561     tb->UserTime      = tmsb.tms_utime;
00562     tb->KernelTime    = tmsb.tms_stime;
00563     tb->CreateTime   *= TICK_TO_100NSEC;
00564     tb->UserTime     *= TICK_TO_100NSEC;
00565     tb->KernelTime   *= TICK_TO_100NSEC;
00566     tb->ExitTime      = 0;
00567     status = 1;
00568 #endif
00569   }
00570   if ( info ) *info = *tb;
00571   return status;
00572 }

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

Definition at line 416 of file ProcessDescriptor.cpp.

00418                                                              {
00419   long status = 1;
00420   ProcessHandle h(pid);
00421   QUOTA_LIMITS* vb = &m_QUOTA_LIMITS[h.item()];
00422   if ( fetch == Quota )   {
00423 #if defined(_WIN32) && WINVER>=0x0400     // Windows NT
00424     status = NtApi::NtQueryInformationProcess(h.handle(),
00425                                               ProcessQuotaLimits,
00426                                               vb,
00427                                               sizeof(QUOTA_LIMITS),
00428                                               0);
00429     status = (status==0) ? 1 : 0;
00430 #elif _WIN32                              // Windows 95,98...
00431 #elif defined(linux)                      // Linux
00432     // On linux all this stuff typically is not set
00433     // (ie. rlim_max=RLIM_INFINITY...)
00434     rlimit lim;
00435     getrlimit(RLIMIT_DATA, &lim);
00436     if ( lim.rlim_max == RLIM_INFINITY ) lim.rlim_max = 0xFFFFFFFF;
00437     vb->PagedPoolLimit        = lim.rlim_max;
00438 
00439     getrlimit(RLIMIT_STACK, &lim);
00440     if ( lim.rlim_max == RLIM_INFINITY ) lim.rlim_max = 0xFFFFFFFF;
00441     vb->NonPagedPoolLimit     = lim.rlim_max;
00442     vb->MinimumWorkingSetSize = 0;
00443 
00444     getrlimit(RLIMIT_RSS, &lim);
00445     if ( lim.rlim_max == RLIM_INFINITY ) lim.rlim_max = 0xFFFFFFFF;
00446     vb->MaximumWorkingSetSize = lim.rlim_max;
00447 
00448     getrlimit(RLIMIT_AS, &lim);
00449     if ( lim.rlim_max == RLIM_INFINITY ) lim.rlim_max = 0xFFFFFFFF;
00450     vb->PagefileLimit         = lim.rlim_max;
00451 
00452     getrlimit(RLIMIT_CPU, &lim);
00453     if ( lim.rlim_max == RLIM_INFINITY ) lim.rlim_max = 0xFFFFFFFF;
00454     vb->TimeLimit             = lim.rlim_max;
00455 #elif defined(__APPLE__)
00456 #else                                     // All Other
00457 #endif                                    // End ALL OS
00458   }
00459   if ( info ) *info = *vb;
00460   return status;
00461 }

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

Definition at line 371 of file ProcessDescriptor.cpp.

00373                                                             {
00374   long status = 1;
00375   ProcessHandle h(pid);
00376   VM_COUNTERS* vb = &m_VM_COUNTERS[h.item()];
00377   if ( fetch == Memory )   {
00378 #if defined(_WIN32) && WINVER>=0x0400     // Windows NT
00379     status = NtApi::NtQueryInformationProcess(h.handle(),
00380                                               ProcessVmCounters,
00381                                               vb,
00382                                               sizeof(VM_COUNTERS),
00383                                               0);
00384     status = (status==0) ? 1 : 0;
00385 #elif _WIN32                              // Windows 95,98...
00386 #elif defined(linux)                      // Linux
00387     char buf[1024];
00388     sprintf(buf,"/proc/%ld/statm", processID(pid));
00389     long size, resident, share, trs, lrs, drs, dt;
00390     int fd = open(buf,O_RDONLY);
00391     read(fd, buf, sizeof(buf));  
00392     close(fd);
00393     fd = sscanf(buf, "%ld %ld %ld %ld %ld %ld %ld",
00394                      &size, &resident, &share, &trs, &drs, &lrs, &dt);
00395     linux_proc prc;
00396     readProcStat( processID(pid), prc);
00397     vb->PeakVirtualSize            = prc.vsize;
00398     vb->VirtualSize                = prc.vsize;
00399     vb->PeakWorkingSetSize         = resident * pg_size;
00400     vb->WorkingSetSize             = resident * pg_size;
00401     vb->QuotaPeakPagedPoolUsage    = share    * pg_size;
00402     vb->QuotaPagedPoolUsage        = share    * pg_size;
00403     vb->QuotaNonPagedPoolUsage     = (trs+drs)* pg_size;// drs = data/stack size
00404     vb->QuotaPeakNonPagedPoolUsage = (trs+drs)* pg_size;// trs = VmExe size
00405     vb->PageFaultCount             = prc.majflt + prc.minflt;
00406     vb->PagefileUsage              = prc.vsize-resident*pg_size;
00407     vb->PeakPagefileUsage          = prc.vsize-resident*pg_size;
00408 #elif defined(__APPLE__)
00409 #else                                     // All Other
00410 #endif                                    // End ALL OS
00411   }
00412   if ( info ) *info = *vb;
00413   return status;
00414 }

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

Definition at line 263 of file ProcessDescriptor.cpp.

00265                                                          {
00266   long status = 1;
00267   ProcessHandle h(pid);
00268   IO_COUNTERS* vb = &m_IO_COUNTERS[h.item()];
00269   if ( fetch == IO )   {
00270 #if defined(_WIN32) && WINVER>=0x0400     // Windows NT
00271     status = NtApi::NtQueryInformationProcess(h.handle(),
00272                                               ProcessIoCounters,
00273                                               vb,
00274                                               sizeof(IO_COUNTERS),
00275                                               0);
00276     status = (status==0) ? 1 : 0;
00277 #elif _WIN32                              // Windows 95,98...
00278 #elif defined(linux)
00279     linux_proc prc;
00280     readProcStat(processID(pid), prc);
00281     rusage usage;
00282     getrusage(RUSAGE_SELF, &usage);
00283     vb->ReadOperationCount    = usage.ru_inblock;
00284     vb->WriteOperationCount   = usage.ru_oublock;
00285     vb->OtherOperationCount   = 0;
00286     vb->ReadTransferCount     = usage.ru_inblock;
00287     vb->WriteTransferCount    = usage.ru_oublock;
00288     vb->OtherTransferCount    = 0;
00289 #else                                     // All Other
00290 #endif                                    // End ALL OS
00291   }
00292   if ( info ) *info = *vb;
00293   return status;
00294 }

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

Definition at line 341 of file ProcessDescriptor.cpp.

00341                                                                            {
00342   long status = 1, *vb = &status;
00343   ProcessHandle h(pid);
00344   vb = &m_PRIORITYBOOST[h.item()];
00345   *vb = 0;
00346   switch ( fetch )    {
00347   case PriorityBoost:
00348 #if defined(_WIN32) && WINVER>=0x0400     // Windows NT
00349     status = NtApi::NtQueryInformationProcess(h.handle(),
00350                                               ProcessPriorityBoost,
00351                                               vb,
00352                                               sizeof(long),
00353                                               0);
00354 #elif _WIN32                              // Windows 95,98...
00355 #else
00356     // Not applicable
00357     status = 0;
00358     *vb = 0;
00359 #endif                                    // End ALL OS
00360     status = (status==0) ? 1 : 0;
00361     break;
00362   default:
00363     status = -1;
00364     vb = &status;
00365     break;
00366   }
00367   if ( info ) *info = *vb;
00368   return status;
00369 }

Member Data Documentation

long System::ProcessDescriptor::m_PRIORITYBOOST[2] [private]

Definition at line 124 of file ProcessDescriptor.h.

IO_COUNTERS System::ProcessDescriptor::m_IO_COUNTERS[2] [private]

Definition at line 125 of file ProcessDescriptor.h.

VM_COUNTERS System::ProcessDescriptor::m_VM_COUNTERS[2] [private]

Definition at line 126 of file ProcessDescriptor.h.

KERNEL_USER_TIMES System::ProcessDescriptor::m_KERNEL_USER_TIMES[2] [private]

Definition at line 127 of file ProcessDescriptor.h.

POOLED_USAGE_AND_LIMITS System::ProcessDescriptor::m_POOLED_USAGE_AND_LIMITS[2] [private]

Definition at line 128 of file ProcessDescriptor.h.

QUOTA_LIMITS System::ProcessDescriptor::m_QUOTA_LIMITS[2] [private]

Definition at line 129 of file ProcessDescriptor.h.

PROCESS_BASIC_INFORMATION System::ProcessDescriptor::m_PROCESS_BASIC_INFORMATION[2] [private]

Definition at line 130 of file ProcessDescriptor.h.

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

/afs/cern.ch/sw/Gaudi/releases/GAUDI/GAUDI_v21r6/GaudiKernel/src/Lib/ProcessDescriptor.h
/afs/cern.ch/sw/Gaudi/releases/GAUDI/GAUDI_v21r6/GaudiKernel/src/Lib/ProcessDescriptor.cpp

Gaudi Framework, version v21r6

System::ProcessDescriptor Class Reference

Detailed Description

Public Member Functions

Private Attributes

Classes

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation