00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00022 #if !defined(GLOBUS_TIME_H)
00023 #define GLOBUS_TIME_H
00024
00025 #include "globus_types.h"
00026 #include <time.h>
00027
00028 #ifdef __cplusplus
00029 extern "C" {
00030 #endif
00031
00032 #define GLOBUS_I_TIME_INFINITY_SEC INT_MAX
00033 #define GLOBUS_I_TIME_INFINITY_NSEC INT_MAX
00034 #define GLOBUS_I_TIME_INFINITY_USEC INT_MAX
00035
00036 #if defined(_WIN32) && !defined(_POSIX)
00037 typedef struct globus_abstime_s
00038 {
00039 time_t tv_sec;
00040 long tv_nsec;
00041 } globus_abstime_t;
00042 #else
00043 typedef struct timespec globus_abstime_t;
00044 #endif
00045
00046 typedef struct timeval globus_reltime_t;
00047
00051 #define GlobusTimeAbstimeSet(Abstime, Sec, USec) \
00052 { \
00053 GlobusTimeAbstimeGetCurrent(Abstime); \
00054 (Abstime).tv_nsec += (USec * 1000); \
00055 if((Abstime).tv_nsec >= 1000000000) \
00056 { \
00057 (Abstime).tv_sec += ((Abstime).tv_nsec / 1000000000);\
00058 (Abstime).tv_nsec = (Abstime).tv_nsec % 1000000000; \
00059 } \
00060 (Abstime).tv_sec += Sec; \
00061 }
00062
00065 #define GlobusTimeAbstimeGet(Abstime, Sec, USec) \
00066 { \
00067 Sec = (Abstime).tv_sec; \
00068 USec = ((Abstime).tv_nsec / 1000); \
00069 }
00070
00074 #define GlobusTimeReltimeSet(Reltime, Sec, USec) \
00075 { \
00076 (Reltime).tv_usec = (USec); \
00077 (Reltime).tv_sec = Sec; \
00078 if((Reltime).tv_usec >= 1000000) \
00079 { \
00080 (Reltime).tv_sec += ((Reltime).tv_usec / 1000000);\
00081 (Reltime).tv_usec = (Reltime).tv_usec % 1000000; \
00082 } \
00083 }
00084
00085 #define GlobusTimeReltimeGet(Reltime, Sec, USec) \
00086 { \
00087 (USec) = (Reltime).tv_usec; \
00088 (Sec) = (Reltime).tv_sec; \
00089 }
00090
00091 #define GlobusTimeAbstimePrintf(Abstime) \
00092 { \
00093 printf("sec -->%lu\n", (unsigned long) (Abstime).tv_sec); \
00094 printf("nsec -->%lu\n", (unsigned long) (Abstime).tv_nsec); \
00095 }
00096
00097 #define GlobusTimeReltimePrintf(Reltime) \
00098 { \
00099 printf("sec -->%lu\n", (unsigned long) (Reltime).tv_sec); \
00100 printf("usec -->%lu\n", (unsigned long) (Reltime).tv_usec); \
00101 }
00102
00106 #define GlobusTimeAbstimeDiff(Reltime, T1, T2) \
00107 { \
00108 int __res = globus_abstime_cmp(&(T1), &(T2)); \
00109 if(__res < 0) \
00110 { \
00111 (Reltime).tv_sec = (T2).tv_sec - (T1).tv_sec; \
00112 (Reltime).tv_usec = \
00113 (((T2).tv_nsec - (T1).tv_nsec) / 1000); \
00114 if((Reltime).tv_usec < 0) \
00115 { \
00116 (Reltime).tv_sec--; \
00117 (Reltime).tv_usec += 1000000; \
00118 } \
00119 } \
00120 else if(__res > 0) \
00121 { \
00122 (Reltime).tv_sec = (T1).tv_sec - (T2).tv_sec; \
00123 (Reltime).tv_usec = \
00124 (((T1).tv_nsec - (T2).tv_nsec) / 1000); \
00125 if((Reltime).tv_usec < 0) \
00126 { \
00127 (Reltime).tv_sec--; \
00128 (Reltime).tv_usec += 1000000; \
00129 } \
00130 } \
00131 else \
00132 { \
00133 (Reltime).tv_sec = 0; \
00134 (Reltime).tv_usec = 0; \
00135 } \
00136 }
00137
00138 #define GlobusTimeReltimeDiff(Reltime, T1, T2) \
00139 { \
00140 int __res = globus_reltime_cmp(&(T1), &(T2)); \
00141 if(__res < 0) \
00142 { \
00143 (Reltime).tv_sec = (T2).tv_sec - (T1).tv_sec; \
00144 (Reltime).tv_usec = \
00145 ((T2).tv_usec - (T1).tv_usec); \
00146 if((Reltime).tv_usec < 0) \
00147 { \
00148 (Reltime).tv_sec--; \
00149 (Reltime).tv_usec += 1000000; \
00150 } \
00151 } \
00152 else if(__res > 0) \
00153 { \
00154 (Reltime).tv_sec = (T1).tv_sec - (T2).tv_sec; \
00155 (Reltime).tv_usec = \
00156 ((T1).tv_usec - (T2).tv_usec); \
00157 if((Reltime).tv_usec < 0) \
00158 { \
00159 (Reltime).tv_sec--; \
00160 (Reltime).tv_usec += 1000000; \
00161 } \
00162 } \
00163 else \
00164 { \
00165 (Reltime).tv_sec = 0; \
00166 (Reltime).tv_usec = 0; \
00167 } \
00168 }
00169
00173 #define GlobusTimeReltimeToUSec(SlpInt, Reltime) \
00174 { \
00175 SlpInt = ((Reltime).tv_sec * 1000000) + \
00176 ((Reltime).tv_usec); \
00177 }
00178
00182 #define GlobusTimeReltimeToMilliSec( Milliseconds, Reltime) \
00183 { \
00184 Milliseconds = ((Reltime).tv_sec * 1000) + \
00185 ((Reltime).tv_usec)/ 1000; \
00186 }
00187
00191 #define GlobusTimeAbstimeInc(Abstime, Reltime) \
00192 { \
00193 (Abstime).tv_nsec += ((Reltime).tv_usec * 1000); \
00194 if((Abstime).tv_nsec >= 1000000000) \
00195 { \
00196 (Abstime).tv_sec++; \
00197 (Abstime).tv_nsec -= 1000000000; \
00198 } \
00199 (Abstime).tv_sec += (Reltime).tv_sec; \
00200 }
00201
00202 #define GlobusTimeAbstimeDec(Abstime, Reltime) \
00203 { \
00204 (Abstime).tv_nsec -= ((Reltime).tv_usec * 1000); \
00205 if((Abstime).tv_nsec < 0) \
00206 { \
00207 (Abstime).tv_sec--; \
00208 (Abstime).tv_nsec += 1000000000; \
00209 } \
00210 (Abstime).tv_sec -= (Reltime).tv_sec; \
00211 }
00212
00213
00217 #if defined(_WIN32)
00218 # define GlobusTimeAbstimeGetCurrent(Abstime) \
00219 { \
00220 struct _timeb timebuffer; \
00221 \
00222 _ftime(&timebuffer); \
00223 (Abstime).tv_sec = timebuffer.time; \
00224 (Abstime).tv_nsec = (timebuffer.millitm * 1000000); \
00225 }
00226 #else
00227 # define GlobusTimeAbstimeGetCurrent(Abstime) \
00228 { \
00229 struct timeval __time; \
00230 \
00231 gettimeofday(&__time, GLOBUS_NULL); \
00232 (Abstime).tv_sec = __time.tv_sec; \
00233 (Abstime).tv_nsec = (__time.tv_usec * 1000); \
00234 }
00235 #endif
00236
00240 #define GlobusTimeAbstimeCopy(Dest, Src) \
00241 { \
00242 (Dest).tv_sec = (Src).tv_sec; \
00243 (Dest).tv_nsec = (Src).tv_nsec; \
00244 }
00245
00249 #define GlobusTimeReltimeCopy(Dest, Src) \
00250 { \
00251 (Dest).tv_sec = (Src).tv_sec; \
00252 (Dest).tv_usec = (Src).tv_usec; \
00253 }
00254
00258 #define GlobusTimeReltimeMultiply(Reltime, Factor) \
00259 { \
00260 (Reltime).tv_usec *= Factor; \
00261 (Reltime).tv_sec *= Factor; \
00262 \
00263 if((Reltime).tv_usec >= 1000000) \
00264 { \
00265 (Reltime).tv_sec += ((Reltime).tv_usec / 1000000);\
00266 (Reltime).tv_usec = (Reltime).tv_usec % 1000000; \
00267 } \
00268 }
00269
00273 #define GlobusTimeReltimeDivide(Reltime, Factor) \
00274 { \
00275 (Reltime).tv_usec /= Factor; \
00276 (Reltime).tv_sec /= Factor; \
00277 }
00278
00279 extern const globus_abstime_t globus_i_abstime_infinity;
00280 extern const globus_abstime_t globus_i_abstime_zero;
00281 extern const globus_reltime_t globus_i_reltime_infinity;
00282 extern const globus_reltime_t globus_i_reltime_zero;
00283
00290 globus_bool_t
00291 globus_time_has_expired(
00292 const globus_abstime_t * abstime);
00293
00297 globus_bool_t
00298 globus_time_abstime_is_infinity(
00299 const globus_abstime_t * abstime);
00300
00304 globus_bool_t
00305 globus_time_reltime_is_infinity(
00306 const globus_reltime_t * reltime);
00307
00318 int
00319 globus_abstime_cmp(
00320 const globus_abstime_t * abstime_1,
00321 const globus_abstime_t * abstime_2);
00322
00333 int
00334 globus_reltime_cmp(
00335 const globus_reltime_t * reltime_1,
00336 const globus_reltime_t * reltime_2);
00337
00338
00339 #ifdef __cplusplus
00340 }
00341 #endif
00342 #endif