change htimer_reset timeout

event/hevent.c

@@ -560,8 +560,7 @@ static void __read_timeout_cb(htimer_t* timer) {
     hio_t* io = (hio_t*)timer->privdata;
     uint64_t inactive_ms = (io->loop->cur_hrtime - io->last_read_hrtime) / 1000;
     if (inactive_ms + 100 < io->read_timeout) {
-        ((struct htimeout_s*)io->read_timer)->timeout = io->read_timeout - inactive_ms;
-        htimer_reset(io->read_timer);
+        htimer_reset(io->read_timer, io->read_timeout - inactive_ms);
     } else {
         char localaddrstr[SOCKADDR_STRLEN] = {0};
         char peeraddrstr[SOCKADDR_STRLEN] = {0};
@@ -582,8 +581,7 @@ void hio_set_read_timeout(hio_t* io, int timeout_ms) {
 
     if (io->read_timer) {
         // reset
-        ((struct htimeout_s*)io->read_timer)->timeout = timeout_ms;
-        htimer_reset(io->read_timer);
+        htimer_reset(io->read_timer, timeout_ms);
     } else {
         // add
         io->read_timer = htimer_add(io->loop, __read_timeout_cb, timeout_ms, 1);
@@ -596,8 +594,7 @@ static void __write_timeout_cb(htimer_t* timer) {
     hio_t* io = (hio_t*)timer->privdata;
     uint64_t inactive_ms = (io->loop->cur_hrtime - io->last_write_hrtime) / 1000;
     if (inactive_ms + 100 < io->write_timeout) {
-        ((struct htimeout_s*)io->write_timer)->timeout = io->write_timeout - inactive_ms;
-        htimer_reset(io->write_timer);
+        htimer_reset(io->write_timer, io->write_timeout - inactive_ms);
     } else {
         char localaddrstr[SOCKADDR_STRLEN] = {0};
         char peeraddrstr[SOCKADDR_STRLEN] = {0};
@@ -618,8 +615,7 @@ void hio_set_write_timeout(hio_t* io, int timeout_ms) {
 
     if (io->write_timer) {
         // reset
-        ((struct htimeout_s*)io->write_timer)->timeout = timeout_ms;
-        htimer_reset(io->write_timer);
+        htimer_reset(io->write_timer, timeout_ms);
     } else {
         // add
         io->write_timer = htimer_add(io->loop, __write_timeout_cb, timeout_ms, 1);
@@ -633,8 +629,7 @@ static void __keepalive_timeout_cb(htimer_t* timer) {
     uint64_t last_rw_hrtime = MAX(io->last_read_hrtime, io->last_write_hrtime);
     uint64_t inactive_ms = (io->loop->cur_hrtime - last_rw_hrtime) / 1000;
     if (inactive_ms + 100 < io->keepalive_timeout) {
-        ((struct htimeout_s*)io->keepalive_timer)->timeout = io->keepalive_timeout - inactive_ms;
-        htimer_reset(io->keepalive_timer);
+        htimer_reset(io->keepalive_timer, io->keepalive_timeout - inactive_ms);
     } else {
         char localaddrstr[SOCKADDR_STRLEN] = {0};
         char peeraddrstr[SOCKADDR_STRLEN] = {0};
@@ -655,8 +650,7 @@ void hio_set_keepalive_timeout(hio_t* io, int timeout_ms) {
 
     if (io->keepalive_timer) {
         // reset
-        ((struct htimeout_s*)io->keepalive_timer)->timeout = timeout_ms;
-        htimer_reset(io->keepalive_timer);
+        htimer_reset(io->keepalive_timer, timeout_ms);
     } else {
         // add
         io->keepalive_timer = htimer_add(io->loop, __keepalive_timeout_cb, timeout_ms, 1);
@@ -681,8 +675,7 @@ void hio_set_heartbeat(hio_t* io, int interval_ms, hio_send_heartbeat_fn fn) {
 
     if (io->heartbeat_timer) {
         // reset
-        ((struct htimeout_s*)io->heartbeat_timer)->timeout = interval_ms;
-        htimer_reset(io->heartbeat_timer);
+        htimer_reset(io->heartbeat_timer, interval_ms);
     } else {
         // add
         io->heartbeat_timer = htimer_add(io->loop, __heartbeat_timer_cb, interval_ms, INFINITE);

event/hloop.c

@@ -599,18 +599,18 @@ void hidle_del(hidle_t* idle) {
     EVENT_DEL(idle);
 }
 
-htimer_t* htimer_add(hloop_t* loop, htimer_cb cb, uint32_t timeout, uint32_t repeat) {
-    if (timeout == 0)   return NULL;
+htimer_t* htimer_add(hloop_t* loop, htimer_cb cb, uint32_t timeout_ms, uint32_t repeat) {
+    if (timeout_ms == 0)   return NULL;
     htimeout_t* timer;
     HV_ALLOC_SIZEOF(timer);
     timer->event_type = HEVENT_TYPE_TIMEOUT;
     timer->priority = HEVENT_HIGHEST_PRIORITY;
     timer->repeat = repeat;
-    timer->timeout = timeout;
+    timer->timeout = timeout_ms;
     hloop_update_time(loop);
-    timer->next_timeout = loop->cur_hrtime + (uint64_t)timeout*1000;
+    timer->next_timeout = loop->cur_hrtime + (uint64_t)timeout_ms * 1000;
     // NOTE: Limit granularity to 100ms
-    if (timeout >= 1000 && timeout % 100 == 0) {
+    if (timeout_ms >= 1000 && timeout_ms % 100 == 0) {
         timer->next_timeout = timer->next_timeout / 100000 * 100000;
     }
     heap_insert(&loop->timers, &timer->node);
@@ -619,7 +619,7 @@ htimer_t* htimer_add(hloop_t* loop, htimer_cb cb, uint32_t timeout, uint32_t rep
     return (htimer_t*)timer;
 }
 
-void htimer_reset(htimer_t* timer) {
+void htimer_reset(htimer_t* timer, uint32_t timeout_ms) {
     if (timer->event_type != HEVENT_TYPE_TIMEOUT) {
         return;
     }
@@ -633,7 +633,10 @@ void htimer_reset(htimer_t* timer) {
     if (timer->repeat == 0) {
         timer->repeat = 1;
     }
-    timer->next_timeout = loop->cur_hrtime + (uint64_t)timeout->timeout*1000;
+    if (timeout_ms > 0) {
+        timeout->timeout = timeout_ms;
+    }
+    timer->next_timeout = loop->cur_hrtime + (uint64_t)timeout->timeout * 1000;
     // NOTE: Limit granularity to 100ms
     if (timeout->timeout >= 1000 && timeout->timeout % 100 == 0) {
         timer->next_timeout = timer->next_timeout / 100000 * 100000;

event/hloop.h

@@ -185,8 +185,7 @@ HV_EXPORT hidle_t* hidle_add(hloop_t* loop, hidle_cb cb, uint32_t repeat DEFAULT
 HV_EXPORT void     hidle_del(hidle_t* idle);
 
 // timer
-// @param timeout: unit(ms)
-HV_EXPORT htimer_t* htimer_add(hloop_t* loop, htimer_cb cb, uint32_t timeout, uint32_t repeat DEFAULT(INFINITE));
+HV_EXPORT htimer_t* htimer_add(hloop_t* loop, htimer_cb cb, uint32_t timeout_ms, uint32_t repeat DEFAULT(INFINITE));
 /*
  * minute   hour    day     week    month       cb
  * 0~59     0~23    1~31    0~6     1~12
@@ -202,7 +201,7 @@ HV_EXPORT htimer_t* htimer_add_period(hloop_t* loop, htimer_cb cb,
                         int8_t week   DEFAULT(-1), int8_t month DEFAULT(-1), uint32_t repeat DEFAULT(INFINITE));
 
 HV_EXPORT void htimer_del(htimer_t* timer);
-HV_EXPORT void htimer_reset(htimer_t* timer);
+HV_EXPORT void htimer_reset(htimer_t* timer, uint32_t timeout_ms DEFAULT(0));
 
 // io
 //-----------------------low-level apis---------------------------------------

evpp/EventLoop.h

@@ -121,11 +121,11 @@ public:
         }
     }
 
-    void resetTimer(TimerID timerID) {
+    void resetTimer(TimerID timerID, int timeout_ms = 0) {
         std::lock_guard<std::mutex> locker(mutex_);
         auto iter = timers.find(timerID);
         if (iter != timers.end()) {
-            htimer_reset(iter->second->timer);
+            htimer_reset(iter->second->timer, timeout_ms);
             if (iter->second->repeat == 0) {
                 iter->second->repeat = 1;
             }
@@ -243,11 +243,11 @@ static inline void killTimer(TimerID timerID) {
     loop->killTimer(timerID);
 }
 
-static inline void resetTimer(TimerID timerID) {
+static inline void resetTimer(TimerID timerID, int timeout_ms) {
     EventLoop* loop = tlsEventLoop();
     assert(loop != NULL);
     if (loop == NULL) return;
-    loop->resetTimer(timerID);
+    loop->resetTimer(timerID, timeout_ms);
 }
 
 static inline TimerID setTimeout(int timeout_ms, TimerCallback cb) {

evpp/TimerThread.h

@@ -38,8 +38,8 @@ public:
         loop()->runInLoop(std::bind(&EventLoop::killTimer, loop(), timerID));
     }
 
-    void resetTimer(TimerID timerID) {
-        loop()->runInLoop(std::bind(&EventLoop::resetTimer, loop(), timerID));
+    void resetTimer(TimerID timerID, int timeout_ms = 0) {
+        loop()->runInLoop(std::bind(&EventLoop::resetTimer, loop(), timerID, timeout_ms));
     }
 };
 

examples/htimer_test.c

@@ -20,7 +20,7 @@ void on_timer_del(htimer_t* timer) {
 // test htimer_reset
 void on_timer_reset(htimer_t* timer) {
     printf("time=%llus on_timer_reset\n", LLU(hloop_now(hevent_loop(timer))));
-    htimer_reset((htimer_t*)hevent_userdata(timer));
+    htimer_reset((htimer_t*)hevent_userdata(timer), 0);
 }
 
 // test hloop_stop