--- /dev/null
+// -*- 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
Code Review / stor4nfv.git / blobdiff