X-Git-Url: https://gerrit.opnfv.org/gerrit/gitweb?a=blobdiff_plain;f=src%2Fceph%2Fsrc%2Fcommon%2Fceph_time.h;fp=src%2Fceph%2Fsrc%2Fcommon%2Fceph_time.h;h=8479a0d5494c62beb7c9caa88ce4fafd7fd7a22b;hb=812ff6ca9fcd3e629e49d4328905f33eee8ca3f5;hp=0000000000000000000000000000000000000000;hpb=15280273faafb77777eab341909a3f495cf248d9;p=stor4nfv.git

diff --git a/src/ceph/src/common/ceph_time.h b/src/ceph/src/common/ceph_time.h
new file mode 100644
index 0000000..8479a0d
--- /dev/null
+++ b/src/ceph/src/common/ceph_time.h
@@ -0,0 +1,509 @@
+// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
+// vim: ts=8 sw=2 smarttab
+/*
+ * Ceph - scalable distributed file system
+ *
+ * Copyright (C) 2004-2006 Sage Weil <sage@newdream.net>
+ *
+ * This is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License version 2.1, as published by the Free Software
+ * Foundation.	See file COPYING.
+ *
+ */
+
+#ifndef COMMON_CEPH_TIME_H
+#define COMMON_CEPH_TIME_H
+
+#include <chrono>
+
+#include "include/encoding.h"
+
+#if defined(DARWIN)
+#include <sys/_types/_timespec.h>
+#include <mach/mach.h>
+#include <mach/clock.h>
+
+#define CLOCK_REALTIME CALENDAR_CLOCK
+#define CLOCK_MONOTONIC SYSTEM_CLOCK
+#define CLOCK_REALTIME_COARSE CLOCK_REALTIME
+#define CLOCK_MONOTONIC_COARSE CLOCK_MONOTONIC
+
+int clock_gettime(int clk_id, struct timespec *tp);
+#endif
+
+struct ceph_timespec;
+
+namespace ceph {
+  namespace time_detail {
+    using std::chrono::duration_cast;
+    using std::chrono::seconds;
+    using std::chrono::microseconds;
+    using std::chrono::nanoseconds;
+    // Currently we use a 64-bit count of nanoseconds.
+
+    // We could, if we wished, use a struct holding a uint64_t count
+    // of seconds and a uint32_t count of nanoseconds.
+
+    // At least this way we can change it to something else if we
+    // want.
+    typedef uint64_t rep;
+
+    // A concrete duration, unsigned. The timespan Ceph thinks in.
+    typedef std::chrono::duration<rep, std::nano> timespan;
+
+
+    // Like the above but signed.
+    typedef int64_t signed_rep;
+
+    typedef std::chrono::duration<signed_rep, std::nano> signedspan;
+
+    // We define our own clocks so we can have our choice of all time
+    // sources supported by the operating system. With the standard
+    // library the resolution and cost are unspecified. (For example,
+    // the libc++ system_clock class gives only microsecond
+    // resolution.)
+
+    // One potential issue is that we should accept system_clock
+    // timepoints in user-facing APIs alongside (or instead of)
+    // ceph::real_clock times.
+    class real_clock {
+    public:
+      typedef timespan duration;
+      typedef duration::rep rep;
+      typedef duration::period period;
+      // The second template parameter defaults to the clock's duration
+      // type.
+      typedef std::chrono::time_point<real_clock> time_point;
+      static constexpr const bool is_steady = false;
+
+      static time_point now() noexcept {
+	struct timespec ts;
+	clock_gettime(CLOCK_REALTIME, &ts);
+	return from_timespec(ts);
+      }
+
+      static bool is_zero(const time_point& t) {
+	return (t == time_point::min());
+      }
+
+      // Allow conversion to/from any clock with the same interface as
+      // std::chrono::system_clock)
+      template<typename Clock, typename Duration>
+      static time_point to_system_time_point(
+	const std::chrono::time_point<Clock, Duration>& t) {
+	return time_point(seconds(Clock::to_time_t(t)) +
+			  duration_cast<duration>(t.time_since_epoch() %
+						  seconds(1)));
+      }
+      template<typename Clock, typename Duration>
+      static std::chrono::time_point<Clock, Duration> to_system_time_point(
+	const time_point& t) {
+	return (Clock::from_time_t(to_time_t(t)) +
+		duration_cast<Duration>(t.time_since_epoch() % seconds(1)));
+      }
+
+      static time_t to_time_t(const time_point& t) noexcept {
+	return duration_cast<seconds>(t.time_since_epoch()).count();
+      }
+      static time_point from_time_t(const time_t& t) noexcept {
+	return time_point(seconds(t));
+      }
+
+      static void to_timespec(const time_point& t, struct timespec& ts) {
+	ts.tv_sec = to_time_t(t);
+	ts.tv_nsec = (t.time_since_epoch() % seconds(1)).count();
+      }
+      static struct timespec to_timespec(const time_point& t) {
+	struct timespec ts;
+	to_timespec(t, ts);
+	return ts;
+      }
+      static time_point from_timespec(const struct timespec& ts) {
+	return time_point(seconds(ts.tv_sec) + nanoseconds(ts.tv_nsec));
+      }
+
+      static void to_ceph_timespec(const time_point& t,
+				   struct ceph_timespec& ts);
+      static struct ceph_timespec to_ceph_timespec(const time_point& t);
+      static time_point from_ceph_timespec(const struct ceph_timespec& ts);
+
+      static void to_timeval(const time_point& t, struct timeval& tv) {
+	tv.tv_sec = to_time_t(t);
+	tv.tv_usec = duration_cast<microseconds>(t.time_since_epoch() %
+						 seconds(1)).count();
+      }
+      static struct timeval to_timeval(const time_point& t) {
+	struct timeval tv;
+	to_timeval(t, tv);
+	return tv;
+      }
+      static time_point from_timeval(const struct timeval& tv) {
+	return time_point(seconds(tv.tv_sec) + microseconds(tv.tv_usec));
+      }
+
+      static double to_double(const time_point& t) {
+	return std::chrono::duration<double>(t.time_since_epoch()).count();
+      }
+      static time_point from_double(const double d) {
+	return time_point(duration_cast<duration>(
+			    std::chrono::duration<double>(d)));
+      }
+    };
+
+    class coarse_real_clock {
+    public:
+      typedef timespan duration;
+      typedef duration::rep rep;
+      typedef duration::period period;
+      // The second template parameter defaults to the clock's duration
+      // type.
+      typedef std::chrono::time_point<coarse_real_clock> time_point;
+      static constexpr const bool is_steady = false;
+
+      static time_point now() noexcept {
+	struct timespec ts;
+#if defined(CLOCK_REALTIME_COARSE)
+	// Linux systems have _COARSE clocks.
+	clock_gettime(CLOCK_REALTIME_COARSE, &ts);
+#elif defined(CLOCK_REALTIME_FAST)
+	// BSD systems have _FAST clocks.
+	clock_gettime(CLOCK_REALTIME_FAST, &ts);
+#else
+	// And if we find neither, you may wish to consult your system's
+	// documentation.
+#warning Falling back to CLOCK_REALTIME, may be slow.
+	clock_gettime(CLOCK_REALTIME, &ts);
+#endif
+	return from_timespec(ts);
+      }
+
+      static time_t to_time_t(const time_point& t) noexcept {
+	return duration_cast<seconds>(t.time_since_epoch()).count();
+      }
+      static time_point from_time_t(const time_t t) noexcept {
+	return time_point(seconds(t));
+      }
+
+      static void to_timespec(const time_point& t, struct timespec& ts) {
+	ts.tv_sec = to_time_t(t);
+	ts.tv_nsec = (t.time_since_epoch() % seconds(1)).count();
+      }
+      static struct timespec to_timespec(const time_point& t) {
+	struct timespec ts;
+	to_timespec(t, ts);
+	return ts;
+      }
+      static time_point from_timespec(const struct timespec& ts) {
+	return time_point(seconds(ts.tv_sec) + nanoseconds(ts.tv_nsec));
+      }
+
+      static void to_ceph_timespec(const time_point& t,
+				   struct ceph_timespec& ts);
+      static struct ceph_timespec to_ceph_timespec(const time_point& t);
+      static time_point from_ceph_timespec(const struct ceph_timespec& ts);
+
+      static void to_timeval(const time_point& t, struct timeval& tv) {
+	tv.tv_sec = to_time_t(t);
+	tv.tv_usec = duration_cast<microseconds>(t.time_since_epoch() %
+						 seconds(1)).count();
+      }
+      static struct timeval to_timeval(const time_point& t) {
+	struct timeval tv;
+	to_timeval(t, tv);
+	return tv;
+      }
+      static time_point from_timeval(const struct timeval& tv) {
+	return time_point(seconds(tv.tv_sec) + microseconds(tv.tv_usec));
+      }
+
+      static double to_double(const time_point& t) {
+	return std::chrono::duration<double>(t.time_since_epoch()).count();
+      }
+      static time_point from_double(const double d) {
+	return time_point(duration_cast<duration>(
+			    std::chrono::duration<double>(d)));
+      }
+    };
+
+    class mono_clock {
+    public:
+      typedef timespan duration;
+      typedef duration::rep rep;
+      typedef duration::period period;
+      typedef std::chrono::time_point<mono_clock> time_point;
+      static constexpr const bool is_steady = true;
+
+      static time_point now() noexcept {
+	struct timespec ts;
+	clock_gettime(CLOCK_MONOTONIC, &ts);
+	return time_point(seconds(ts.tv_sec) + nanoseconds(ts.tv_nsec));
+      }
+
+      // A monotonic clock's timepoints are only meaningful to the
+      // computer on which they were generated. Thus having an
+      // optional skew is meaningless.
+    };
+
+    class coarse_mono_clock {
+    public:
+      typedef timespan duration;
+      typedef duration::rep rep;
+      typedef duration::period period;
+      typedef std::chrono::time_point<coarse_mono_clock> time_point;
+      static constexpr const bool is_steady = true;
+
+      static time_point now() noexcept {
+	struct timespec ts;
+#if defined(CLOCK_MONOTONIC_COARSE)
+	// Linux systems have _COARSE clocks.
+	clock_gettime(CLOCK_MONOTONIC_COARSE, &ts);
+#elif defined(CLOCK_MONOTONIC_FAST)
+	// BSD systems have _FAST clocks.
+	clock_gettime(CLOCK_MONOTONIC_FAST, &ts);
+#else
+	// And if we find neither, you may wish to consult your system's
+	// documentation.
+#warning Falling back to CLOCK_MONOTONIC, may be slow.
+	clock_gettime(CLOCK_MONOTONIC, &ts);
+#endif
+	return time_point(seconds(ts.tv_sec) + nanoseconds(ts.tv_nsec));
+      }
+    };
+
+    // So that our subtractions produce negative spans rather than
+    // arithmetic underflow.
+    namespace {
+      template<typename Rep1, typename Period1, typename Rep2,
+	       typename Period2>
+      inline auto difference(std::chrono::duration<Rep1, Period1> minuend,
+			     std::chrono::duration<Rep2, Period2> subtrahend)
+	-> typename std::common_type<
+	  std::chrono::duration<typename std::make_signed<Rep1>::type,
+				Period1>,
+	  std::chrono::duration<typename std::make_signed<Rep2>::type,
+				Period2> >::type {
+	// Foo.
+	using srep =
+	  typename std::common_type<
+	    std::chrono::duration<typename std::make_signed<Rep1>::type,
+				  Period1>,
+	    std::chrono::duration<typename std::make_signed<Rep2>::type,
+				  Period2> >::type;
+	return srep(srep(minuend).count() - srep(subtrahend).count());
+      }
+
+      template<typename Clock, typename Duration1, typename Duration2>
+      inline auto difference(
+	typename std::chrono::time_point<Clock, Duration1> minuend,
+	typename std::chrono::time_point<Clock, Duration2> subtrahend)
+	-> typename std::common_type<
+	  std::chrono::duration<typename std::make_signed<
+				  typename Duration1::rep>::type,
+				typename Duration1::period>,
+	  std::chrono::duration<typename std::make_signed<
+				  typename Duration2::rep>::type,
+				typename Duration2::period> >::type {
+	return difference(minuend.time_since_epoch(),
+			  subtrahend.time_since_epoch());
+      }
+    }
+  } // namespace time_detail
+
+  // duration is the concrete time representation for our code in the
+  // case that we are only interested in durations between now and the
+  // future. Using it means we don't have to have EVERY function that
+  // deals with a duration be a template. We can do so for user-facing
+  // APIs, however.
+  using time_detail::timespan;
+
+  // Similar to the above but for durations that can specify
+  // differences between now and a time point in the past.
+  using time_detail::signedspan;
+
+  // High-resolution real-time clock
+  using time_detail::real_clock;
+
+  // Low-resolution but preusmably faster real-time clock
+  using time_detail::coarse_real_clock;
+
+
+  // High-resolution monotonic clock
+  using time_detail::mono_clock;
+
+  // Low-resolution but, I would hope or there's no point, faster
+  // monotonic clock
+  using time_detail::coarse_mono_clock;
+
+  // Please note that the coarse clocks are disjoint. You cannot
+  // subtract a real_clock timepoint from a coarse_real_clock
+  // timepoint as, from C++'s perspective, they are disjoint types.
+
+  // This is not necessarily bad. If I sample a mono_clock and then a
+  // coarse_mono_clock, the coarse_mono_clock's time could potentially
+  // be previous to the mono_clock's time (just due to differing
+  // resolution) which would be Incorrect.
+
+  // This is not horrible, though, since you can use an idiom like
+  // mono_clock::timepoint(coarsepoint.time_since_epoch()) to unwrap
+  // and rewrap if you know what you're doing.
+
+
+  // Actual wall-clock times
+  typedef real_clock::time_point real_time;
+  typedef coarse_real_clock::time_point coarse_real_time;
+
+  // Monotonic times should never be serialized or communicated
+  // between machines, since they are incomparable. Thus we also don't
+  // make any provision for converting between
+  // std::chrono::steady_clock time and ceph::mono_clock time.
+  typedef mono_clock::time_point mono_time;
+  typedef coarse_mono_clock::time_point coarse_mono_time;
+
+  template<typename Rep1, typename Ratio1, typename Rep2, typename Ratio2>
+  auto floor(const std::chrono::duration<Rep1, Ratio1>& duration,
+	     const std::chrono::duration<Rep2, Ratio2>& precision) ->
+    typename std::common_type<std::chrono::duration<Rep1, Ratio1>,
+			      std::chrono::duration<Rep2, Ratio2> >::type {
+    return duration - (duration % precision);
+  }
+
+  template<typename Rep1, typename Ratio1, typename Rep2, typename Ratio2>
+  auto ceil(const std::chrono::duration<Rep1, Ratio1>& duration,
+	    const std::chrono::duration<Rep2, Ratio2>& precision) ->
+    typename std::common_type<std::chrono::duration<Rep1, Ratio1>,
+			      std::chrono::duration<Rep2, Ratio2> >::type {
+    auto tmod = duration % precision;
+    return duration - tmod + (tmod > tmod.zero() ? 1 : 0) * precision;
+  }
+
+  template<typename Clock, typename Duration, typename Rep, typename Ratio>
+  auto floor(const std::chrono::time_point<Clock, Duration>& timepoint,
+	     const std::chrono::duration<Rep, Ratio>& precision) ->
+    std::chrono::time_point<Clock,
+			    typename std::common_type<
+			      Duration, std::chrono::duration<Rep, Ratio>
+			      >::type> {
+    return std::chrono::time_point<
+      Clock, typename std::common_type<
+	Duration, std::chrono::duration<Rep, Ratio> >::type>(
+	  floor(timepoint.time_since_epoch(), precision));
+  }
+  template<typename Clock, typename Duration, typename Rep, typename Ratio>
+  auto ceil(const std::chrono::time_point<Clock, Duration>& timepoint,
+	    const std::chrono::duration<Rep, Ratio>& precision) ->
+    std::chrono::time_point<Clock,
+			    typename std::common_type<
+			      Duration,
+			      std::chrono::duration<Rep, Ratio> >::type> {
+    return std::chrono::time_point<
+      Clock, typename std::common_type<
+	Duration, std::chrono::duration<Rep, Ratio> >::type>(
+	  ceil(timepoint.time_since_epoch(), precision));
+  }
+
+  namespace {
+    inline timespan make_timespan(const double d) {
+      return std::chrono::duration_cast<timespan>(
+	std::chrono::duration<double>(d));
+    }
+  }
+
+  std::ostream& operator<<(std::ostream& m, const timespan& t);
+  template<typename Clock,
+	   typename std::enable_if<!Clock::is_steady>::type* = nullptr>
+  std::ostream& operator<<(std::ostream& m,
+			   const std::chrono::time_point<Clock>& t);
+  template<typename Clock,
+	   typename std::enable_if<Clock::is_steady>::type* = nullptr>
+  std::ostream& operator<<(std::ostream& m,
+			   const std::chrono::time_point<Clock>& t);
+
+  // The way std::chrono handles the return type of subtraction is not
+  // wonderful. The difference of two unsigned types SHOULD be signed.
+
+  namespace {
+    inline signedspan operator -(real_time minuend,
+				 real_time subtrahend) {
+      return time_detail::difference(minuend, subtrahend);
+    }
+
+    inline signedspan operator -(coarse_real_time minuend,
+				 coarse_real_time subtrahend) {
+      return time_detail::difference(minuend, subtrahend);
+    }
+
+    inline signedspan operator -(mono_time minuend,
+				 mono_time subtrahend) {
+      return time_detail::difference(minuend, subtrahend);
+    }
+
+    inline signedspan operator -(coarse_mono_time minuend,
+				 coarse_mono_time subtrahend) {
+      return time_detail::difference(minuend, subtrahend);
+    }
+  }
+
+  // We could add specializations of time_point - duration and
+  // time_point + duration to assert on overflow, but I don't think we
+  // should.
+
+} // namespace ceph
+
+// We need these definitions to be able to hande ::encode/::decode on
+// time points.
+
+template<typename Clock, typename Duration>
+void encode(const std::chrono::time_point<Clock, Duration>& t,
+	    ceph::bufferlist &bl) {
+  auto ts = Clock::to_timespec(t);
+  // A 32 bit count of seconds causes me vast unhappiness.
+  uint32_t s = ts.tv_sec;
+  uint32_t ns = ts.tv_nsec;
+  ::encode(s, bl);
+  ::encode(ns, bl);
+}
+
+template<typename Clock, typename Duration>
+void decode(std::chrono::time_point<Clock, Duration>& t,
+	    bufferlist::iterator& p) {
+  uint32_t s;
+  uint32_t ns;
+  ::decode(s, p);
+  ::decode(ns, p);
+  struct timespec ts = {
+    static_cast<time_t>(s),
+    static_cast<long int>(ns)};
+
+  t = Clock::from_timespec(ts);
+}
+
+// C++ Overload Resolution requires that our encode/decode functions
+// be defined in the same namespace as the type. So we need this
+// to handle things like ::encode(std::vector<ceph::real_time // > >)
+
+namespace std {
+  namespace chrono {
+    template<typename Clock, typename Duration>
+    void encode(const time_point<Clock, Duration>& t,
+		ceph::bufferlist &bl) {
+      ::encode(t, bl);
+    }
+
+    template<typename Clock, typename Duration>
+    void decode(time_point<Clock, Duration>& t, bufferlist::iterator &p) {
+      ::decode(t, p);
+    }
+  } // namespace chrono
+
+  // An overload of our own
+  namespace {
+    inline timespan abs(signedspan z) {
+      return z > signedspan::zero() ?
+	std::chrono::duration_cast<timespan>(z) :
+	timespan(-z.count());
+    }
+  }
+} // namespace std
+
+#endif // COMMON_CEPH_TIME_H