Use the std::chrono::steady_clock for timers (#60)

an-tao · web-flow · commit 374acaa8aa39 · 2019-11-28T14:31:31.000+08:00
diff --git a/trantor/net/EventLoop.cc b/trantor/net/EventLoop.cc
@@ -219,11 +219,23 @@ void EventLoop::queueInLoop(Func &&cb)
 
 TimerId EventLoop::runAt(const Date &time, const Func &cb)
 {
-    return timerQueue_->addTimer(cb, time, 0);
+    auto microSeconds =
+        time.microSecondsSinceEpoch() - Date::now().microSecondsSinceEpoch();
+    std::chrono::steady_clock::time_point tp =
+        std::chrono::steady_clock::now() +
+        std::chrono::microseconds(microSeconds);
+    return timerQueue_->addTimer(cb, tp, std::chrono::microseconds(0));
 }
 TimerId EventLoop::runAt(const Date &time, Func &&cb)
 {
-    return timerQueue_->addTimer(std::move(cb), time, 0);
+    auto microSeconds =
+        time.microSecondsSinceEpoch() - Date::now().microSecondsSinceEpoch();
+    std::chrono::steady_clock::time_point tp =
+        std::chrono::steady_clock::now() +
+        std::chrono::microseconds(microSeconds);
+    return timerQueue_->addTimer(std::move(cb),
+                                 tp,
+                                 std::chrono::microseconds(0));
 }
 TimerId EventLoop::runAfter(double delay, const Func &cb)
 {
@@ -235,13 +247,17 @@ TimerId EventLoop::runAfter(double delay, Func &&cb)
 }
 TimerId EventLoop::runEvery(double interval, const Func &cb)
 {
-    return timerQueue_->addTimer(cb, Date::date().after(interval), interval);
+    std::chrono::microseconds dur(
+        static_cast<std::chrono::microseconds::rep>(interval * 1000000));
+    auto tp = std::chrono::steady_clock::now() + dur;
+    return timerQueue_->addTimer(cb, tp, dur);
 }
 TimerId EventLoop::runEvery(double interval, Func &&cb)
 {
-    return timerQueue_->addTimer(std::move(cb),
-                                 Date::date().after(interval),
-                                 interval);
+    std::chrono::microseconds dur(
+        static_cast<std::chrono::microseconds::rep>(interval * 1000000));
+    auto tp = std::chrono::steady_clock::now() + dur;
+    return timerQueue_->addTimer(std::move(cb), tp, dur);
 }
 void EventLoop::invalidateTimer(TimerId id)
 {
diff --git a/trantor/net/inner/Timer.cc b/trantor/net/inner/Timer.cc
@@ -19,19 +19,23 @@
 namespace trantor
 {
 std::atomic<TimerId> Timer::timersCreated_ = ATOMIC_VAR_INIT(InvalidTimerId);
-Timer::Timer(const TimerCallback &cb, const Date &when, double interval)
+Timer::Timer(const TimerCallback &cb,
+             const TimePoint &when,
+             const TimeInterval &interval)
     : callback_(cb),
       when_(when),
       interval_(interval),
-      repeat_(interval > 0.0),
+      repeat_(interval.count() > 0),
       id_(++timersCreated_)
 {
 }
-Timer::Timer(TimerCallback &&cb, const Date &when, double interval)
+Timer::Timer(TimerCallback &&cb,
+             const TimePoint &when,
+             const TimeInterval &interval)
     : callback_(std::move(cb)),
       when_(when),
       interval_(interval),
-      repeat_(interval > 0.0),
+      repeat_(interval.count() > 0),
       id_(++timersCreated_)
 {
     // LOG_TRACE<<"Timer move contrustor";
@@ -40,14 +44,14 @@ void Timer::run() const
 {
     callback_();
 }
-void Timer::restart(const Date &now)
+void Timer::restart(const TimePoint &now)
 {
     if (repeat_)
     {
-        when_ = now.after(interval_);
+        when_ = now + interval_;
     }
     else
-        when_ = Date();
+        when_ = std::chrono::steady_clock::now();
 }
 bool Timer::operator<(const Timer &t) const
 {
diff --git a/trantor/net/inner/Timer.h b/trantor/net/inner/Timer.h
@@ -14,31 +14,36 @@
 
 #pragma once
 
-#include <trantor/utils/Date.h>
 #include <trantor/utils/NonCopyable.h>
 #include <trantor/net/callbacks.h>
 #include <functional>
 #include <atomic>
 #include <iostream>
+#include <chrono>
 
 namespace trantor
 {
 using TimerId = uint64_t;
-
+using TimePoint = std::chrono::steady_clock::time_point;
+using TimeInterval = std::chrono::microseconds;
 class Timer : public NonCopyable
 {
   public:
-    Timer(const TimerCallback &cb, const Date &when, double interval);
-    Timer(TimerCallback &&cb, const Date &when, double interval);
+    Timer(const TimerCallback &cb,
+          const TimePoint &when,
+          const TimeInterval &interval);
+    Timer(TimerCallback &&cb,
+          const TimePoint &when,
+          const TimeInterval &interval);
     ~Timer()
     {
         //   std::cout<<"Timer unconstract!"<<std::endl;
     }
     void run() const;
-    void restart(const Date &now);
+    void restart(const TimePoint &now);
     bool operator<(const Timer &t) const;
     bool operator>(const Timer &t) const;
-    const Date &when() const
+    const TimePoint &when() const
     {
         return when_;
     }
@@ -53,8 +58,8 @@ class Timer : public NonCopyable
 
   private:
     TimerCallback callback_;
-    Date when_;
-    const double interval_;
+    TimePoint when_;
+    const TimeInterval interval_;
     const bool repeat_;
     const TimerId id_;
     static std::atomic<TimerId> timersCreated_;
diff --git a/trantor/net/inner/TimerQueue.cc b/trantor/net/inner/TimerQueue.cc
@@ -35,20 +35,21 @@ int createTimerfd()
     return timerfd;
 }
 
-struct timespec howMuchTimeFromNow(const Date &when)
+struct timespec howMuchTimeFromNow(const TimePoint &when)
 {
-    int64_t microseconds =
-        when.microSecondsSinceEpoch() - Date::date().microSecondsSinceEpoch();
-    if (microseconds < 100)
+    auto microSeconds = std::chrono::duration_cast<std::chrono::microseconds>(
+                            when - std::chrono::steady_clock::now())
+                            .count();
+    if (microSeconds < 100)
     {
-        microseconds = 100;
+        microSeconds = 100;
     }
     struct timespec ts;
-    ts.tv_sec = static_cast<time_t>(microseconds / 1000000);
-    ts.tv_nsec = static_cast<long>((microseconds % 1000000) * 1000);
+    ts.tv_sec = static_cast<time_t>(microSeconds / 1000000);
+    ts.tv_nsec = static_cast<long>((microSeconds % 1000000) * 1000);
     return ts;
 }
-void resetTimerfd(int timerfd, const Date &expiration)
+void resetTimerfd(int timerfd, const TimePoint &expiration)
 {
     // wake up loop by timerfd_settime()
     struct itimerspec newValue;
@@ -62,12 +63,10 @@ void resetTimerfd(int timerfd, const Date &expiration)
         // LOG_SYSERR << "timerfd_settime()";
     }
 }
-void readTimerfd(int timerfd, const Date &now)
+void readTimerfd(int timerfd, const TimePoint &now)
 {
     uint64_t howmany;
     ssize_t n = ::read(timerfd, &howmany, sizeof howmany);
-    LOG_TRACE << "TimerQueue::handleRead() " << howmany << " at "
-              << now.toFormattedString(true);
     if (n != sizeof howmany)
     {
         LOG_ERROR << "TimerQueue::handleRead() reads " << n
@@ -78,7 +77,7 @@ void readTimerfd(int timerfd, const Date &now)
 void TimerQueue::handleRead()
 {
     loop_->assertInLoopThread();
-    const Date now = Date::date();
+    const auto now = std::chrono::steady_clock::now();
     readTimerfd(timerfd_, now);
 
     std::vector<TimerPtr> expired = getExpired(now);
@@ -98,20 +97,21 @@ void TimerQueue::handleRead()
     reset(expired, now);
 }
 #else
-int howMuchTimeFromNow(const Date &when)
+int64_t howMuchTimeFromNow(const TimePoint &when)
 {
-    int64_t microSeconds =
-        when.microSecondsSinceEpoch() - Date::date().microSecondsSinceEpoch();
+    auto microSeconds = std::chrono::duration_cast<std::chrono::microseconds>(
+                            when - std::chrono::steady_clock::now())
+                            .count();
     if (microSeconds < 1000)
     {
         microSeconds = 1000;
     }
-    return static_cast<int>(microSeconds / 1000);
+    return microSeconds / 1000;
 }
 void TimerQueue::processTimers()
 {
     loop_->assertInLoopThread();
-    const Date now = Date::date();
+    const auto now = std::chrono::steady_clock::now();
 
     std::vector<TimerPtr> expired = getExpired(now);
 
@@ -162,7 +162,7 @@ void TimerQueue::reset()
         timerfdChannelPtr_->enableReading();
         if (!timers_.empty())
         {
-            const Date nextExpire = timers_.top()->when();
+            const auto nextExpire = timers_.top()->when();
             resetTimerfd(timerfd_, nextExpire);
         }
     });
@@ -182,8 +182,8 @@ TimerQueue::~TimerQueue()
 }
 
 TimerId TimerQueue::addTimer(const TimerCallback &cb,
-                             const Date &when,
-                             double interval)
+                             const TimePoint &when,
+                             const TimeInterval &interval)
 {
     std::shared_ptr<Timer> timerPtr =
         std::make_shared<Timer>(cb, when, interval);
@@ -192,8 +192,8 @@ TimerId TimerQueue::addTimer(const TimerCallback &cb,
     return timerPtr->id();
 }
 TimerId TimerQueue::addTimer(TimerCallback &&cb,
-                             const Date &when,
-                             double interval)
+                             const TimePoint &when,
+                             const TimeInterval &interval)
 {
     std::shared_ptr<Timer> timerPtr =
         std::make_shared<Timer>(std::move(cb), when, interval);
@@ -233,7 +233,7 @@ bool TimerQueue::insert(const TimerPtr &timerPtr)
     return earliestChanged;
 }
 #ifndef __linux__
-int TimerQueue::getTimeout() const
+int64_t TimerQueue::getTimeout() const
 {
     loop_->assertInLoopThread();
     if (timers_.empty())
@@ -247,7 +247,7 @@ int TimerQueue::getTimeout() const
 }
 #endif
 
-std::vector<TimerPtr> TimerQueue::getExpired(const Date &now)
+std::vector<TimerPtr> TimerQueue::getExpired(const TimePoint &now)
 {
     std::vector<TimerPtr> expired;
     while (!timers_.empty())
@@ -262,7 +262,8 @@ std::vector<TimerPtr> TimerQueue::getExpired(const Date &now)
     }
     return expired;
 }
-void TimerQueue::reset(const std::vector<TimerPtr> &expired, const Date &now)
+void TimerQueue::reset(const std::vector<TimerPtr> &expired,
+                       const TimePoint &now)
 {
     loop_->assertInLoopThread();
     for (auto const &timerPtr : expired)
@@ -277,7 +278,7 @@ void TimerQueue::reset(const std::vector<TimerPtr> &expired, const Date &now)
 #ifdef __linux__
     if (!timers_.empty())
     {
-        const Date nextExpire = timers_.top()->when();
+        const auto nextExpire = timers_.top()->when();
         resetTimerfd(timerfd_, nextExpire);
     }
 #endif
diff --git a/trantor/net/inner/TimerQueue.h b/trantor/net/inner/TimerQueue.h
@@ -16,7 +16,6 @@
 
 #include <trantor/utils/NonCopyable.h>
 #include <trantor/net/callbacks.h>
-#include <trantor/utils/Date.h>
 #include "Timer.h"
 #include <queue>
 #include <memory>
@@ -42,15 +41,17 @@ class TimerQueue : NonCopyable
     explicit TimerQueue(EventLoop *loop);
     ~TimerQueue();
     TimerId addTimer(const TimerCallback &cb,
-                     const Date &when,
-                     double interval);
-    TimerId addTimer(TimerCallback &&cb, const Date &when, double interval);
+                     const TimePoint &when,
+                     const TimeInterval &interval);
+    TimerId addTimer(TimerCallback &&cb,
+                     const TimePoint &when,
+                     const TimeInterval &interval);
     void addTimerInLoop(const TimerPtr &timer);
     void invalidateTimer(TimerId id);
 #ifdef __linux__
     void reset();
 #else
-    int getTimeout() const;
+    int64_t getTimeout() const;
     void processTimers();
 #endif
   protected:
@@ -65,8 +66,8 @@ class TimerQueue : NonCopyable
     bool callingExpiredTimers_;
     bool insert(const TimerPtr &timePtr);
     std::vector<TimerPtr> getExpired();
-    void reset(const std::vector<TimerPtr> &expired, const Date &now);
-    std::vector<TimerPtr> getExpired(const Date &now);
+    void reset(const std::vector<TimerPtr> &expired, const TimePoint &now);
+    std::vector<TimerPtr> getExpired(const TimePoint &now);
 
   private:
     std::unordered_set<uint64_t> timerIdSet_;
diff --git a/trantor/tests/TimerTest.cc b/trantor/tests/TimerTest.cc
@@ -26,5 +26,7 @@ int main()
     loop.runAfter(5, []() { std::cout << "runAt 5s later" << std::endl; });
     loop.runEvery(1, []() { std::cout << "runEvery 1s" << std::endl; });
     loop.runAfter(4, []() { std::cout << "runAfter 4s" << std::endl; });
+    loop.runAfter(10min,
+                  []() { std::cout << "*********** run after 10 min\n"; });
     loop.loop();
 }

Original file line number	Diff line number	Diff line change
`@@ -219,11 +219,23 @@ void EventLoop::queueInLoop(Func &&cb)`
`219`	`219`
`220`	`220`	`TimerId EventLoop::runAt(const Date &time, const Func &cb)`
`221`	`221`	`{`
`222`		`- return timerQueue_->addTimer(cb, time, 0);`
	`222`	`+ auto microSeconds =`
	`223`	`+ time.microSecondsSinceEpoch() - Date::now().microSecondsSinceEpoch();`
	`224`	`+ std::chrono::steady_clock::time_point tp =`
	`225`	`+ std::chrono::steady_clock::now() +`
	`226`	`+ std::chrono::microseconds(microSeconds);`
	`227`	`+ return timerQueue_->addTimer(cb, tp, std::chrono::microseconds(0));`
`223`	`228`	`}`
`224`	`229`	`TimerId EventLoop::runAt(const Date &time, Func &&cb)`
`225`	`230`	`{`
`226`		`- return timerQueue_->addTimer(std::move(cb), time, 0);`
	`231`	`+ auto microSeconds =`
	`232`	`+ time.microSecondsSinceEpoch() - Date::now().microSecondsSinceEpoch();`
	`233`	`+ std::chrono::steady_clock::time_point tp =`
	`234`	`+ std::chrono::steady_clock::now() +`
	`235`	`+ std::chrono::microseconds(microSeconds);`
	`236`	`+ return timerQueue_->addTimer(std::move(cb),`
	`237`	`+ tp,`
	`238`	`+ std::chrono::microseconds(0));`
`227`	`239`	`}`
`228`	`240`	`TimerId EventLoop::runAfter(double delay, const Func &cb)`
`229`	`241`	`{`
`@@ -235,13 +247,17 @@ TimerId EventLoop::runAfter(double delay, Func &&cb)`
`235`	`247`	`}`
`236`	`248`	`TimerId EventLoop::runEvery(double interval, const Func &cb)`
`237`	`249`	`{`
`238`		`- return timerQueue_->addTimer(cb, Date::date().after(interval), interval);`
	`250`	`+ std::chrono::microseconds dur(`
	`251`	`+ static_cast<std::chrono::microseconds::rep>(interval * 1000000));`
	`252`	`+ auto tp = std::chrono::steady_clock::now() + dur;`
	`253`	`+ return timerQueue_->addTimer(cb, tp, dur);`
`239`	`254`	`}`
`240`	`255`	`TimerId EventLoop::runEvery(double interval, Func &&cb)`
`241`	`256`	`{`
`242`		`- return timerQueue_->addTimer(std::move(cb),`
`243`		`- Date::date().after(interval),`
`244`		`- interval);`
	`257`	`+ std::chrono::microseconds dur(`
	`258`	`+ static_cast<std::chrono::microseconds::rep>(interval * 1000000));`
	`259`	`+ auto tp = std::chrono::steady_clock::now() + dur;`
	`260`	`+ return timerQueue_->addTimer(std::move(cb), tp, dur);`
`245`	`261`	`}`
`246`	`262`	`void EventLoop::invalidateTimer(TimerId id)`
`247`	`263`	`{`
Original file line number	Diff line number	Diff line change
`@@ -19,19 +19,23 @@`
`19`	`19`	`namespace trantor`
`20`	`20`	`{`
`21`	`21`	`std::atomic<TimerId> Timer::timersCreated_ = ATOMIC_VAR_INIT(InvalidTimerId);`
`22`		`-Timer::Timer(const TimerCallback &cb, const Date &when, double interval)`
	`22`	`+Timer::Timer(const TimerCallback &cb,`
	`23`	`+ const TimePoint &when,`
	`24`	`+ const TimeInterval &interval)`
`23`	`25`	`: callback_(cb),`
`24`	`26`	`when_(when),`
`25`	`27`	`interval_(interval),`
`26`		`- repeat_(interval > 0.0),`
	`28`	`+ repeat_(interval.count() > 0),`
`27`	`29`	`id_(++timersCreated_)`
`28`	`30`	`{`
`29`	`31`	`}`
`30`		`-Timer::Timer(TimerCallback &&cb, const Date &when, double interval)`
	`32`	`+Timer::Timer(TimerCallback &&cb,`
	`33`	`+ const TimePoint &when,`
	`34`	`+ const TimeInterval &interval)`
`31`	`35`	`: callback_(std::move(cb)),`
`32`	`36`	`when_(when),`
`33`	`37`	`interval_(interval),`
`34`		`- repeat_(interval > 0.0),`
	`38`	`+ repeat_(interval.count() > 0),`
`35`	`39`	`id_(++timersCreated_)`
`36`	`40`	`{`
`37`	`41`	`// LOG_TRACE<<"Timer move contrustor";`
`@@ -40,14 +44,14 @@ void Timer::run() const`
`40`	`44`	`{`
`41`	`45`	`callback_();`
`42`	`46`	`}`
`43`		`-void Timer::restart(const Date &now)`
	`47`	`+void Timer::restart(const TimePoint &now)`
`44`	`48`	`{`
`45`	`49`	`if (repeat_)`
`46`	`50`	`{`
`47`		`- when_ = now.after(interval_);`
	`51`	`+ when_ = now + interval_;`
`48`	`52`	`}`
`49`	`53`	`else`
`50`		`- when_ = Date();`
	`54`	`+ when_ = std::chrono::steady_clock::now();`
`51`	`55`	`}`
`52`	`56`	`bool Timer::operator<(const Timer &t) const`
`53`	`57`	`{`
Original file line number	Diff line number	Diff line change
`@@ -35,20 +35,21 @@ int createTimerfd()`
`35`	`35`	`return timerfd;`
`36`	`36`	`}`
`37`	`37`
`38`		`-struct timespec howMuchTimeFromNow(const Date &when)`
	`38`	`+struct timespec howMuchTimeFromNow(const TimePoint &when)`
`39`	`39`	`{`
`40`		`- int64_t microseconds =`
`41`		`- when.microSecondsSinceEpoch() - Date::date().microSecondsSinceEpoch();`
`42`		`- if (microseconds < 100)`
	`40`	`+ auto microSeconds = std::chrono::duration_cast<std::chrono::microseconds>(`
	`41`	`+ when - std::chrono::steady_clock::now())`
	`42`	`+ .count();`
	`43`	`+ if (microSeconds < 100)`
`43`	`44`	`{`
`44`		`- microseconds = 100;`
	`45`	`+ microSeconds = 100;`
`45`	`46`	`}`
`46`	`47`	`struct timespec ts;`
`47`		`- ts.tv_sec = static_cast<time_t>(microseconds / 1000000);`
`48`		`- ts.tv_nsec = static_cast<long>((microseconds % 1000000) * 1000);`
	`48`	`+ ts.tv_sec = static_cast<time_t>(microSeconds / 1000000);`
	`49`	`+ ts.tv_nsec = static_cast<long>((microSeconds % 1000000) * 1000);`
`49`	`50`	`return ts;`
`50`	`51`	`}`
`51`		`-void resetTimerfd(int timerfd, const Date &expiration)`
	`52`	`+void resetTimerfd(int timerfd, const TimePoint &expiration)`
`52`	`53`	`{`
`53`	`54`	`// wake up loop by timerfd_settime()`
`54`	`55`	`struct itimerspec newValue;`
`@@ -62,12 +63,10 @@ void resetTimerfd(int timerfd, const Date &expiration)`
`62`	`63`	`// LOG_SYSERR << "timerfd_settime()";`
`63`	`64`	`}`
`64`	`65`	`}`
`65`		`-void readTimerfd(int timerfd, const Date &now)`
	`66`	`+void readTimerfd(int timerfd, const TimePoint &now)`
`66`	`67`	`{`
`67`	`68`	`uint64_t howmany;`
`68`	`69`	`ssize_t n = ::read(timerfd, &howmany, sizeof howmany);`
`69`		`- LOG_TRACE << "TimerQueue::handleRead() " << howmany << " at "`
`70`		`- << now.toFormattedString(true);`
`71`	`70`	`if (n != sizeof howmany)`
`72`	`71`	`{`
`73`	`72`	`LOG_ERROR << "TimerQueue::handleRead() reads " << n`
`@@ -78,7 +77,7 @@ void readTimerfd(int timerfd, const Date &now)`
`78`	`77`	`void TimerQueue::handleRead()`
`79`	`78`	`{`
`80`	`79`	`loop_->assertInLoopThread();`
`81`		`- const Date now = Date::date();`
	`80`	`+ const auto now = std::chrono::steady_clock::now();`
`82`	`81`	`readTimerfd(timerfd_, now);`
`83`	`82`
`84`	`83`	`std::vector<TimerPtr> expired = getExpired(now);`
`@@ -98,20 +97,21 @@ void TimerQueue::handleRead()`
`98`	`97`	`reset(expired, now);`
`99`	`98`	`}`
`100`	`99`	`#else`
`101`		`-int howMuchTimeFromNow(const Date &when)`
	`100`	`+int64_t howMuchTimeFromNow(const TimePoint &when)`
`102`	`101`	`{`
`103`		`- int64_t microSeconds =`
`104`		`- when.microSecondsSinceEpoch() - Date::date().microSecondsSinceEpoch();`
	`102`	`+ auto microSeconds = std::chrono::duration_cast<std::chrono::microseconds>(`
	`103`	`+ when - std::chrono::steady_clock::now())`
	`104`	`+ .count();`
`105`	`105`	`if (microSeconds < 1000)`
`106`	`106`	`{`
`107`	`107`	`microSeconds = 1000;`
`108`	`108`	`}`
`109`		`- return static_cast<int>(microSeconds / 1000);`
	`109`	`+ return microSeconds / 1000;`
`110`	`110`	`}`
`111`	`111`	`void TimerQueue::processTimers()`
`112`	`112`	`{`
`113`	`113`	`loop_->assertInLoopThread();`
`114`		`- const Date now = Date::date();`
	`114`	`+ const auto now = std::chrono::steady_clock::now();`
`115`	`115`
`116`	`116`	`std::vector<TimerPtr> expired = getExpired(now);`
`117`	`117`
`@@ -162,7 +162,7 @@ void TimerQueue::reset()`
`162`	`162`	`timerfdChannelPtr_->enableReading();`
`163`	`163`	`if (!timers_.empty())`
`164`	`164`	`{`
`165`		`- const Date nextExpire = timers_.top()->when();`
	`165`	`+ const auto nextExpire = timers_.top()->when();`
`166`	`166`	`resetTimerfd(timerfd_, nextExpire);`
`167`	`167`	`}`
`168`	`168`	`});`
`@@ -182,8 +182,8 @@ TimerQueue::~TimerQueue()`
`182`	`182`	`}`
`183`	`183`
`184`	`184`	`TimerId TimerQueue::addTimer(const TimerCallback &cb,`
`185`		`- const Date &when,`
`186`		`- double interval)`
	`185`	`+ const TimePoint &when,`
	`186`	`+ const TimeInterval &interval)`
`187`	`187`	`{`
`188`	`188`	`std::shared_ptr<Timer> timerPtr =`
`189`	`189`	`std::make_shared<Timer>(cb, when, interval);`
`@@ -192,8 +192,8 @@ TimerId TimerQueue::addTimer(const TimerCallback &cb,`
`192`	`192`	`return timerPtr->id();`
`193`	`193`	`}`
`194`	`194`	`TimerId TimerQueue::addTimer(TimerCallback &&cb,`
`195`		`- const Date &when,`
`196`		`- double interval)`
	`195`	`+ const TimePoint &when,`
	`196`	`+ const TimeInterval &interval)`
`197`	`197`	`{`
`198`	`198`	`std::shared_ptr<Timer> timerPtr =`
`199`	`199`	`std::make_shared<Timer>(std::move(cb), when, interval);`
`@@ -233,7 +233,7 @@ bool TimerQueue::insert(const TimerPtr &timerPtr)`
`233`	`233`	`return earliestChanged;`
`234`	`234`	`}`
`235`	`235`	`#ifndef __linux__`
`236`		`-int TimerQueue::getTimeout() const`
	`236`	`+int64_t TimerQueue::getTimeout() const`
`237`	`237`	`{`
`238`	`238`	`loop_->assertInLoopThread();`
`239`	`239`	`if (timers_.empty())`
`@@ -247,7 +247,7 @@ int TimerQueue::getTimeout() const`
`247`	`247`	`}`
`248`	`248`	`#endif`
`249`	`249`
`250`		`-std::vector<TimerPtr> TimerQueue::getExpired(const Date &now)`
	`250`	`+std::vector<TimerPtr> TimerQueue::getExpired(const TimePoint &now)`
`251`	`251`	`{`
`252`	`252`	`std::vector<TimerPtr> expired;`
`253`	`253`	`while (!timers_.empty())`
`@@ -262,7 +262,8 @@ std::vector<TimerPtr> TimerQueue::getExpired(const Date &now)`
`262`	`262`	`}`
`263`	`263`	`return expired;`
`264`	`264`	`}`
`265`		`-void TimerQueue::reset(const std::vector<TimerPtr> &expired, const Date &now)`
	`265`	`+void TimerQueue::reset(const std::vector<TimerPtr> &expired,`
	`266`	`+ const TimePoint &now)`
`266`	`267`	`{`
`267`	`268`	`loop_->assertInLoopThread();`
`268`	`269`	`for (auto const &timerPtr : expired)`
`@@ -277,7 +278,7 @@ void TimerQueue::reset(const std::vector<TimerPtr> &expired, const Date &now)`
`277`	`278`	`#ifdef __linux__`
`278`	`279`	`if (!timers_.empty())`
`279`	`280`	`{`
`280`		`- const Date nextExpire = timers_.top()->when();`
	`281`	`+ const auto nextExpire = timers_.top()->when();`
`281`	`282`	`resetTimerfd(timerfd_, nextExpire);`
`282`	`283`	`}`
`283`	`284`	`#endif`
Original file line number	Diff line number	Diff line change
`@@ -26,5 +26,7 @@ int main()`
`26`	`26`	`loop.runAfter(5, []() { std::cout << "runAt 5s later" << std::endl; });`
`27`	`27`	`loop.runEvery(1, []() { std::cout << "runEvery 1s" << std::endl; });`
`28`	`28`	`loop.runAfter(4, []() { std::cout << "runAfter 4s" << std::endl; });`
	`29`	`+ loop.runAfter(10min,`
	`30`	`+ []() { std::cout << "*********** run after 10 min\n"; });`
`29`	`31`	`loop.loop();`
`30`	`32`	`}`