compat_time.h 7.8 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233
  1. /* Copyright (c) 2003-2004, Roger Dingledine
  2. * Copyright (c) 2004-2006, Roger Dingledine, Nick Mathewson.
  3. * Copyright (c) 2007-2017, The Tor Project, Inc. */
  4. /* See LICENSE for licensing information */
  5. /**
  6. * \file compat_time.h
  7. *
  8. * \brief Functions and types for monotonic times.
  9. *
  10. * monotime_* functions try to provide a high-resolution monotonic timer with
  11. * something the best resolution the system provides. monotime_coarse_*
  12. * functions run faster (if the operating system gives us a way to do that)
  13. * but produce a less accurate timer: accuracy will probably be on the order
  14. * of tens of milliseconds.
  15. */
  16. #ifndef TOR_COMPAT_TIME_H
  17. #define TOR_COMPAT_TIME_H
  18. #include "orconfig.h"
  19. #ifdef _WIN32
  20. #undef HAVE_CLOCK_GETTIME
  21. #endif
  22. #if defined(HAVE_CLOCK_GETTIME)
  23. /* to ensure definition of CLOCK_MONOTONIC_COARSE if it's there */
  24. #include <time.h>
  25. #endif
  26. #if !defined(HAVE_STRUCT_TIMEVAL_TV_SEC)
  27. /** Implementation of timeval for platforms that don't have it. */
  28. struct timeval {
  29. time_t tv_sec;
  30. unsigned int tv_usec;
  31. };
  32. #endif /* !defined(HAVE_STRUCT_TIMEVAL_TV_SEC) */
  33. /** Represents a monotonic timer in a platform-dependent way. */
  34. typedef struct monotime_t {
  35. #ifdef __APPLE__
  36. /* On apple, there is a 64-bit counter whose precision we must look up. */
  37. uint64_t abstime_;
  38. #elif defined(HAVE_CLOCK_GETTIME)
  39. /* It sure would be nice to use clock_gettime(). Posix is a nice thing. */
  40. struct timespec ts_;
  41. #elif defined (_WIN32)
  42. /* On Windows, there is a 64-bit counter whose precision we must look up. */
  43. int64_t pcount_;
  44. #else
  45. #define MONOTIME_USING_GETTIMEOFDAY
  46. /* Otherwise, we will be stuck using gettimeofday. */
  47. struct timeval tv_;
  48. #endif /* defined(__APPLE__) || ... */
  49. } monotime_t;
  50. #if defined(CLOCK_MONOTONIC_COARSE) && \
  51. defined(HAVE_CLOCK_GETTIME)
  52. #define MONOTIME_COARSE_FN_IS_DIFFERENT
  53. #define monotime_coarse_t monotime_t
  54. #elif defined(_WIN32)
  55. #define MONOTIME_COARSE_FN_IS_DIFFERENT
  56. #define MONOTIME_COARSE_TYPE_IS_DIFFERENT
  57. /** Represents a coarse monotonic time in a platform-independent way. */
  58. typedef struct monotime_coarse_t {
  59. uint64_t tick_count_;
  60. } monotime_coarse_t;
  61. #elif defined(__APPLE__) && defined(HAVE_MACH_APPROXIMATE_TIME)
  62. #define MONOTIME_COARSE_FN_IS_DIFFERENT
  63. #define monotime_coarse_t monotime_t
  64. #else
  65. #define monotime_coarse_t monotime_t
  66. #endif /* defined(CLOCK_MONOTONIC_COARSE) && ... || ... */
  67. /**
  68. * Initialize the timing subsystem. This function is idempotent.
  69. */
  70. void monotime_init(void);
  71. /**
  72. * Set <b>out</b> to the current time.
  73. */
  74. void monotime_get(monotime_t *out);
  75. /**
  76. * Return the number of nanoseconds between <b>start</b> and <b>end</b>.
  77. */
  78. int64_t monotime_diff_nsec(const monotime_t *start, const monotime_t *end);
  79. /**
  80. * Return the number of microseconds between <b>start</b> and <b>end</b>.
  81. */
  82. int64_t monotime_diff_usec(const monotime_t *start, const monotime_t *end);
  83. /**
  84. * Return the number of milliseconds between <b>start</b> and <b>end</b>.
  85. */
  86. int64_t monotime_diff_msec(const monotime_t *start, const monotime_t *end);
  87. /**
  88. * Return the number of nanoseconds since the timer system was initialized.
  89. */
  90. uint64_t monotime_absolute_nsec(void);
  91. /**
  92. * Return the number of microseconds since the timer system was initialized.
  93. */
  94. uint64_t monotime_absolute_usec(void);
  95. /**
  96. * Return the number of milliseconds since the timer system was initialized.
  97. */
  98. uint64_t monotime_absolute_msec(void);
  99. /**
  100. * Set <b>out</b> to zero.
  101. */
  102. void monotime_zero(monotime_t *out);
  103. /**
  104. * Return true iff <b>out</b> is zero
  105. */
  106. int monotime_is_zero(const monotime_t *out);
  107. /**
  108. * Set <b>out</b> to N milliseconds after <b>val</b>.
  109. */
  110. /* XXXX We should add a more generic function here if we ever need to */
  111. void monotime_add_msec(monotime_t *out, const monotime_t *val, uint32_t msec);
  112. #if defined(MONOTIME_COARSE_FN_IS_DIFFERENT)
  113. /**
  114. * Set <b>out</b> to the current coarse time.
  115. */
  116. void monotime_coarse_get(monotime_coarse_t *out);
  117. uint64_t monotime_coarse_absolute_nsec(void);
  118. uint64_t monotime_coarse_absolute_usec(void);
  119. uint64_t monotime_coarse_absolute_msec(void);
  120. #else /* !(defined(MONOTIME_COARSE_FN_IS_DIFFERENT)) */
  121. #define monotime_coarse_get monotime_get
  122. #define monotime_coarse_absolute_nsec monotime_absolute_nsec
  123. #define monotime_coarse_absolute_usec monotime_absolute_usec
  124. #define monotime_coarse_absolute_msec monotime_absolute_msec
  125. #endif /* defined(MONOTIME_COARSE_FN_IS_DIFFERENT) */
  126. /**
  127. * Return a "timestamp" approximation for a coarse monotonic timer.
  128. * This timestamp is meant to be fast to calculate and easy to
  129. * compare, and have a unit of something roughly around 1 msec.
  130. *
  131. * It will wrap over from time to time.
  132. *
  133. * It has no defined zero point.
  134. */
  135. uint32_t monotime_coarse_to_stamp(const monotime_coarse_t *t);
  136. /**
  137. * Convert a difference, expressed in the units of monotime_coarse_to_stamp,
  138. * into an approximate number of milliseconds.
  139. */
  140. uint64_t monotime_coarse_stamp_units_to_approx_msec(uint64_t units);
  141. uint64_t monotime_msec_to_approx_coarse_stamp_units(uint64_t msec);
  142. uint32_t monotime_coarse_get_stamp(void);
  143. #if defined(MONOTIME_COARSE_TYPE_IS_DIFFERENT)
  144. int64_t monotime_coarse_diff_nsec(const monotime_coarse_t *start,
  145. const monotime_coarse_t *end);
  146. int64_t monotime_coarse_diff_usec(const monotime_coarse_t *start,
  147. const monotime_coarse_t *end);
  148. int64_t monotime_coarse_diff_msec(const monotime_coarse_t *start,
  149. const monotime_coarse_t *end);
  150. void monotime_coarse_zero(monotime_coarse_t *out);
  151. int monotime_coarse_is_zero(const monotime_coarse_t *val);
  152. void monotime_coarse_add_msec(monotime_coarse_t *out,
  153. const monotime_coarse_t *val, uint32_t msec);
  154. #else /* !(defined(MONOTIME_COARSE_TYPE_IS_DIFFERENT)) */
  155. #define monotime_coarse_diff_nsec monotime_diff_nsec
  156. #define monotime_coarse_diff_usec monotime_diff_usec
  157. #define monotime_coarse_diff_msec monotime_diff_msec
  158. #define monotime_coarse_zero monotime_zero
  159. #define monotime_coarse_is_zero monotime_is_zero
  160. #define monotime_coarse_add_msec monotime_add_msec
  161. #endif /* defined(MONOTIME_COARSE_TYPE_IS_DIFFERENT) */
  162. /**
  163. * As monotime_coarse_diff_msec, but avoid 64-bit division.
  164. *
  165. * Requires that the difference fit into an int32_t; not for use with
  166. * large time differences.
  167. */
  168. int32_t monotime_coarse_diff_msec32_(const monotime_coarse_t *start,
  169. const monotime_coarse_t *end);
  170. /**
  171. * As monotime_coarse_diff_msec, but avoid 64-bit division if it is expensive.
  172. *
  173. * Requires that the difference fit into an int32_t; not for use with
  174. * large time differences.
  175. */
  176. static inline int32_t
  177. monotime_coarse_diff_msec32(const monotime_coarse_t *start,
  178. const monotime_coarse_t *end)
  179. {
  180. #if SIZEOF_VOID_P == 8
  181. // on a 64-bit platform, let's assume 64/64 division is cheap.
  182. return (int32_t) monotime_coarse_diff_msec(start, end);
  183. #else
  184. return monotime_coarse_diff_msec32_(start, end);
  185. #endif
  186. }
  187. MOCK_DECL(void, tor_gettimeofday, (struct timeval *timeval));
  188. #ifdef TOR_UNIT_TESTS
  189. void tor_sleep_msec(int msec);
  190. void monotime_enable_test_mocking(void);
  191. void monotime_disable_test_mocking(void);
  192. void monotime_set_mock_time_nsec(int64_t);
  193. #if defined(MONOTIME_COARSE_FN_IS_DIFFERENT)
  194. void monotime_coarse_set_mock_time_nsec(int64_t);
  195. #else
  196. #define monotime_coarse_set_mock_time_nsec monotime_set_mock_time_nsec
  197. #endif
  198. #endif /* defined(TOR_UNIT_TESTS) */
  199. #ifdef COMPAT_TIME_PRIVATE
  200. #if defined(_WIN32) || defined(TOR_UNIT_TESTS)
  201. STATIC int64_t ratchet_performance_counter(int64_t count_raw);
  202. STATIC int64_t ratchet_coarse_performance_counter(int64_t count_raw);
  203. #endif
  204. #if defined(MONOTIME_USING_GETTIMEOFDAY) || defined(TOR_UNIT_TESTS)
  205. STATIC void ratchet_timeval(const struct timeval *timeval_raw,
  206. struct timeval *out);
  207. #endif
  208. #ifdef TOR_UNIT_TESTS
  209. void monotime_reset_ratchets_for_testing(void);
  210. #endif
  211. #endif /* defined(COMPAT_TIME_PRIVATE) */
  212. #endif /* !defined(TOR_COMPAT_TIME_H) */