X-Git-Url: https://git.whamcloud.com/?a=blobdiff_plain;f=lnet%2Finclude%2Flibcfs%2Fdarwin%2Fdarwin-time.h;fp=lnet%2Finclude%2Flibcfs%2Fdarwin%2Fdarwin-time.h;h=43ad274630814b9770f4083f409f14daedec90e3;hb=ed88907a96ba81d3558e71ade9def98bdc785169;hp=d6230ade17175978f03d802de6b2ce31c43afa15;hpb=f7a2d07e30db3462880feb00a0461ee056b225c6;p=fs%2Flustre-release.git

diff --git a/lnet/include/libcfs/darwin/darwin-time.h b/lnet/include/libcfs/darwin/darwin-time.h
index d6230ad..43ad274 100644
--- a/lnet/include/libcfs/darwin/darwin-time.h
+++ b/lnet/include/libcfs/darwin/darwin-time.h
@@ -64,48 +64,46 @@
  *  int            cfs_fs_time_before (cfs_fs_time_t *, cfs_fs_time_t *);
  *  int            cfs_fs_time_beforeq(cfs_fs_time_t *, cfs_fs_time_t *);
  *
- *  cfs_duration_t cfs_time_minimal_timeout(void)
- *
  *  CFS_TIME_FORMAT
  *  CFS_DURATION_FORMAT
  *
  */
 
 #define ONE_BILLION ((u_int64_t)1000000000)
-#define ONE_MILLION ((u_int64_t)   1000000)
+#define ONE_MILLION 1000000
 
 #ifdef __KERNEL__
 #include <sys/types.h>
 #include <sys/systm.h>
 
-#ifndef __APPLE_API_PRIVATE
-#define __APPLE_API_PRIVATE
-#include <sys/user.h>
-#undef __APPLE_API_PRIVATE
-#else
-#include <sys/user.h>
-#endif
-
 #include <sys/kernel.h>
 
-#include <mach/thread_act.h>
 #include <mach/mach_types.h>
-#include <mach/mach_traps.h>
-#include <mach/thread_switch.h>
 #include <mach/time_value.h>
-#include <kern/sched_prim.h>
-#include <vm/pmap.h>
-#include <vm/vm_kern.h>
-#include <mach/machine/vm_param.h>
 #include <kern/clock.h>
-#include <kern/thread_call.h>
 #include <sys/param.h>
-#include <sys/vm.h>
 
 #include <libcfs/darwin/darwin-types.h>
 #include <libcfs/darwin/darwin-utils.h>
 #include <libcfs/darwin/darwin-lock.h>
 
+/*
+ * There are three way to measure time in OS X:
+ * 1. nanoseconds
+ * 2. absolute time (abstime unit equal to the length of one bus cycle),
+ *    schedule of thread/timer are counted by absolute time, but abstime
+ *    in different mac can be different also, so we wouldn't use it.
+ * 3. clock interval (1sec = 100hz). But clock interval only taken by KPI
+ *    like tsleep().
+ *
+ * We use nanoseconds (uptime, not calendar time)
+ *
+ * clock_get_uptime()   :get absolute time since bootup.
+ * nanouptime()         :get nanoseconds since bootup
+ * microuptime()        :get microseonds since bootup
+ * nanotime()           :get nanoseconds since epoch
+ * microtime()          :get microseconds since epoch
+ */
 typedef u_int64_t cfs_time_t; /* nanoseconds */
 typedef int64_t cfs_duration_t;
 
@@ -118,15 +116,15 @@ static inline cfs_time_t cfs_time_current(void)
 {
         struct timespec instant;
 
-        nanotime(&instant);
-        return ((u_int64_t)instant.tv_sec) * ONE_BILLION + instant.tv_nsec;
+        nanouptime(&instant);
+        return ((u_int64_t)instant.tv_sec) * NSEC_PER_SEC + instant.tv_nsec;
 }
 
 static inline time_t cfs_time_current_sec(void)
 {
         struct timespec instant;
 
-        nanotime(&instant);
+        nanouptime(&instant);
 	return instant.tv_sec;
 }
 
