System Namespace Reference

Typedefs
typedef void *	ImageHandle
	Definition of an image handle. More...
typedef void *	ProcessHandle
	Definition of the process handle. More...
typedef void *	ThreadHandle
	A Thread handle. More...

Enumerations
enum	ModuleType { UNKNOWN, SHAREDLIB, EXECUTABLE }
enum	InfoType {   NoFetch, RemainTime, Times, ProcessBasics,   PriorityBoost, Memory, Quota, System,   Modules, IO }
	Enumeration for fetching information. More...
enum	TimeType {   Year, Month, Day, Hour,   Min, Sec, milliSec, microSec,   nanoSec }
	Time type for conversion. More...

Functions
const std::string &	moduleName ()
	Get the name of the (executable/DLL) file without file-type. More...
const std::string &	moduleNameFull ()
	Get the full name of the (executable/DLL) file. More...
const ModuleType	moduleType ()
	Get type of the module. More...
ProcessHandle	processHandle ()
	Handle to running process. More...
ImageHandle	moduleHandle ()
	Handle to currently executed module. More...
ImageHandle	exeHandle ()
	Handle to the executable file running. More...
const std::string &	exeName ()
	Name of the executable file running. More...
const std::vector< std::string >	linkedModules ()
	Vector of names of linked modules. More...
void	setModuleHandle (ImageHandle handle)
	Attach module handle. More...
const std::string &	hostName ()
	Host name. More...
const std::string &	osName ()
	OS name. More...
const std::string &	osVersion ()
	OS version. More...
const std::string &	machineType ()
	Machine type. More...
const std::string &	accountName ()
	User login name. More...
long	numCmdLineArgs ()
	Number of arguments passed to the commandline. More...
long	argc ()
	Number of arguments passed to the commandline (==numCmdLineArgs()); just to match argv call... More...
const std::vector< std::string >	cmdLineArgs ()
	Command line arguments including executable name as arg[0] as vector of strings. More...
char **	argv ()
	char** command line arguments including executable name as arg[0]; You may not modify them! More...
const std::string	getEnv (const char *var)
	get a particular environment variable More...
const std::vector< std::string >	getEnv ()
	get all environment variables More...
int	setEnv (const std::string &name, const std::string &value, int overwrite=1)
	set an environment variables. More...
ThreadHandle	threadSelf ()
	thread handle "accessor" More...
longlong	adjustTime (TimeType typ, longlong timevalue)
	Convert time from OS native time to requested representation (Experts only) More...
longlong	ellapsedTime (TimeType typ=milliSec, InfoType fetch=Times, long pid=-1)
longlong	kernelTime (TimeType typ=milliSec, InfoType fetch=Times, long pid=-1)
longlong	userTime (TimeType typ=milliSec, InfoType fetch=Times, long pid=-1)
longlong	cpuTime (TimeType typ=milliSec, InfoType fetch=Times, long pid=-1)
longlong	remainingTime (TimeType typ=milliSec, InfoType fetch=Quota, long pid=-1)
longlong	creationTime (TimeType typ=milliSec, InfoType fetch=Times, long pid=-1)
longlong	systemStart (TimeType typ=Sec)
longlong	upTime (TimeType typ=Hour)
longlong	currentTime (TimeType typ=milliSec)
longlong	tickCount ()

Detailed Description

ModuleInfo: OS specific details to access at run-time the module configuration of the process.

M.Frank

Note: OS specific details as well as Gaudi details may not occur in this definition file, because this header is the used by both, the OS specific implementations and the gaudi specific implementation. Since e.g. IID is defined in both, this would lead automatically to complete comilation failures.....

Author

M.Frank

Note: OS specific details for process timing

Entrypoints:

• remainingTime returns the time the process could still execute
• ellapsedTime: returns ellapsed time since program start
• kernelTime: returns the amount of time the process has spent in kernel mode
• userTime: returns the amount of time the process has spent in user mode
• cpuTime: returns kernel+user time

