kconfig: use pkg-config for ncurses detection

[akaros.git] / kern / include / time.h

diff --git a/kern/include/time.h b/kern/include/time.h
index 92ee9b4..32d42f5 100644 (file)
--- a/kern/include/time.h
+++ b/kern/include/time.h
@@ -1,39 +1,77 @@
-#ifndef ROS_KERN_TIME_H
-#define ROS_KERN_TIME_H
+#pragma once
 
 #include <ros/common.h>
+#include <ros/time.h>
 #include <arch/time.h>
+#include <ros/procinfo.h>
 
-/* (newlib) Time Value Specification Structures, P1003.1b-1993, p. 261 */
-typedef long time_t;
+/* Conversion factors */
+#define NSEC_PER_SEC   1000000000L
+#define NSEC_PER_MSEC  1000000L
+#define NSEC_PER_USEC  1000L
 
-struct timespec {
-  time_t  tv_sec;   /* Seconds */
-  long    tv_nsec;  /* Nanoseconds */
-};
-
-struct itimerspec {
-  struct timespec  it_interval;  /* Timer period */
-  struct timespec  it_value;     /* Timer expiration */
-};
+void time_init(void);
+void udelay(uint64_t usec);    /* done in arch-specific files */
 
-struct timeval {
-       time_t tv_sec;  /* seconds */
-       time_t tv_usec; /* microseconds */
-};
+uint64_t read_persistent_clock(void);  /* arch-specific */
 
-void train_timing();
-void udelay(uint64_t usec);    /* done in arch-specific files */
-void udelay_sched(uint64_t usec);
-uint64_t tsc2sec(uint64_t tsc_time);
-uint64_t tsc2msec(uint64_t tsc_time);
-uint64_t tsc2usec(uint64_t tsc_time);
 uint64_t tsc2nsec(uint64_t tsc_time);
-uint64_t sec2tsc(uint64_t sec);
-uint64_t msec2tsc(uint64_t msec);
-uint64_t usec2tsc(uint64_t usec);
+
+static inline uint64_t tsc2usec(uint64_t tsc_time)
+{
+       return tsc2nsec(tsc_time) / NSEC_PER_USEC;
+}
+
+static inline uint64_t tsc2msec(uint64_t tsc_time)
+{
+       return tsc2nsec(tsc_time) / NSEC_PER_MSEC;
+}
+
+static inline uint64_t tsc2sec(uint64_t tsc_time)
+{
+       return tsc2nsec(tsc_time) / NSEC_PER_SEC;
+}
+
 uint64_t nsec2tsc(uint64_t nsec);
 
+static inline uint64_t usec2tsc(uint64_t usec)
+{
+       return nsec2tsc(usec * NSEC_PER_USEC);
+}
+
+static inline uint64_t msec2tsc(uint64_t msec)
+{
+       return nsec2tsc(msec * NSEC_PER_MSEC);
+}
+
+static inline uint64_t sec2tsc(uint64_t sec)
+{
+       return nsec2tsc(sec * NSEC_PER_SEC);
+}
+
+uint64_t epoch_nsec(void);
+
+static inline struct timespec nsec2timespec(uint64_t ns)
+{
+       return (struct timespec) {
+               .tv_sec = ns / NSEC_PER_SEC,
+               .tv_nsec = ns % NSEC_PER_SEC
+       };
+}
+
+static inline struct timeval nsec2timeval(uint64_t ns)
+{
+       return (struct timeval) {
+               .tv_sec = ns / NSEC_PER_SEC,
+               .tv_usec = (ns % NSEC_PER_SEC) / NSEC_PER_USEC
+       };
+}
+
+static inline struct timespec tsc2timespec(uint64_t tsc_time)
+{
+       return nsec2timespec(tsc2nsec(tsc_time));
+}
+
 /* Just takes a time measurement.  Meant to be paired with stop_timing.  Use
  * this if you don't want to muck with overheads or subtraction. */
 static inline __attribute__((always_inline))
@@ -50,13 +88,20 @@ uint64_t stop_timing(uint64_t start_time)
 {
     uint64_t diff = read_tsc_serialized();
     diff -= start_time;
-    diff -= system_timing.timing_overhead;
+    diff -= __proc_global_info.tsc_overhead;
        if ((int64_t) diff < 0) {
                return 1;
        }
        return diff;
 }
 
+static inline __attribute__((always_inline))
+uint64_t nsec(void)
+{
+       return tsc2nsec(read_tsc());
+}
+
+
 /* Ancient measurement crap below.  TODO: use or lose it */
 
 #if 0
@@ -86,9 +131,8 @@ typedef struct Timer{
        _timer_##tag->curr_run = start_timing();
 #define TAGGED_TIMING_END(tag)                                              \
 ({                                                                          \
-       _timer_##tag->curr_run = stop_timing(_timer_##tag->curr_run);           \
-       _timer_##tag->aggr_run += _timer_##tag->curr_run;                       \
+       _timer_##tag->curr_run = stop_timing(_timer_##tag->curr_run);       \
+       _timer_##tag->aggr_run += _timer_##tag->curr_run;                   \
 })
 
 #endif
-#endif /* ROS_KERN_TIME_H */