Modify the timing wheel

Author: an-tao

trantor/utils/TimingWheel.cc

@@ -18,27 +18,29 @@ using namespace trantor;
 
 TimingWheel::TimingWheel(trantor::EventLoop *loop,
                          size_t maxTimeout,
-                         float tickInterval,
+                         float ticksInterval,
                          size_t bucketsNumPerWheel)
     : loop_(loop),
-      tickInterval_(tickInterval),
+      ticksInterval_(ticksInterval),
       bucketsNumPerWheel_(bucketsNumPerWheel)
 {
     assert(maxTimeout > 1);
-    assert(tickInterval > 0);
-    size_t maxTickNum = maxTimeout / tickInterval;
+    assert(ticksInterval > 0);
+    assert(bucketsNumPerWheel_ > 1);
+    size_t maxTickNum = maxTimeout / ticksInterval;
+    auto ticksNum = bucketsNumPerWheel;
     wheelsNum_ = 1;
-    while (maxTickNum > bucketsNumPerWheel_)
+    while (maxTickNum > ticksNum)
     {
         ++wheelsNum_;
-        maxTickNum = maxTickNum / bucketsNumPerWheel_;
+        ticksNum *= bucketsNumPerWheel_;
     }
     wheels_.resize(wheelsNum_);
     for (size_t i = 0; i < wheelsNum_; ++i)
     {
         wheels_[i].resize(bucketsNumPerWheel_);
     }
-    timerId_ = loop_->runEvery(tickInterval_, [=]() {
+    timerId_ = loop_->runEvery(ticksInterval_, [=]() {
         ++ticksCounter_;
         size_t t = ticksCounter_;
         size_t pow = 1;
@@ -90,10 +92,9 @@ void TimingWheel::insertEntry(size_t delay, EntryPtr entryPtr)
 
 void TimingWheel::insertEntryInloop(size_t delay, EntryPtr entryPtr)
 {
-    // protected by bucketMutex;
     loop_->assertInLoopThread();
 
-    delay = delay / tickInterval_ + 1;
+    delay = delay / ticksInterval_ + 1;
     size_t t = ticksCounter_;
     for (size_t i = 0; i < wheelsNum_; ++i)
     {

trantor/utils/TimingWheel.h

@@ -29,8 +29,8 @@
 #define TIMING_BUCKET_NUM_PER_WHEEL 100
 #define TIMING_TICK_INTERVAL 1.0
 
-// Four wheels with 200 buckets per wheel means the cache map can work with
-// a timeout up to 200^4 seconds,about 50 years;
+// Four wheels with 200 buckets per wheel means the timing wheel can work with
+// a timeout up to 200^4 seconds, about 50 years;
 
 namespace trantor
 {
@@ -60,17 +60,17 @@ class TimingWheel
     /// constructor
     /// @param loop
     /// eventloop pointer
-    /// @param tickInterval
+    /// @param ticksInterval
     /// second
     /// @param wheelsNum
     /// number of wheels
     /// @param bucketsNumPerWheel
     /// buckets number per wheel
     /// The max delay of the CacheMap is about
-    /// tickInterval*(bucketsNumPerWheel^wheelsNum) seconds.
+    /// ticksInterval*(bucketsNumPerWheel^wheelsNum) seconds.
     TimingWheel(trantor::EventLoop *loop,
                 size_t maxTimeout,
-                float tickInterval = TIMING_TICK_INTERVAL,
+                float ticksInterval = TIMING_TICK_INTERVAL,
                 size_t bucketsNumPerWheel = TIMING_BUCKET_NUM_PER_WHEEL);
 
     // If timeout>0, the value will be erased within the 'timeout' seconds after
@@ -94,7 +94,7 @@ class TimingWheel
     trantor::TimerId timerId_;
     trantor::EventLoop *loop_;
 
-    float tickInterval_;
+    float ticksInterval_;
     size_t wheelsNum_;
     size_t bucketsNumPerWheel_;
 };