On Windows NT Time is expressed as the amount of time that has elapsed since midnight on January 1, 1601 at Greenwich, England.

On Unix time is expressed as the amount of time that has elapsed since midnight on January 1, 1970 at Greenwich, England.

History :

+---------+----------------------------------------------+--------+
|    Date |                 Comment                      | Who    |
+---------+----------------------------------------------+--------+
| 11/11/00| Initial version.                             | MF     |
+---------+----------------------------------------------+--------+

Author

: M.Frank

Version

: 1.0

Typedef Documentation

ImageHandle

typedef void* System::ImageHandle

Definition of an image handle.

Definition at line 30 of file ModuleInfo.h.

ProcessHandle

typedef void* System::ProcessHandle

Definition of the process handle.

Definition at line 32 of file ModuleInfo.h.

ThreadHandle

typedef void* System::ThreadHandle

A Thread handle.

Definition at line 63 of file System.h.

Enumeration Type Documentation

InfoType

enum System::InfoType

Enumeration for fetching information.

Enumerator
NoFetch
RemainTime
Times
ProcessBasics
PriorityBoost
Memory
Quota
System
Modules
IO

Definition at line 18 of file SystemBase.h.

                  {   NoFetch, 
                      RemainTime, 
                      Times, 
                      ProcessBasics, 
                      PriorityBoost, 
                      Memory, 
                      Quota,
                      System, 
                      Modules, 
                      IO };

ModuleType

enum System::ModuleType

Enumerator
UNKNOWN
SHAREDLIB
EXECUTABLE

Definition at line 28 of file ModuleInfo.h.

{ UNKNOWN, SHAREDLIB, EXECUTABLE };

TimeType

enum System::TimeType

Time type for conversion.

Enumerator
Year
Month
Day
Hour
Min
Sec
milliSec
microSec
nanoSec

Definition at line 53 of file Timing.h.

{ Year, Month, Day, Hour, Min, Sec, milliSec, microSec, nanoSec };

Function Documentation

accountName()

const std::string & System::accountName

(

)

User login name.

Definition at line 88 of file System.cpp.

Referenced by Application::Application(), and Server_NI6008::Server_NI6008().

                                     {
  static std::string account = "";
  if ( account == "" ) {
    const char* acct = ::getlogin();
    if ( 0 == acct ) acct = ::getenv("LOGNAME");
    if ( 0 == acct ) acct = ::getenv("USER");
    account = (acct) ? acct : "Unknown";
  }
  return account;
}

adjustTime()

longlong System::adjustTime	(	TimeType	typ,
		longlong	timevalue
	)

Convert time from OS native time to requested representation (Experts only)

argc()

long System::argc

(

)

Number of arguments passed to the commandline (==numCmdLineArgs()); just to match argv call...

Number of arguments passed to the commandline.

Definition at line 105 of file System.cpp.

References cmdLineArgs().

                     {
  return cmdLineArgs().size();
}

argv()

char ** System::argv

(

)

char** command line arguments including executable name as arg[0]; You may not modify them!

Const char** command line arguments including executable name as arg[0].

added by I.B.

Definition at line 134 of file System.cpp.

References cmdLineArgs(), and s_argvChars.

                       {
  if( s_argvChars.empty() ) { cmdLineArgs(); }  
  // We rely here on the fact that a vector's allocation table is contiguous
  return (char**)&s_argvChars[0];
}

cmdLineArgs()

const std::vector< std::string > System::cmdLineArgs

(

)

Command line arguments including executable name as arg[0] as vector of strings.

Const char** command line arguments including executable name as arg[0].

Definition at line 110 of file System.cpp.

References exeName(), s_argvChars, and s_argvStrings.