@@ -152,7 +150,7 @@ static inline int cfs_time_beforeq(cfs_time_t t1, cfs_time_t t2)
 
 static inline void cfs_fs_time_current(cfs_fs_time_t *t)
 {
-        *t = time;
+        microtime((struct timeval *)t);
 }
 
 static inline time_t cfs_fs_time_sec(cfs_fs_time_t *t)
@@ -160,12 +158,6 @@ static inline time_t cfs_fs_time_sec(cfs_fs_time_t *t)
         return t->tv_sec;
 }
 
-static inline cfs_duration_t cfs_duration_build(int64_t nano)
-{
-        return nano;
-}
-
-
 static inline void cfs_fs_time_usec(cfs_fs_time_t *t, struct timeval *v)
 {
         *v = *t;
@@ -174,17 +166,12 @@ static inline void cfs_fs_time_usec(cfs_fs_time_t *t, struct timeval *v)
 static inline void cfs_fs_time_nsec(cfs_fs_time_t *t, struct timespec *s)
 {
         s->tv_sec  = t->tv_sec;
-        s->tv_nsec = t->tv_usec * 1000;
+        s->tv_nsec = t->tv_usec * NSEC_PER_USEC;
 }
 
 static inline cfs_duration_t cfs_time_seconds(int seconds)
 {
-	return cfs_duration_build(ONE_BILLION * (int64_t)seconds);
-}
-
-static inline cfs_time_t cfs_time_shift(int seconds)
-{
-	return cfs_time_add(cfs_time_current(), cfs_time_seconds(seconds));
+	return (NSEC_PER_SEC * (int64_t)seconds);
 }
 
 /*
@@ -192,7 +179,7 @@ static inline cfs_time_t cfs_time_shift(int seconds)
  */
 static inline int64_t __cfs_fs_time_flat(cfs_fs_time_t *t)
 {
-        return ((int64_t)t->tv_sec) * ONE_BILLION + t->tv_usec;
+        return ((int64_t)t->tv_sec)*NSEC_PER_SEC + t->tv_usec*NSEC_PER_USEC;
 }
 
 static inline int cfs_fs_time_before(cfs_fs_time_t *t1, cfs_fs_time_t *t2)
@@ -207,29 +194,33 @@ static inline int cfs_fs_time_beforeq(cfs_fs_time_t *t1, cfs_fs_time_t *t2)
 
 static inline time_t cfs_duration_sec(cfs_duration_t d)
 {
-        return d / ONE_BILLION;
+        return d / NSEC_PER_SEC;
 }
 
 static inline void cfs_duration_usec(cfs_duration_t d, struct timeval *s)
 {
-        s->tv_sec = d / ONE_BILLION;
-        s->tv_usec = (d - s->tv_sec * ONE_BILLION) / 1000;
+        s->tv_sec = d / NSEC_PER_SEC;
+        s->tv_usec = (d - ((int64_t)s->tv_sec) * NSEC_PER_SEC) / NSEC_PER_USEC;
 }
 
 static inline void cfs_duration_nsec(cfs_duration_t d, struct timespec *s)
 {
-        s->tv_sec = d / ONE_BILLION;
-        s->tv_nsec = d - ((int64_t)s->tv_sec) * ONE_BILLION;
+        s->tv_sec = d / NSEC_PER_SEC;
+        s->tv_nsec = d - ((int64_t)s->tv_sec) * NSEC_PER_SEC;
 }
 
-static inline cfs_duration_t cfs_time_minimal_timeout(void)
-{
-        return ONE_BILLION / (u_int64_t)hz;
-}
+#define cfs_time_current_64 cfs_time_current
+#define cfs_time_add_64     cfs_time_add
+#define cfs_time_shift_64   cfs_time_shift
+#define cfs_time_before_64  cfs_time_before
 
-/* inline function cfs_time_minimal_timeout() can not be used to
- * initiallize static variable */
-#define CFS_MIN_DELAY		(ONE_BILLION / (u_int64_t)100)
+/* 
+ * One jiffy (in nanoseconds)
+ *
+ * osfmk/kern/sched_prim.c
+ * #define DEFAULT_PREEMPTION_RATE      100
+ */
+#define CFS_TICK		(NSEC_PER_SEC / (u_int64_t)100)
 
 #define LTIME_S(t)		(t)