--- /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_TIMER_H
+#define COMMON_CEPH_TIMER_H
+
+#include <condition_variable>
+#include <thread>
+#include <boost/intrusive/set.hpp>
+
+namespace ceph {
+
+ /// Newly constructed timer should be suspended at point of
+ /// construction.
+
+ struct construct_suspended_t { };
+ constexpr construct_suspended_t construct_suspended { };
+
+ namespace timer_detail {
+ using boost::intrusive::member_hook;
+ using boost::intrusive::set_member_hook;
+ using boost::intrusive::link_mode;
+ using boost::intrusive::normal_link;
+ using boost::intrusive::set;
+ using boost::intrusive::constant_time_size;
+ using boost::intrusive::compare;
+
+ // Compared to the SafeTimer this does fewer allocations (you
+ // don't have to allocate a new Context every time you
+ // want to cue the next tick.)
+ //
+ // It also does not share a lock with the caller. If you call
+ // cancel event, it either cancels the event (and returns true) or
+ // you missed it. If this does not work for you, you can set up a
+ // flag and mutex of your own.
+ //
+ // You get to pick your clock. I like mono_clock, since I usually
+ // want to wait FOR a given duration. real_clock is worthwhile if
+ // you want to wait UNTIL a specific moment of wallclock time. If
+ // you want you can set up a timer that executes a function after
+ // you use up ten seconds of CPU time.
+
+ template <class TC>
+ class timer {
+ using sh = set_member_hook<link_mode<normal_link> >;
+
+ struct event {
+ typename TC::time_point t;
+ uint64_t id;
+ std::function<void()> f;
+
+ sh schedule_link;
+ sh event_link;
+
+ event() : t(TC::time_point::min()), id(0) {}
+ event(uint64_t _id) : t(TC::time_point::min()), id(_id) {}
+ event(typename TC::time_point _t, uint64_t _id,
+ std::function<void()>&& _f) : t(_t), id(_id), f(_f) {}
+ event(typename TC::time_point _t, uint64_t _id,
+ const std::function<void()>& _f) : t(_t), id(_id), f(_f) {}
+ bool operator <(const event& e) {
+ return t == e.t ? id < e.id : t < e.t;
+ }
+ };
+ struct SchedCompare {
+ bool operator()(const event& e1, const event& e2) const {
+ return e1.t == e2.t ? e1.id < e2.id : e1.t < e2.t;
+ }
+ };
+ struct EventCompare {
+ bool operator()(const event& e1, const event& e2) const {
+ return e1.id < e2.id;
+ }
+ };
+
+ using schedule_type = set<event,
+ member_hook<event, sh, &event::schedule_link>,
+ constant_time_size<false>,
+ compare<SchedCompare> >;
+
+ schedule_type schedule;
+
+ using event_set_type = set<event,
+ member_hook<event, sh, &event::event_link>,
+ constant_time_size<false>,
+ compare<EventCompare> >;
+
+ event_set_type events;
+
+ std::mutex lock;
+ using lock_guard = std::lock_guard<std::mutex>;
+ using unique_lock = std::unique_lock<std::mutex>;
+ std::condition_variable cond;
+
+ event* running{ nullptr };
+ uint64_t next_id{ 0 };
+
+ bool suspended;
+ std::thread thread;
+
+ void timer_thread() {
+ unique_lock l(lock);
+ while (!suspended) {
+ typename TC::time_point now = TC::now();
+
+ while (!schedule.empty()) {
+ auto p = schedule.begin();
+ // Should we wait for the future?
+ if (p->t > now)
+ break;
+
+ event& e = *p;
+ schedule.erase(e);
+ events.erase(e);
+
+ // Since we have only one thread it is impossible to have more
+ // than one running event
+ running = &e;
+
+ l.unlock();
+ e.f();
+ l.lock();
+
+ if (running) {
+ running = nullptr;
+ delete &e;
+ } // Otherwise the event requeued itself
+ }
+
+ if (schedule.empty())
+ cond.wait(l);
+ else
+ cond.wait_until(l, schedule.begin()->t);
+ }
+ }
+
+ public:
+ timer() {
+ lock_guard l(lock);
+ suspended = false;
+ thread = std::thread(&timer::timer_thread, this);
+ }
+
+ // Create a suspended timer, jobs will be executed in order when
+ // it is resumed.
+ timer(construct_suspended_t) {
+ lock_guard l(lock);
+ suspended = true;
+ }
+
+ timer(const timer &) = delete;
+ timer& operator=(const timer &) = delete;
+
+ ~timer() {
+ suspend();
+ cancel_all_events();
+ }
+
+ // Suspend operation of the timer (and let its thread die).
+ void suspend() {
+ unique_lock l(lock);
+ if (suspended)
+ return;
+
+ suspended = true;
+ cond.notify_one();
+ l.unlock();
+ thread.join();
+ }
+
+
+ // Resume operation of the timer. (Must have been previously
+ // suspended.)
+ void resume() {
+ unique_lock l(lock);
+ if (!suspended)
+ return;
+
+ suspended = false;
+ assert(!thread.joinable());
+ thread = std::thread(&timer::timer_thread, this);
+ }
+
+ // Schedule an event in the relative future
+ template<typename Callable, typename... Args>
+ uint64_t add_event(typename TC::duration duration,
+ Callable&& f, Args&&... args) {
+ typename TC::time_point when = TC::now();
+ when += duration;
+ return add_event(when,
+ std::forward<Callable>(f),
+ std::forward<Args>(args)...);
+ }
+
+ // Schedule an event in the absolute future
+ template<typename Callable, typename... Args>
+ uint64_t add_event(typename TC::time_point when,
+ Callable&& f, Args&&... args) {
+ std::lock_guard<std::mutex> l(lock);
+ event& e = *(new event(
+ when, ++next_id,
+ std::forward<std::function<void()> >(
+ std::bind(std::forward<Callable>(f),
+ std::forward<Args>(args)...))));
+ auto i = schedule.insert(e);
+ events.insert(e);
+
+ /* If the event we have just inserted comes before everything
+ * else, we need to adjust our timeout. */
+ if (i.first == schedule.begin())
+ cond.notify_one();
+
+ // Previously each event was a context, identified by a
+ // pointer, and each context to be called only once. Since you
+ // can queue the same function pointer, member function,
+ // lambda, or functor up multiple times, identifying things by
+ // function for the purposes of cancellation is no longer
+ // suitable. Thus:
+ return e.id;
+ }
+
+ // Adjust the timeout of a currently-scheduled event (relative)
+ bool adjust_event(uint64_t id, typename TC::duration duration) {
+ return adjust_event(id, TC::now() + duration);
+ }
+
+ // Adjust the timeout of a currently-scheduled event (absolute)
+ bool adjust_event(uint64_t id, typename TC::time_point when) {
+ std::lock_guard<std::mutex> l(lock);
+
+ event key(id);
+ typename event_set_type::iterator it = events.find(key);
+
+ if (it == events.end())
+ return false;
+
+ event& e = *it;
+
+ schedule.erase(e);
+ e.t = when;
+ schedule.insert(e);
+
+ return true;
+ }
+
+ // Cancel an event. If the event has already come and gone (or you
+ // never submitted it) you will receive false. Otherwise you will
+ // receive true and it is guaranteed the event will not execute.
+ bool cancel_event(const uint64_t id) {
+ std::lock_guard<std::mutex> l(lock);
+ event dummy(id);
+ auto p = events.find(dummy);
+ if (p == events.end()) {
+ return false;
+ }
+
+ event& e = *p;
+ events.erase(e);
+ schedule.erase(e);
+ delete &e;
+
+ return true;
+ }
+
+ // Reschedules a currently running event in the relative
+ // future. Must be called only from an event executed by this
+ // timer. If you have a function that can be called either from
+ // this timer or some other way, it is your responsibility to make
+ // sure it can tell the difference only does not call
+ // reschedule_me in the non-timer case.
+ //
+ // Returns an event id. If you had an event_id from the first
+ // scheduling, replace it with this return value.
+ uint64_t reschedule_me(typename TC::duration duration) {
+ return reschedule_me(TC::now() + duration);
+ }
+
+ // Reschedules a currently running event in the absolute
+ // future. Must be called only from an event executed by this
+ // timer. if you have a function that can be called either from
+ // this timer or some other way, it is your responsibility to make
+ // sure it can tell the difference only does not call
+ // reschedule_me in the non-timer case.
+ //
+ // Returns an event id. If you had an event_id from the first
+ // scheduling, replace it with this return value.
+ uint64_t reschedule_me(typename TC::time_point when) {
+ if (std::this_thread::get_id() != thread.get_id())
+ throw std::make_error_condition(std::errc::operation_not_permitted);
+ std::lock_guard<std::mutex> l(lock);
+ running->t = when;
+ uint64_t id = ++next_id;
+ running->id = id;
+ schedule.insert(*running);
+ events.insert(*running);
+
+ // Hacky, but keeps us from being deleted
+ running = nullptr;
+
+ // Same function, but you get a new ID.
+ return id;
+ }
+
+ // Remove all events from the queue.
+ void cancel_all_events() {
+ std::lock_guard<std::mutex> l(lock);
+ while (!events.empty()) {
+ auto p = events.begin();
+ event& e = *p;
+ schedule.erase(e);
+ events.erase(e);
+ delete &e;
+ }
+ }
+ }; // timer
+ }; // timer_detail
+
+ using timer_detail::timer;
+}; // ceph
+
+#endif
Code Review / stor4nfv.git / blobdiff