Referenced by argc(), argv(), and numCmdLineArgs().

                                                  {
  if ( s_argvChars.size() == 0 )    {
    char exe[1024];
    sprintf(exe, "/proc/%d/cmdline", ::getpid());
    FILE *cmdLine = ::fopen(exe,"r");
    char cmd[1024];
    if ( cmdLine )   {
      long len = fread(cmd, sizeof(char), sizeof(cmd), cmdLine);
      if ( len > 0 )   {
        cmd[len] = 0;
        for ( char* token = cmd; token-cmd < len; token += strlen(token)+1 )  {
          s_argvStrings.push_back(token);
          s_argvChars.push_back( s_argvStrings.back().c_str());
        }
        s_argvStrings[0] = exeName();
        s_argvChars[0]   = s_argvStrings[0].c_str();
      }
    }
    ::fclose(cmdLine);
  }
  return s_argvStrings;
}

cpuTime()

longlong System::cpuTime	(	TimeType	typ = milliSec,
		InfoType	fetch = Times,
		long	pid = -1
	)

Consumed CPU time of process in milli seconds.

Parameters

typ	Indicator or the unit the time will be returned.
fetch	Indicator of the information to be fetched. If Fetch_None, the information will not be updated.
pid	Process ID of which the information will be returned

Returns

Requested value in the indicated units.

creationTime()

longlong System::creationTime	(	TimeType	typ = milliSec,
		InfoType	fetch = Times,
		long	pid = -1
	)

Process Creation time.

Parameters

typ	Indicator or the unit the time will be returned.
fetch	Indicator of the information to be fetched. If Fetch_None, the information will not be updated.
pid	Process ID of which the information will be returned

Returns

Requested value in the indicated units.

currentTime()

longlong System::currentTime

(

TimeType

typ = milliSec

)

Retrieve absolute system time

Parameters

typ	Indicator or the unit the time will be returned.

Returns

Requested value in the indicated units.

ellapsedTime()

longlong System::ellapsedTime	(	TimeType	typ = milliSec,
		InfoType	fetch = Times,
		long	pid = -1
	)

Ellapsed time since start of process in milli seconds.

Parameters

typ	Indicator or the unit the time will be returned.
timevalue	Time value to be converted.

Returns

Requested value in the indicated units.

exeHandle()

System::ImageHandle System::exeHandle

(

)

Handle to the executable file running.

Definition at line 152 of file ModuleInfo.cpp.

References ModuleHandle, and processHandle().

Referenced by exeName().

                                       {
#ifdef WIN32
  if ( processHandle() )    {
    static HINSTANCE handle = 0;
    DWORD   cbNeeded;
    if ( 0 == handle && _psApi.isValid() )    {
      if ( _psApi.EnumProcessModules( processHandle(), &handle, sizeof(ModuleHandle), &cbNeeded) )   {
      }
    }
    return handle;
  }
#elif defined(linux) || defined(__APPLE__)
  // This does NOT work!
  static Dl_info infoBuf, *info = &infoBuf;
  if ( 0 == info ) {
    void* handle = ::dlopen(0, RTLD_LAZY);
    //printf("Exe handle:%X\n", handle);
    if ( 0 != handle ) {
      void* func = ::dlsym(handle, "main");
      //printf("Exe:Func handle:%X\n", func);
      if ( 0 != func ) {
        if ( 0 != ::dladdr(func, &infoBuf) ) {
            //std::cout << "All OK" << std::endl;
          info = &infoBuf;
        }
      }
    }
  }
  return info;
#elif __hpux
  // Don't know how to solve this .....
#endif
  return 0;
}

exeName()

const std::string & System::exeName

(

)

Name of the executable file running.

Definition at line 187 of file ModuleInfo.cpp.

References exeHandle(), and processHandle().

Referenced by cmdLineArgs().

                                    {
  static std::string module("");
  if ( module.length() == 0 )    {
    char name[512] = {"Unknown.module"};
    name[0] = 0;
#ifdef WIN32
    if ( _psApi.isValid() && processHandle() )   {
      _psApi.GetModuleFileNameExA( processHandle(), (HINSTANCE)exeHandle(), name,sizeof(name) );
    }
#elif defined(linux) || defined(__APPLE__)
    char cmd[512];
    ::sprintf(cmd, "/proc/%d/exe", ::getpid());
    module = "Unknown";
    ::readlink(cmd, name, sizeof(name));
#elif __hpux
    ::realpath(((HMODULE*)exeHandle())->dsc.filename, name);
#endif
    module = name;
  }
  return module;
}

