ltt/branches/poly/ltt/time.h

   1 /* This file is part of the Linux Trace Toolkit trace reading library
   2  * Copyright (C) 2003-2004 Michel Dagenais
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License Version 2.1 as published by the Free Software Foundation.
   7  *
   8  * This library is distributed in the hope that it will be useful,
   9  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  11  * Lesser General Public License for more details.
  12  *
  13  * You should have received a copy of the GNU Lesser General Public
  14  * License along with this library; if not, write to the
  15  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  16  * Boston, MA 02111-1307, USA.
  17  */
  18
  19 #ifndef LTT_TIME_H
  20 #define LTT_TIME_H
  21
  22 #include <glib.h>
  23
  24
  25 typedef struct _LttTime {
  26   unsigned long tv_sec;
  27   unsigned long tv_nsec;
  28 } LttTime;
  29
  30
  31 #define NANOSECONDS_PER_SECOND 1000000000
  32
  33 static const LttTime ltt_time_zero = { 0, 0 };
  34
  35 static const LttTime ltt_time_one = { 0, 1 };
  36
  37 static const LttTime ltt_time_infinite = { G_MAXUINT, NANOSECONDS_PER_SECOND };
  38
  39 static inline LttTime ltt_time_sub(LttTime t1, LttTime t2)
  40 {
  41   LttTime res;
  42   res.tv_sec  = t1.tv_sec  - t2.tv_sec;
  43   res.tv_nsec = t1.tv_nsec - t2.tv_nsec;
  44   if(t1.tv_nsec < t2.tv_nsec) {
  45     res.tv_sec--;
  46     res.tv_nsec += NANOSECONDS_PER_SECOND;
  47   }
  48   return res;
  49 }
  50
  51
  52 static inline LttTime ltt_time_add(LttTime t1, LttTime t2)
  53 {
  54   LttTime res;
  55   res.tv_nsec = t1.tv_nsec + t2.tv_nsec;
  56   res.tv_sec = t1.tv_sec + t2.tv_sec;
  57   if(res.tv_nsec >= NANOSECONDS_PER_SECOND) {
  58     res.tv_sec++;
  59     res.tv_nsec -= NANOSECONDS_PER_SECOND;
  60   }
  61   return res;
  62 }
  63
  64
  65 static inline int ltt_time_compare(LttTime t1, LttTime t2)
  66 {
  67   if(t1.tv_sec > t2.tv_sec) return 1;
  68   if(t1.tv_sec < t2.tv_sec) return -1;
  69   if(t1.tv_nsec > t2.tv_nsec) return 1;
  70   if(t1.tv_nsec < t2.tv_nsec) return -1;
  71   return 0;
  72 }
  73
  74 #define LTT_TIME_MIN(a,b) ((ltt_time_compare((a),(b)) < 0) ? (a) : (b))
  75 #define LTT_TIME_MAX(a,b) ((ltt_time_compare((a),(b)) > 0) ? (a) : (b))
  76
  77 #define MAX_TV_SEC_TO_DOUBLE 0x7FFFFF
  78 static inline double ltt_time_to_double(LttTime t1)
  79 {
  80   /* We lose precision if tv_sec is > than (2^23)-1
  81    *
  82    * Max values that fits in a double (53 bits precision on normalised
  83    * mantissa):
  84    * tv_nsec : NANOSECONDS_PER_SECONDS : 2^30
  85    *
  86    * So we have 53-30 = 23 bits left for tv_sec.
  87    * */
  88   g_assert(t1.tv_sec <= MAX_TV_SEC_TO_DOUBLE);
  89   if(t1.tv_sec > MAX_TV_SEC_TO_DOUBLE)
  90     g_warning("Precision loss in conversion LttTime to double");
  91   return (double)t1.tv_sec + (double)t1.tv_nsec / NANOSECONDS_PER_SECOND;
  92 }
  93
  94
  95 static inline LttTime ltt_time_from_double(double t1)
  96 {
  97   /* We lose precision if tv_sec is > than (2^23)-1
  98    *
  99    * Max values that fits in a double (53 bits precision on normalised
 100    * mantissa):
 101    * tv_nsec : NANOSECONDS_PER_SECONDS : 2^30
 102    *
 103    * So we have 53-30 = 23 bits left for tv_sec.
 104    * */
 105   g_assert(t1 <= MAX_TV_SEC_TO_DOUBLE);
 106   if(t1 > MAX_TV_SEC_TO_DOUBLE)
 107     g_warning("Conversion from non precise double to LttTime");
 108   LttTime res;
 109   res.tv_sec = t1;
 110   res.tv_nsec = (t1 - res.tv_sec) * NANOSECONDS_PER_SECOND;
 111   return res;
 112 }
 113
 114 /* Use ltt_time_to_double and ltt_time_from_double to check for lack
 115  * of precision.
 116  */
 117 static inline LttTime ltt_time_mul(LttTime t1, double d)
 118 {
 119   LttTime res;
 120
 121   double time_double = ltt_time_to_double(t1);
 122
 123   time_double = time_double * d;
 124
 125   res = ltt_time_from_double(time_double);
 126
 127   return res;
 128
 129 #if 0
 130   /* What is that ? (Mathieu) */
 131   if(f == 0.0){
 132     res.tv_sec = 0;
 133     res.tv_nsec = 0;
 134   }else{
 135   double d;
 136     d = 1.0/f;
 137     sec = t1.tv_sec / (double)d;
 138     res.tv_sec = sec;
 139     res.tv_nsec = t1.tv_nsec / (double)d + (sec - res.tv_sec) *
 140                   NANOSECONDS_PER_SECOND;
 141     res.tv_sec += res.tv_nsec / NANOSECONDS_PER_SECOND;
 142     res.tv_nsec %= NANOSECONDS_PER_SECOND;
 143   }
 144   return res;
 145 #endif //0
 146 }
 147
 148
 149 /* Use ltt_time_to_double and ltt_time_from_double to check for lack
 150  * of precision.
 151  */
 152 static inline LttTime ltt_time_div(LttTime t1, double d)
 153 {
 154   LttTime res;
 155
 156   double time_double = ltt_time_to_double(t1);
 157
 158   time_double = time_double / d;
 159
 160   res = ltt_time_from_double(time_double);
 161
 162   return res;
 163
 164
 165 #if 0
 166   double sec;
 167   LttTime res;
 168
 169   sec = t1.tv_sec / (double)f;
 170   res.tv_sec = sec;
 171   res.tv_nsec = t1.tv_nsec / (double)f + (sec - res.tv_sec) *
 172       NANOSECONDS_PER_SECOND;
 173   res.tv_sec += res.tv_nsec / NANOSECONDS_PER_SECOND;
 174   res.tv_nsec %= NANOSECONDS_PER_SECOND;
 175   return res;
 176 #endif //0
 177 }
 178
 179 static inline guint64 ltt_time_to_uint64(LttTime t1)
 180 {
 181   return (guint64)t1.tv_sec*NANOSECONDS_PER_SECOND
 182             + (guint64)t1.tv_nsec;
 183 }
 184
 185
 186 #define MAX_TV_SEC_TO_UINT64 0x3FFFFFFFFFFFFFFFULL
 187 static inline LttTime ltt_time_from_uint64(guint64 t1)
 188 {
 189   /* We lose precision if tv_sec is > than (2^62)-1
 190    * */
 191   g_assert(t1 <= MAX_TV_SEC_TO_UINT64);
 192   if(t1 > MAX_TV_SEC_TO_UINT64)
 193     g_warning("Conversion from non precise uint64 to LttTime");
 194   LttTime res;
 195   res.tv_sec = t1/NANOSECONDS_PER_SECOND;
 196   res.tv_nsec = (t1 - res.tv_sec*NANOSECONDS_PER_SECOND);
 197   return res;
 198 }
 199
 200 #endif // LTT_TIME_H