| The Gaudi Framework v28r2p1 (f1a77ff4)

- Main Page
- Related Pages
- Modules
- Namespaces
- Classes
- Files

- File List
- File Members

Timing.cpp
Go to the documentation of this file.
1 //====================================================================
2 // Timing.cpp
3 //--------------------------------------------------------------------
4 //
5 // Package : System (The LHCb System service)
6 //
7 // Description: Implementation of Systems internals
8 //
9 // Author : M.Frank
10 // Created : 13/1/99
11 // Changes :
12 //====================================================================
13 #define GAUDIKERNEL_TIMING_CPP
14
15 #include "GaudiKernel/Timing.h"
16 #include "ProcessDescriptor.h"
17
18 #include <ctime>
19 #include <climits>
20 #ifdef _WIN32
21 #include <windows.h>
22 #else
23 #include <sys/time.h>
24 #include <sys/times.h>
25 #include <unistd.h>
26 #endif
27
28 #ifdef _WIN32
29 static const longlong UNIX_BASE_TIME = 116444736000000000;
30 #else
31 static const longlong UNIX_BASE_TIME = 0;
32 #endif
33
34 // convert time from internal representation to the appropriate type
35 // Internal representation for WIN32: 100 nanosecond intervals
36 // Unix: 1 clock tick (usually 10 milliseconds)
37 longlong System::adjustTime(TimeType typ, longlong t) {
38 if ( t != -1 ) {
39 #ifndef _WIN32
40 // t /= CLK_TCK ; // needs division by clock tick unit
45
47 #endif
48 switch( typ ) {
49 case Year : return adjustTime<Year >(t);
50 case Month : return adjustTime<Month >(t);
51 case Day : return adjustTime<Day >(t);
52 case Hour : return adjustTime<Hour >(t);
53 case Min : return adjustTime<Min >(t);
54 case Sec : return adjustTime<Sec >(t);
55 case milliSec: return adjustTime<milliSec>(t);
56 case microSec: return adjustTime<microSec>(t);
57 case nanoSec : return adjustTime<nanoSec >(t);
58 case Native : return adjustTime<Native >(t);
59 }
60 }
61 return t;
62 }
63
65 longlong System::tickCount() {
66 longlong count = 10000;
67 #ifdef _WIN32
68 count *= ::GetTickCount(); // Number of milliSec since system startup
69 #else
70 struct tms buf;
71 count *= 10*times(&buf);
72 #endif
73 return count;
74 }
75
76 #include <iostream>
77
79 longlong System::currentTime(TimeType typ) {
80 switch( typ ) {
81 case Year : return currentTime<Year >();
82 case Month : return currentTime<Month >();
83 case Day : return currentTime<Day >();
84 case Hour : return currentTime<Hour >();
85 case Min : return currentTime<Min >();
86 case Sec : return currentTime<Sec >();
87 case milliSec: return currentTime<milliSec>();
88 case microSec: return currentTime<microSec>();
89 case nanoSec : return currentTime<nanoSec >();
90 case Native : return currentTime<Native >();
91 }
92 return currentTime<Native>();
93 }
94
96 longlong System::systemStart(TimeType typ) {
97 static longlong sys_start = 0;
98 if ( 0 == sys_start ) {
99 longlong c = currentTime(microSec);
100 longlong t = tickCount();
101 sys_start = 10*c - t;
102 }
103 return adjustTime(typ, sys_start);
104 }
105
107 longlong System::upTime(TimeType typ) {
108 static longlong sys_start = 10*systemStart(microSec);
109 return adjustTime(typ, 10*currentTime(microSec)-sys_start);
110 }
111
113 longlong System::creationTime(TimeType typ, InfoType fetch, long pid) {
114 longlong created = 0;
115 KERNEL_USER_TIMES info;
116 if ( fetch != NoFetch && getProcess()->query(pid, fetch, &info) ) {
117 created = adjustTime(typ, info.CreateTime-UNIX_BASE_TIME);
118 }
119 return created;
120 }
121
123 longlong System::remainingTime(TimeType typ, InfoType fetch, long pid) {
124 longlong left = 0;
125 QUOTA_LIMITS quota;
126 if ( fetch != NoFetch && getProcess()->query(pid, fetch, &quota) ) {
127 if ( left == -1 ) {
128 //left = _I64_MAX;
129 }
130 else {
131 left = adjustTime(typ, quota.TimeLimit);
132 }
133 }
134 return left;
135 }
136
138 longlong System::ellapsedTime(TimeType typ, InfoType fetch, long pid) {
139 KERNEL_USER_TIMES info;
140 longlong ellapsed = currentTime(microSec)*10;
141 getProcess()->query(pid, fetch, &info);
142 ellapsed = adjustTime(typ, ellapsed+UNIX_BASE_TIME-info.CreateTime);
143 return ellapsed;
144 }
145
147 longlong System::kernelTime(TimeType typ, InfoType fetch, long pid) {
148 KERNEL_USER_TIMES info;
149 longlong kerneltime = 0;
150 if ( fetch != NoFetch && getProcess()->query(pid, fetch, &info) ) {
151 kerneltime = adjustTime(typ, info.KernelTime );
152 }
153 return kerneltime;
154 }
155
157 longlong System::userTime(TimeType typ, InfoType fetch, long pid) {
158 longlong usertime = 0;
159 KERNEL_USER_TIMES info;
160 if ( fetch != NoFetch && getProcess()->query(pid, fetch, &info) ) {
161 usertime = adjustTime(typ, info.UserTime );
162 }
163 return usertime;
164 }
165
167 longlong System::cpuTime(TimeType typ, InfoType fetch, long pid) {
168 longlong cputime = 0;
169 KERNEL_USER_TIMES info;
170 if ( fetch != NoFetch && getProcess()->query(pid, fetch, &info) ) {
171 cputime = adjustTime(typ, info.KernelTime+info.UserTime );
172 }
173 return cputime;
174 }
175
176 namespace System {
177 ProcessTime getProcessTime(long pid) {
178 KERNEL_USER_TIMES info;
179 if (getProcess()->query(pid, Times, &info)) {
180 return ProcessTime(info.KernelTime,
181 info.UserTime,
182 currentTime<Native>() - info.CreateTime);
183 }
184 return ProcessTime(); // return 0s in case of problems
185 }
186 }
187
188
System::KERNEL_USER_TIMES
Process/Thread System and User Time NtQueryInformationProcess using ProcessTimes NtQueryInformationTh...
Definition: ProcessDescriptor.h:93
System::userTime
GAUDI_API longlong userTime(TimeType typ=milliSec, InfoType fetch=Times, long pid=-1)
CPU user mode time of process in milliseconds.
Definition: Timing.cpp:157
System::currentTime< milliSec >
template longlong currentTime< milliSec >()
System::currentTime< microSec >
template longlong currentTime< microSec >()
gaudirun.c
c
Definition: gaudirun.py:391
System::systemStart
GAUDI_API longlong systemStart(TimeType typ=Sec)
Maximum processing time left for this process.
Definition: Timing.cpp:96
ProcessDescriptor.h
System::Min
Definition: Timing.h:57
System
Note: OS specific details for environment resolution.
Definition: Debugger.h:19
System::Times
Definition: SystemBase.h:20
System::QUOTA_LIMITS::TimeLimit
longlong TimeLimit
Definition: ProcessDescriptor.h:38
System::cpuTime
GAUDI_API longlong cpuTime(TimeType typ=milliSec, InfoType fetch=Times, long pid=-1)
Consumed CPU time of process in milliseconds.
Definition: Timing.cpp:167
System::adjustTime< Native >
long long adjustTime< Native >(long long t)
Definition: Timing.h:239
System::Hour
Definition: Timing.h:57
System::ellapsedTime
GAUDI_API longlong ellapsedTime(TimeType typ=milliSec, InfoType fetch=Times, long pid=-1)
Elapsed time since start of process in milliseconds.
Definition: Timing.cpp:138
System::milliSec
Definition: Timing.h:57
System::upTime
GAUDI_API longlong upTime(TimeType typ=Hour)
Maximum processing time left for this process.
Definition: Timing.cpp:107
System::Sec
Definition: Timing.h:57
System::adjustTime< nanoSec >
long long adjustTime< nanoSec >(long long t)
Definition: Timing.h:231
System::tickCount
GAUDI_API longlong tickCount()
Retrieve the number of ticks since system startup.
Definition: Timing.cpp:65
System::microSec
Definition: Timing.h:57
__longlong
Definition: Kernel.h:56
System::creationTime
GAUDI_API longlong creationTime(TimeType typ=milliSec, InfoType fetch=Times, long pid=-1)
Process Creation time.
Definition: Timing.cpp:113
System::TimeType
TimeType
Time type for conversion.
Definition: Timing.h:57
System::remainingTime
GAUDI_API longlong remainingTime(TimeType typ=milliSec, InfoType fetch=Quota, long pid=-1)
Maximum processing time left for this process.
Definition: Timing.cpp:123
System::currentTime< Native >
template longlong currentTime< Native >()
System::Native
Definition: Timing.h:57
System::currentTime< nanoSec >
template longlong currentTime< nanoSec >()
System::kernelTime
GAUDI_API longlong kernelTime(TimeType typ=milliSec, InfoType fetch=Times, long pid=-1)
CPU kernel mode time of process in milliseconds.
Definition: Timing.cpp:147
System::adjustTime< milliSec >
long long adjustTime< milliSec >(long long t)
Definition: Timing.h:223
System::ProcessTime
Simple class to hold the time information of a process.
Definition: Timing.h:146
System::adjustTime< microSec >
long long adjustTime< microSec >(long long t)
Definition: Timing.h:227
System::currentTime
GAUDI_API longlong currentTime()
Retrieve absolute system time.
Definition: Timing.h:245
System::NoFetch
Definition: SystemBase.h:18
System::Month
Definition: Timing.h:57
Timing.h
System::nanoSec
Definition: Timing.h:57
System::KERNEL_USER_TIMES::KernelTime
longlong KernelTime
Definition: ProcessDescriptor.h:96
System::adjustTime
GAUDI_API longlong adjustTime(TimeType typ, longlong timevalue)
Convert time from OS native time to requested representation (Experts only)
Definition: Timing.cpp:37
System::getProcess
ProcessDescriptor * getProcess()
Retrieve Process structure.
Definition: ProcessDescriptor.h:135
System::QUOTA_LIMITS
Process Quotas NtQueryInformationProcess using ProcessQuotaLimits NtQueryInformationProcess using Pro...
Definition: ProcessDescriptor.h:32
System::ProcessDescriptor::query
long query(long pid, InfoType info, PROCESS_BASIC_INFORMATION *buffer)
Definition: ProcessDescriptor.cpp:642
System::getProcessTime
GAUDI_API ProcessTime getProcessTime(long pid=-1)
Retrieve the process time data for a process.
Definition: Timing.cpp:177
System::Year
Definition: Timing.h:57
System::KERNEL_USER_TIMES::UserTime
longlong UserTime
Definition: ProcessDescriptor.h:97
System::KERNEL_USER_TIMES::CreateTime
longlong CreateTime
Definition: ProcessDescriptor.h:94
System::InfoType
InfoType
Enumeration for fetching information.
Definition: SystemBase.h:18
System::Day
Definition: Timing.h:57