getEnv() [1/2]

const std::string System::getEnv

(

const char *

var

)

get a particular environment variable

get a particular env var, return "UNKNOWN" if not defined

Definition at line 143 of file System.cpp.

Referenced by Application::bookkeeping(), and Application::loadHistoryFile().

                                              {
  char* env;
  if  ( (env = getenv(var)) != 0 ) {
    return env;
  } else {
    return "UNKNOWN";
  }
}

getEnv() [2/2]

const std::vector< std::string > System::getEnv

(

)

get all environment variables

get all defined environment vars

Definition at line 153 of file System.cpp.

References environ.

                                          {
  std::vector<std::string> vars;
  for (int i=0; environ[i] != 0; ++i) {
    vars.push_back(environ[i]);
  }
  return vars;
}

hostName()

const std::string & System::hostName

(

)

Host name.

Definition at line 39 of file System.cpp.

Referenced by Application::Application(), Computer::Computer(), and Server_NI6008::Server_NI6008().

                                  {
  static std::string host = "";
  if ( host == "" ) {
    char buffer[512];
    memset(buffer,0,sizeof(buffer));
    ::gethostname(buffer, sizeof(buffer));
    host = buffer;
  }
  return host;
}

kernelTime()

longlong System::kernelTime	(	TimeType	typ = milliSec,
		InfoType	fetch = Times,
		long	pid = -1
	)

CPU kernel mode time of process in milli seconds.

Parameters

typ	Indicator or the unit the time will be returned.
fetch	Indicator of the information to be fetched. If Fetch_None, the information will not be updated.
pid	Process ID of which the information will be returned

Returns

Requested value in the indicated units.

linkedModules()

const std::vector< std::string > System::linkedModules

(

)

Vector of names of linked modules.

Definition at line 209 of file ModuleInfo.cpp.

References processHandle(), and s_linkedModules.

                                                    {
  if ( s_linkedModules.size() == 0 )    {
#ifdef WIN32
    char   name[255];  // Maximum file name length on NT 4.0
    DWORD  cbNeeded;
    HINSTANCE handle[1024];
    if ( _psApi.isValid() )    {
      if ( _psApi.EnumProcessModules(processHandle(),handle,sizeof(handle),&cbNeeded) )   {
        for (size_t i = 0; i < cbNeeded/sizeof(HANDLE); i++ )    {
          if ( 0 < _psApi.GetModuleFileNameExA( processHandle(), handle[i], name, sizeof(name)) )   {
            s_linkedModules.push_back(name);
          }
        }
      }
    }
#elif defined(linux) || defined(__APPLE__)
    char ff[512], cmd[1024], fname[1024], buf1[64], buf2[64], buf3[64], buf4[64];
    ::sprintf(ff, "/proc/%d/maps", ::getpid());
    FILE* maps = ::fopen(ff, "r");
    while( ::fgets(cmd, sizeof(cmd), maps) ) {
      int len;
      sscanf(cmd, "%s %s %s %s %d %s", buf1, buf2, buf3, buf4, &len, fname);
      if ( len > 0 && strncmp(buf2,"r-xp",strlen("r-xp")) == 0 ) {
        s_linkedModules.push_back(fname);
      }
    }
    ::fclose(maps);
#endif
  }
  return s_linkedModules;
}

machineType()

const std::string & System::machineType

(

)

Machine type.

Definition at line 76 of file System.cpp.

                                     {
  static std::string mach = "";
  struct utsname ut;
  if (uname(&ut) == 0) {
    mach = ut.machine;
  } else {
    mach = "UNKNOWN";
  }
  return mach;
}

moduleHandle()

System::ImageHandle System::moduleHandle

(

)

Handle to currently executed module.

Definition at line 128 of file ModuleInfo.cpp.

References ModuleHandle, and processHandle().

Referenced by moduleName(), and moduleNameFull().

                                          {
  if ( 0 == ModuleHandle )    {
    if ( processHandle() )    {
#ifdef WIN32
      static HINSTANCE handle = 0;
      DWORD   cbNeeded;
      if ( 0 == handle && _psApi.isValid() )    {
        if ( _psApi.EnumProcessModules( processHandle(), &handle, sizeof(ModuleHandle), &cbNeeded) )   {
        }
      }
      return handle;
#elif defined(linux) || defined(__APPLE__)
      static Dl_info info;
      if ( 0 != ::dladdr((void*)System::moduleHandle, &info) ) {
    return &info;
      }
#elif __hpux
      return 0;  // Don't know how to solve this .....
#endif
    }
  }
  return ModuleHandle;
}

moduleName()

const std::string & System::moduleName

(

)

Get the name of the (executable/DLL) file without file-type.

Retrieve base name of module.

Definition at line 47 of file ModuleInfo.cpp.

References moduleHandle(), and processHandle().

                                      {
  static std::string module("");
  if ( module == "" )   {
    if ( processHandle() && moduleHandle() )    {
#ifdef WIN32
      char moduleName[256] = {"Unknown.module"};
      moduleName[0] = 0;
      if ( _psApi.isValid() )   {
        _psApi.GetModuleBaseNameA( processHandle(), (HINSTANCE)moduleHandle(), moduleName, sizeof(moduleName) );
      }
      std::string mod = moduleName;
#elif defined(__linux__) || defined(linux)
      std::string mod = ::basename((char*)((Dl_info*)moduleHandle())->dli_fname);
#elif __hpux
      std::string mod = ::basename(((HMODULE*)moduleHandle())->dsc.filename);
#endif
      module = mod.substr(0, mod.rfind('.'));
    }
  }
  return module;
} 

moduleNameFull()

const std::string & System::moduleNameFull

(

)

Get the full name of the (executable/DLL) file.

Retrieve full name of module.

Definition at line 70 of file ModuleInfo.cpp.

References moduleHandle(), and processHandle().

Referenced by moduleType().

                                          {
  static std::string module("");
  if ( module == "" )   {
    if ( processHandle() && moduleHandle() )    {
      char name[512] = {"Unknown.module"};
      name[0] = 0;
#ifdef WIN32
      if ( _psApi.isValid() )   {
        _psApi.GetModuleFileNameExA( processHandle(), (HINSTANCE)moduleHandle(), name,sizeof(name) );
      }
#elif defined(linux) || defined(__APPLE__)
      ::realpath(((Dl_info*)moduleHandle())->dli_fname, name);
#elif __hpux
      ::realpath(((HMODULE*)moduleHandle())->dsc.filename, name);
#endif
      module = name;
    }
  }
  return module;
}

moduleType()

const System::ModuleType System::moduleType

(

)

Get type of the module.

Definition at line 92 of file ModuleInfo.cpp.

References EXECUTABLE, moduleNameFull(), SHAREDLIB, and UNKNOWN.

                                            {
  static ModuleType type = UNKNOWN;
  if ( type == UNKNOWN )    {
    const std::string& module = moduleNameFull();
    int loc = module.rfind('.')+1;
    if ( loc == 0 )
      type = EXECUTABLE;
    else if ( module[loc] == 'e' || module[loc] == 'E' )
      type = EXECUTABLE;
#ifdef WIN32
    else if ( module[loc] == 'd' || module[loc] == 'D' )
#else
    else if ( module[loc] == 's' && module[loc+1] == 'o' )
#endif
      type = SHAREDLIB;
    else
      type = UNKNOWN;
  }
  return type;
}

numCmdLineArgs()

long System::numCmdLineArgs

(

)

Number of arguments passed to the commandline.

Definition at line 100 of file System.cpp.

References cmdLineArgs().

                              {
  return cmdLineArgs().size();
}

osName()

const std::string & System::osName

(

)

OS name.

Definition at line 51 of file System.cpp.

Referenced by Application::Application(), and Server_NI6008::Server_NI6008().

                                {
  static std::string osname = "";
  struct utsname ut;
  if (uname(&ut) == 0) {
    osname = ut.sysname;
  } else {
    osname = "UNKNOWN";
  }
  return osname;
}

osVersion()

const std::string & System::osVersion

(

)

OS version.

Definition at line 64 of file System.cpp.

Referenced by Application::Application(), and Server_NI6008::Server_NI6008().

                                   {
  static std::string osver = "";
  struct utsname ut;
  if (uname(&ut) == 0) {
    osver = ut.release;
  } else {
    osver = "UNKNOWN";
  }
  return osver;
}

processHandle()

void * System::processHandle

(

)

Handle to running process.

Retrieve processhandle.

Definition at line 114 of file ModuleInfo.cpp.

References FALSE.

Referenced by exeHandle(), exeName(), linkedModules(), moduleHandle(), moduleName(), and moduleNameFull().

                              {
  static long pid = ::getpid();
#ifdef WIN32
  static HANDLE hP = ::OpenProcess(PROCESS_QUERY_INFORMATION|PROCESS_VM_READ,FALSE,pid);
#else
  static void* hP = (void*)pid;
#endif
  return hP;
}

remainingTime()

longlong System::remainingTime	(	TimeType	typ = milliSec,
		InfoType	fetch = Quota,
		long	pid = -1
	)

Maximum processing time left for this process.

Parameters

typ	Indicator or the unit the time will be returned.
fetch	Indicator of the information to be fetched. If Fetch_None, the information will not be updated.
pid	Process ID of which the information will be returned

Returns

Requested value in the indicated units.

setEnv()

int System::setEnv	(	const std::string &	name,
		const std::string &	value,
		int	overwrite = 1
	)

set an environment variables.

Set an environment variables. If value is empty, the variable is removed from the environment. When overwrite is 0, the variable is not set if already present. Returns 0 on success, -1 on failure. See man 3 setenv.

Returns

0 if successful, -1 if not

Definition at line 162 of file System.cpp.

{
  // UNIX version
  return value.empty() ?
    // remove if set to nothing (and return success)
    ::unsetenv(name.c_str()) , 0 :
    // set the value
    ::setenv(name.c_str(),value.c_str(), overwrite);
}

setModuleHandle()

void System::setModuleHandle

(

System::ImageHandle

handle

)

Attach module handle.

Definition at line 124 of file ModuleInfo.cpp.

References ModuleHandle.

                                                        {
  ModuleHandle = handle;
}

systemStart()

longlong System::systemStart

(

TimeType

typ = Sec

)

Maximum processing time left for this process.

Parameters

typ	Indicator or the unit the time will be returned.

Returns

Requested value in the indicated units.

threadSelf()

ThreadHandle System::threadSelf ( )

inline

thread handle "accessor"

Definition at line 65 of file System.h.

{ return (void*)0; }

tickCount()

longlong System::tickCount

(

)

Retrieve the number of ticks since system startup

Returns

Requested value in the indicated units.

upTime()

longlong System::upTime

(

TimeType

typ = Hour

)

Maximum processing time left for this process.

Parameters

typ	Indicator or the unit the time will be returned.

Returns

Requested value in the indicated units.

userTime()

longlong System::userTime	(	TimeType	typ = milliSec,
		InfoType	fetch = Times,
		long	pid = -1
	)

CPU user mode time of process in milli seconds.

Parameters

typ	Indicator or the unit the time will be returned.
fetch	Indicator of the information to be fetched. If Fetch_None, the information will not be updated.
pid	Process ID of which the information will be returned

Returns

Requested value in the indicated units.