nginx-0.3.0-RELEASE importrelease-0.3.0

    *) Change: the 10-days live time limit of worker process was
       eliminated. The limit was introduced because of millisecond timers
       overflow.

10 files changed, 123 insertions, 308 deletions

diff --git a/src/event/modules/ngx_devpoll_module.c b/src/event/modules/ngx_devpoll_module.c
index 5faa1fbcd..7ee8602fc 100644
--- a/src/event/modules/ngx_devpoll_module.c
+++ b/src/event/modules/ngx_devpoll_module.c
@@ -326,44 +326,23 @@ ngx_int_t
 ngx_devpoll_process_events(ngx_cycle_t *cycle)
 {
     int                 events, revents;
-    ngx_int_t           i;
-    ngx_uint_t          lock, accept_lock, expire;
     size_t              n;
-    ngx_msec_t          timer;
     ngx_err_t           err;
+    ngx_int_t           i;
+    ngx_uint_t          lock, accept_lock;
+    ngx_msec_t          timer, delta;
 #if 0
     ngx_cycle_t       **old_cycle;
 #endif
     ngx_event_t        *rev, *wev;
     ngx_connection_t   *c;
-    ngx_epoch_msec_t    delta;
     struct dvpoll       dvp;
     struct timeval      tv;
 
-    for ( ;; ) {
-        timer = ngx_event_find_timer();
-
-        if (timer != 0) {
-            break;
-        }
-
-        ngx_log_debug0(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
-                       "devpoll expired timer");
-
-        ngx_event_expire_timers((ngx_msec_t)
-                                    (ngx_elapsed_msec - ngx_old_elapsed_msec));
-    }
+    timer = ngx_event_find_timer();
 
     /* NGX_TIMER_INFINITE == INFTIM */
 
-    if (timer == NGX_TIMER_INFINITE) {
-        expire = 0;
-
-    } else {
-        expire = 1;
-    }
-
-    ngx_old_elapsed_msec = ngx_elapsed_msec;
     accept_lock = 0;
 
     if (ngx_accept_mutex) {
@@ -382,13 +361,12 @@ ngx_devpoll_process_events(ngx_cycle_t *cycle)
                        || timer > ngx_accept_mutex_delay)
             {
                 timer = ngx_accept_mutex_delay;
-                expire = 0;
             }
         }
     }
 
     ngx_log_debug1(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
-                   "devpoll timer: %d", timer);
+                   "devpoll timer: %M", timer);
 
     if (nchanges) {
         n = nchanges * sizeof(struct pollfd);
@@ -416,9 +394,8 @@ ngx_devpoll_process_events(ngx_cycle_t *cycle)
     ngx_gettimeofday(&tv);
     ngx_time_update(tv.tv_sec);
 
-    delta = ngx_elapsed_msec;
-    ngx_elapsed_msec = (ngx_epoch_msec_t) tv.tv_sec * 1000
-                                          + tv.tv_usec / 1000 - ngx_start_msec;
+    delta = ngx_current_time;
+    ngx_current_time = (ngx_msec_t) tv.tv_sec * 1000 + tv.tv_usec / 1000;
 
     if (err) {
         ngx_log_error((err == NGX_EINTR) ? NGX_LOG_INFO : NGX_LOG_ALERT,
@@ -428,10 +405,10 @@ ngx_devpoll_process_events(ngx_cycle_t *cycle)
     }
 
     if (timer != NGX_TIMER_INFINITE) {
-        delta = ngx_elapsed_msec - delta;
+        delta = ngx_current_time - delta;
 
         ngx_log_debug2(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
-                       "devpoll timer: %d, delta: %d", timer, (int) delta);
+                       "devpoll timer: %M, delta: %M", timer, delta);
     } else {
         if (events == 0) {
             ngx_log_error(NGX_LOG_ALERT, cycle->log, 0,
@@ -554,9 +531,7 @@ ngx_devpoll_process_events(ngx_cycle_t *cycle)
         ngx_mutex_unlock(ngx_posted_events_mutex);
     }
 
-    if (expire && delta) {
-        ngx_event_expire_timers((ngx_msec_t) delta);
-    }
+    ngx_event_expire_timers();
 
     if (!ngx_threaded) {
         ngx_event_process_posted(cycle);
diff --git a/src/event/modules/ngx_epoll_module.c b/src/event/modules/ngx_epoll_module.c
index 75a0b0f4b..177c05da7 100644
--- a/src/event/modules/ngx_epoll_module.c
+++ b/src/event/modules/ngx_epoll_module.c
@@ -387,56 +387,31 @@ ngx_epoll_process_events(ngx_cycle_t *cycle)
     int                events;
     uint32_t           revents;
     ngx_int_t          instance, i;
-    ngx_uint_t         lock, accept_lock, expire;
+    ngx_uint_t         lock, accept_lock;
     ngx_err_t          err;
     ngx_log_t         *log;
-    ngx_msec_t         timer;
+    ngx_msec_t         timer, delta;
     ngx_event_t       *rev, *wev;
     struct timeval     tv;
     ngx_connection_t  *c;
-    ngx_epoch_msec_t   delta;
 
-    for ( ;; ) { 
-        timer = ngx_event_find_timer();
+    timer = ngx_event_find_timer();
 
 #if (NGX_THREADS)
 
-        if (timer == NGX_TIMER_ERROR) {
-            return NGX_ERROR;
-        }
+    if (timer == NGX_TIMER_ERROR) {
+        return NGX_ERROR;
+    }
 
-        if (timer == NGX_TIMER_INFINITE || timer > 500) {
-            timer = 500;
-            break;
-        }
+    if (timer == NGX_TIMER_INFINITE || timer > 500) {
+        timer = 500;
+        break;
+    }
 
 #endif
 
-        if (timer != 0) {
-            break;
-        }
-
-        ngx_log_debug0(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
-                       "epoll expired timer");
-
-        ngx_event_expire_timers((ngx_msec_t)
-                                    (ngx_elapsed_msec - ngx_old_elapsed_msec));
-
-        if (ngx_posted_events && ngx_threaded) {
-            ngx_wakeup_worker_thread(cycle);
-        }
-    }
-
     /* NGX_TIMER_INFINITE == INFTIM */
 
-    if (timer == NGX_TIMER_INFINITE) {
-        expire = 0;
-
-    } else {
-        expire = 1;
-    }
-
-    ngx_old_elapsed_msec = ngx_elapsed_msec;
     accept_lock = 0;
 
     if (ngx_accept_mutex) {
@@ -455,13 +430,12 @@ ngx_epoll_process_events(ngx_cycle_t *cycle)
                        || timer > ngx_accept_mutex_delay)
             {
                 timer = ngx_accept_mutex_delay;
-                expire = 0;
             }
         }
     }
 
     ngx_log_debug1(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
-                   "epoll timer: %d", timer);
+                   "epoll timer: %M", timer);
 
     events = epoll_wait(ep, event_list, nevents, timer);
 
@@ -474,15 +448,14 @@ ngx_epoll_process_events(ngx_cycle_t *cycle)
     ngx_gettimeofday(&tv);
     ngx_time_update(tv.tv_sec);
 
-    delta = ngx_elapsed_msec;
-    ngx_elapsed_msec = (ngx_epoch_msec_t) tv.tv_sec * 1000
-                                          + tv.tv_usec / 1000 - ngx_start_msec;
+    delta = ngx_current_time;
+    ngx_current_time = (ngx_msec_t) tv.tv_sec * 1000 + tv.tv_usec / 1000;
 
     if (timer != NGX_TIMER_INFINITE) {
-        delta = ngx_elapsed_msec - delta;
+        delta = ngx_current_time - delta;
 
         ngx_log_debug2(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
-                       "epoll timer: %d, delta: %d", timer, (int) delta);
+                       "epoll timer: %M, delta: %M", timer, delta);
     } else {
         if (events == 0) {
             ngx_log_error(NGX_LOG_ALERT, cycle->log, 0,
@@ -645,9 +618,7 @@ ngx_epoll_process_events(ngx_cycle_t *cycle)
         ngx_mutex_unlock(ngx_posted_events_mutex);
     }
 
-    if (expire && delta) {
-        ngx_event_expire_timers((ngx_msec_t) delta);
-    }
+    ngx_event_expire_timers();
 
     if (ngx_posted_events) {
         if (ngx_threaded) {
diff --git a/src/event/modules/ngx_iocp_module.c b/src/event/modules/ngx_iocp_module.c
index 5c9e7e68f..269d95552 100644
--- a/src/event/modules/ngx_iocp_module.c
+++ b/src/event/modules/ngx_iocp_module.c
@@ -184,23 +184,21 @@ ngx_int_t ngx_iocp_process_events(ngx_cycle_t *cycle)
     u_int              key;
     u_long             bytes;
     ngx_err_t          err;
-    ngx_msec_t         timer;
+    ngx_msec_t         timer, delta;
     ngx_event_t       *ev;
     struct timeval     tv;
-    ngx_epoch_msec_t   delta;
     ngx_event_ovlp_t  *ovlp;
 
     timer = ngx_event_find_timer();
-    ngx_old_elapsed_msec = ngx_elapsed_msec;
 
-    if (timer == 0) {
+    if (timer == NGX_TIMER_INFINITE) {
         timer = INFINITE;
     }
 
-    ngx_log_debug1(NGX_LOG_DEBUG_EVENT, cycle->log, 0, "iocp timer: %d", timer);
+    ngx_log_debug1(NGX_LOG_DEBUG_EVENT, cycle->log, 0, "iocp timer: %M", timer);
 
     rc = GetQueuedCompletionStatus(iocp, &bytes, (LPDWORD) &key,
-                                   (LPOVERLAPPED *) &ovlp, timer);
+                                   (LPOVERLAPPED *) &ovlp, (u_long) timer);
 
     if (rc == 0) {
         err = ngx_errno;
@@ -214,15 +212,14 @@ ngx_int_t ngx_iocp_process_events(ngx_cycle_t *cycle)
     ngx_log_debug4(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
                    "iocp: %d b:%d k:%d ov:%p", rc, bytes, key, ovlp);
 
-    delta = ngx_elapsed_msec;
-    ngx_elapsed_msec = (ngx_epoch_msec_t) tv.tv_sec * 1000
-                                          + tv.tv_usec / 1000 - ngx_start_msec;
+    delta = ngx_current_time;
+    ngx_current_time = (ngx_msec_t) tv.tv_sec * 1000 + tv.tv_usec / 1000;
 
     if (timer != INFINITE) {
-        delta = ngx_elapsed_msec - delta;
+        delta = ngx_current_time - delta;
 
         ngx_log_debug2(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
-                       "iocp timer: %d, delta: %d", timer, (int) delta);
+                       "iocp timer: %M, delta: %M", timer, delta);
     }
 
     if (err) {
@@ -234,9 +231,7 @@ ngx_int_t ngx_iocp_process_events(ngx_cycle_t *cycle)
                 return NGX_ERROR;
             }
 
-            if (timer != INFINITE && delta) {
-                ngx_event_expire_timers((ngx_msec_t) delta);
-            }
+            ngx_event_expire_timers();
 
             return NGX_OK;
         }
@@ -268,9 +263,7 @@ ngx_int_t ngx_iocp_process_events(ngx_cycle_t *cycle)
         ngx_log_debug1(NGX_LOG_DEBUG_EVENT, cycle->log, err,
                        "iocp: aborted event %p", ev); 
 
-        if (timer != INFINITE && delta) {
-            ngx_event_expire_timers((ngx_msec_t) delta);
-        }
+        ngx_event_expire_timers();
 
         return NGX_OK;
     }
@@ -304,9 +297,7 @@ ngx_int_t ngx_iocp_process_events(ngx_cycle_t *cycle)
 
     ev->handler(ev);
 
-    if (timer != INFINITE && delta) {
-        ngx_event_expire_timers((ngx_msec_t) delta);
-    }
+    ngx_event_expire_timers();
 
     return NGX_OK;
 }
diff --git a/src/event/modules/ngx_kqueue_module.c b/src/event/modules/ngx_kqueue_module.c
index 78ebbad95..ee55915d6 100644
--- a/src/event/modules/ngx_kqueue_module.c
+++ b/src/event/modules/ngx_kqueue_module.c
@@ -445,47 +445,28 @@ ngx_kqueue_process_events(ngx_cycle_t *cycle)
 {
     int                events, n;
     ngx_int_t          i, instance;
-    ngx_uint_t         lock, accept_lock, expire;
+    ngx_uint_t         lock, accept_lock;
     ngx_err_t          err;
-    ngx_msec_t         timer;
+    ngx_msec_t         timer, delta;
     ngx_event_t       *ev;
-    ngx_epoch_msec_t   delta;
     struct timeval     tv;
     struct timespec    ts, *tp;
 
-    for ( ;; ) {
-        timer = ngx_event_find_timer();
+    timer = ngx_event_find_timer();
 
 #if (NGX_THREADS)
 
-        if (timer == NGX_TIMER_ERROR) {
-            return NGX_ERROR;
-        }
+    if (timer == NGX_TIMER_ERROR) {
+        return NGX_ERROR;
+    }
 
-        if (timer == NGX_TIMER_INFINITE || timer > 500) {
-            timer = 500;
-            break;
-        }
+    if (timer == NGX_TIMER_INFINITE || timer > 500) {
+        timer = 500;
+        break;
+    }
 
 #endif
 
-        if (timer != 0) {
-            break;
-        }
-
-        ngx_log_debug0(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
-                       "kevent expired timer");
-
-        ngx_event_expire_timers((ngx_msec_t)
-                                    (ngx_elapsed_msec - ngx_old_elapsed_msec));
-
-        if (ngx_posted_events && ngx_threaded) {
-            ngx_wakeup_worker_thread(cycle);
-        }
-    }
-
-    ngx_old_elapsed_msec = ngx_elapsed_msec;
-    expire = 1;
     accept_lock = 0;
 
     if (ngx_accept_mutex) {
@@ -504,7 +485,6 @@ ngx_kqueue_process_events(ngx_cycle_t *cycle)
                        || timer > ngx_accept_mutex_delay)
             {
                 timer = ngx_accept_mutex_delay;
-                expire = 0;
             }
         }
     }
@@ -524,7 +504,6 @@ ngx_kqueue_process_events(ngx_cycle_t *cycle)
 
     if (timer == NGX_TIMER_INFINITE) {
         tp = NULL;
-        expire = 0;
 
     } else {
         ts.tv_sec = timer / 1000;
@@ -549,9 +528,8 @@ ngx_kqueue_process_events(ngx_cycle_t *cycle)
     ngx_log_debug1(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
                    "kevent events: %d", events);
 
-    delta = ngx_elapsed_msec;
-    ngx_elapsed_msec = (ngx_epoch_msec_t) tv.tv_sec * 1000
-                                          + tv.tv_usec / 1000 - ngx_start_msec;
+    delta = ngx_current_time;
+    ngx_current_time = (ngx_msec_t) tv.tv_sec * 1000 + tv.tv_usec / 1000;
 
     if (err) {
         ngx_log_error((err == NGX_EINTR) ? NGX_LOG_INFO : NGX_LOG_ALERT,
@@ -561,10 +539,10 @@ ngx_kqueue_process_events(ngx_cycle_t *cycle)
     }
 
     if (timer != NGX_TIMER_INFINITE) {
-        delta = ngx_elapsed_msec - delta;
+        delta = ngx_current_time - delta;
 
         ngx_log_debug2(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
-                       "kevent timer: %d, delta: %d", timer, (int) delta);
+                       "kevent timer: %M, delta: %M", timer, delta);
 
     } else {
         if (events == 0) {
@@ -718,9 +696,7 @@ ngx_kqueue_process_events(ngx_cycle_t *cycle)
         ngx_mutex_unlock(ngx_posted_events_mutex);
     }
 
-    if (expire && delta) {
-        ngx_event_expire_timers((ngx_msec_t) delta);
-    }
+    ngx_event_expire_timers();
 
     if (ngx_posted_events) {
         if (ngx_threaded) {
diff --git a/src/event/modules/ngx_poll_module.c b/src/event/modules/ngx_poll_module.c
index 7de0e4ba6..29b375aee 100644
--- a/src/event/modules/ngx_poll_module.c
+++ b/src/event/modules/ngx_poll_module.c
@@ -278,41 +278,19 @@ static ngx_int_t
 ngx_poll_process_events(ngx_cycle_t *cycle)
 {
     int                 ready, revents;
-    ngx_int_t           i, nready;
-    ngx_uint_t          n, found, lock, expire;
-    ngx_msec_t          timer;
     ngx_err_t           err;
+    ngx_int_t           i, nready;
+    ngx_uint_t          n, found, lock;
+    ngx_msec_t          timer, delta;
     ngx_cycle_t       **old_cycle;
     ngx_event_t        *ev;
-    ngx_epoch_msec_t    delta;
     ngx_connection_t   *c;
     struct timeval      tv;
 
-    for ( ;; ) {
-        timer = ngx_event_find_timer();
-
-        if (timer != 0) {
-            break;
-        }
-
-        ngx_log_debug0(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
-                       "poll expired timer");
-
-        ngx_event_expire_timers((ngx_msec_t)
-                                (ngx_elapsed_msec - ngx_old_elapsed_msec));
-    }
+    timer = ngx_event_find_timer();
 
     /* NGX_TIMER_INFINITE == INFTIM */
 
-    if (timer == NGX_TIMER_INFINITE) {
-        expire = 0;
-
-    } else {
-        expire = 1;
-    }
-
-    ngx_old_elapsed_msec = ngx_elapsed_msec; 
-
 #if (NGX_DEBUG0)
     if (cycle->log->log_level & NGX_LOG_DEBUG_ALL) {
         for (i = 0; i < nevents; i++) {
@@ -337,12 +315,11 @@ ngx_poll_process_events(ngx_cycle_t *cycle)
                     || timer > ngx_accept_mutex_delay))
             { 
                 timer = ngx_accept_mutex_delay;
-                expire = 0;
             } 
         }
     }
 
-    ngx_log_debug1(NGX_LOG_DEBUG_EVENT, cycle->log, 0, "poll timer: %d", timer);
+    ngx_log_debug1(NGX_LOG_DEBUG_EVENT, cycle->log, 0, "poll timer: %M", timer);
 
     ready = poll(event_list, (u_int) nevents, (int) timer);
 
@@ -355,9 +332,8 @@ ngx_poll_process_events(ngx_cycle_t *cycle)
     ngx_gettimeofday(&tv);
     ngx_time_update(tv.tv_sec);
 
-    delta = ngx_elapsed_msec;
-    ngx_elapsed_msec = (ngx_epoch_msec_t) tv.tv_sec * 1000
-                                          + tv.tv_usec / 1000 - ngx_start_msec;
+    delta = ngx_current_time;
+    ngx_current_time = (ngx_msec_t) tv.tv_sec * 1000 + tv.tv_usec / 1000;
 
     ngx_log_debug2(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
                    "poll ready %d of %d", ready, nevents);
@@ -370,10 +346,10 @@ ngx_poll_process_events(ngx_cycle_t *cycle)
     }
 
     if (timer != NGX_TIMER_INFINITE) {
-        delta = ngx_elapsed_msec - delta;
+        delta = ngx_current_time - delta;
 
         ngx_log_debug2(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
-                       "poll timer: %d, delta: %d", timer, (int) delta);
+                       "poll timer: %M, delta: %M", timer, delta);
     } else {
         if (ready == 0) {
             ngx_log_error(NGX_LOG_ALERT, cycle->log, 0,
@@ -593,9 +569,7 @@ ngx_poll_process_events(ngx_cycle_t *cycle)
         ngx_log_error(NGX_LOG_ALERT, cycle->log, 0, "poll ready != events");
     }
 
-    if (expire && delta) {
-        ngx_event_expire_timers((ngx_msec_t) delta);
-    }
+    ngx_event_expire_timers();
 
     if (!ngx_threaded) {
         ngx_event_process_posted(cycle);
diff --git a/src/event/modules/ngx_rtsig_module.c b/src/event/modules/ngx_rtsig_module.c
index 9c5df5d2f..fdbbb2fe4 100644
--- a/src/event/modules/ngx_rtsig_module.c
+++ b/src/event/modules/ngx_rtsig_module.c
@@ -283,55 +283,34 @@ ngx_rtsig_process_events(ngx_cycle_t *cycle)
 {
     int                 signo;
     ngx_int_t           instance;
-    ngx_uint_t          expire;
-    ngx_msec_t          timer;
+    ngx_msec_t          timer, delta;
     ngx_err_t           err;
     siginfo_t           si;
     ngx_event_t        *rev, *wev;
     struct timeval      tv;
     struct timespec     ts, *tp;
     struct sigaction    sa;
-    ngx_epoch_msec_t    delta;
     ngx_connection_t   *c;
     ngx_rtsig_conf_t   *rtscf;
 
     if (overflow) {
         timer = 0;
-        expire = 0;
 
     } else {
-        for ( ;; ) {
-            timer = ngx_event_find_timer();
+        timer = ngx_event_find_timer();
 
 #if (NGX_THREADS)
 
-            if (timer == NGX_TIMER_ERROR) {
-                return NGX_ERROR;
-            }
-
-            if (timer == NGX_TIMER_INFINITE || timer > 500) {
-                timer = 500;
-                break;
-            }
-
-#endif
-
-            if (timer != 0) {
-                break;
-            }
-
-            ngx_log_debug0(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
-                           "rtsig expired timer");
-
-            ngx_event_expire_timers((ngx_msec_t)
-                                    (ngx_elapsed_msec - ngx_old_elapsed_msec));
+        if (timer == NGX_TIMER_ERROR) {
+            return NGX_ERROR;
+        }
 
-            if (ngx_posted_events && ngx_threaded) {
-                ngx_wakeup_worker_thread(cycle);
-            }
+        if (timer == NGX_TIMER_INFINITE || timer > 500) {
+            timer = 500;
+            break;
         }
 
-        expire = 1;
+#endif
 
         if (ngx_accept_mutex) {
             if (ngx_accept_disabled > 0) {
@@ -349,7 +328,6 @@ ngx_rtsig_process_events(ngx_cycle_t *cycle)
                         || timer > ngx_accept_mutex_delay))
                 {
                     timer = ngx_accept_mutex_delay;
-                    expire = 0;
                 } 
             }
         }
@@ -357,7 +335,6 @@ ngx_rtsig_process_events(ngx_cycle_t *cycle)
 
     if (timer == NGX_TIMER_INFINITE) {
         tp = NULL;
-        expire = 0;
 
     } else {
         ts.tv_sec = timer / 1000;
@@ -365,10 +342,8 @@ ngx_rtsig_process_events(ngx_cycle_t *cycle)
         tp = &ts;
     }
 
-    ngx_old_elapsed_msec = ngx_elapsed_msec;
-
     ngx_log_debug1(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
-                   "rtsig timer: %d", timer);
+                   "rtsig timer: %M", timer);
 
     /* Linux's sigwaitinfo() is sigtimedwait() with the NULL timeout pointer */
 
@@ -402,9 +377,8 @@ ngx_rtsig_process_events(ngx_cycle_t *cycle)
     ngx_gettimeofday(&tv);
     ngx_time_update(tv.tv_sec);
 
-    delta = ngx_elapsed_msec;
-    ngx_elapsed_msec = (ngx_epoch_msec_t) tv.tv_sec * 1000
-                                          + tv.tv_usec / 1000 - ngx_start_msec;
+    delta = ngx_current_time;
+    ngx_current_time = (ngx_msec_t) tv.tv_sec * 1000 + tv.tv_usec / 1000;
 
     if (err) {
         ngx_accept_mutex_unlock();
@@ -414,10 +388,10 @@ ngx_rtsig_process_events(ngx_cycle_t *cycle)
     }
 
     if (timer != NGX_TIMER_INFINITE) {
-        delta = ngx_elapsed_msec - delta;
+        delta = ngx_current_time - delta;
 
         ngx_log_debug2(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
-                       "rtsig timer: %d, delta: %d", timer, (int) delta);
+                       "rtsig timer: %M, delta: %M", timer, delta);
     }
 
     rtscf = ngx_event_get_conf(ngx_cycle->conf_ctx, ngx_rtsig_module);
@@ -557,9 +531,7 @@ ngx_rtsig_process_events(ngx_cycle_t *cycle)
 
     ngx_accept_mutex_unlock();
 
-    if (expire && delta) {
-        ngx_event_expire_timers((ngx_msec_t) delta);
-    }
+    ngx_event_expire_timers();
 
     if (ngx_posted_events) {
         if (ngx_threaded) {
diff --git a/src/event/modules/ngx_select_module.c b/src/event/modules/ngx_select_module.c
index 7cb338182..5be3afa85 100644
--- a/src/event/modules/ngx_select_module.c
+++ b/src/event/modules/ngx_select_module.c
@@ -265,34 +265,17 @@ static ngx_int_t
 ngx_select_process_events(ngx_cycle_t *cycle)
 {
     int                       ready, nready;
-    ngx_uint_t                i, found, lock, expire;
+    ngx_uint_t                i, found, lock;
     ngx_err_t                 err;
-    ngx_msec_t                timer;
+    ngx_msec_t                timer, delta;
     ngx_event_t              *ev;
     ngx_connection_t         *c;
-    ngx_epoch_msec_t          delta;
     struct timeval            tv, *tp;
 #if (NGX_HAVE_SELECT_CHANGE_TIMEOUT)
-    static ngx_epoch_msec_t   deltas = 0;
+    static ngx_msec_t         deltas = 0;
 #endif
 
-    for ( ;; ) {
-        timer = ngx_event_find_timer();
-
-        if (timer != 0) {
-            break;
-        }
-
-        ngx_log_debug0(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
-                       "select expired timer");
-
-        ngx_event_expire_timers((ngx_msec_t)
-                                    (ngx_elapsed_msec - ngx_old_elapsed_msec));
-    }
-
-    ngx_old_elapsed_msec = ngx_elapsed_msec;
-
-    expire = 1;
+    timer = ngx_event_find_timer();
 
 #if !(NGX_WIN32)
 
@@ -310,7 +293,6 @@ ngx_select_process_events(ngx_cycle_t *cycle)
                     || timer > ngx_accept_mutex_delay))
             {
                 timer = ngx_accept_mutex_delay;
-                expire = 0;
             }
         }
     }
@@ -347,16 +329,15 @@ ngx_select_process_events(ngx_cycle_t *cycle)
 
     if (timer == NGX_TIMER_INFINITE) {
         tp = NULL;
-        expire = 0;
 
     } else {
-        tv.tv_sec = timer / 1000;
-        tv.tv_usec = (timer % 1000) * 1000;
+        tv.tv_sec = (long) (timer / 1000);
+        tv.tv_usec = (long) ((timer % 1000) * 1000);
         tp = &tv;
     }
 
     ngx_log_debug1(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
-                   "select timer: %d", timer);
+                   "select timer: %M", timer);
 
     work_read_fd_set = master_read_fd_set;
     work_write_fd_set = master_write_fd_set;
@@ -386,7 +367,7 @@ ngx_select_process_events(ngx_cycle_t *cycle)
 #if (NGX_HAVE_SELECT_CHANGE_TIMEOUT)
 
     if (timer != NGX_TIMER_INFINITE) {
-        delta = timer - (tv.tv_sec * 1000 + tv.tv_usec / 1000);
+        delta = timer - ((ngx_msec_t) tv.tv_sec * 1000 + tv.tv_usec / 1000);
 
         /*
          * learn the real time and update the cached time
@@ -399,22 +380,23 @@ ngx_select_process_events(ngx_cycle_t *cycle)
             ngx_time_update(tv.tv_sec);
             deltas = tv.tv_usec / 1000;
 
-            ngx_elapsed_msec = (ngx_epoch_msec_t) tv.tv_sec * 1000
-                                          + tv.tv_usec / 1000 - ngx_start_msec;
+            ngx_current_time = (ngx_msec_t) tv.tv_sec * 1000
+                                                           + tv.tv_usec / 1000;
         } else {
-            ngx_elapsed_msec += delta;
+            ngx_current_time += delta;
         }
 
         ngx_log_debug2(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
-                       "select timer: %d, delta: %d", timer, (int) delta);
+                       "select timer: %M, delta: %M", timer, delta);
 
     } else {
-        delta = 0;
+        deltas = 0;
+
         ngx_gettimeofday(&tv);
         ngx_time_update(tv.tv_sec);
 
-        ngx_elapsed_msec = (ngx_epoch_msec_t) tv.tv_sec * 1000
-                                          + tv.tv_usec / 1000 - ngx_start_msec;
+        delta = ngx_current_time;
+        ngx_current_time = (ngx_msec_t) tv.tv_sec * 1000 + tv.tv_usec / 1000;
 
         if (ready == 0) {
             ngx_log_error(NGX_LOG_ALERT, cycle->log, 0,
@@ -429,15 +411,14 @@ ngx_select_process_events(ngx_cycle_t *cycle)
     ngx_gettimeofday(&tv);
     ngx_time_update(tv.tv_sec);
 
-    delta = ngx_elapsed_msec;
-    ngx_elapsed_msec = (ngx_epoch_msec_t) tv.tv_sec * 1000
-                                          + tv.tv_usec / 1000 - ngx_start_msec;
+    delta = ngx_current_time;
+    ngx_current_time = (ngx_msec_t) tv.tv_sec * 1000 + tv.tv_usec / 1000;
 
     if (timer != NGX_TIMER_INFINITE) {
-        delta = ngx_elapsed_msec - delta;
+        delta = ngx_current_time - delta;
 
         ngx_log_debug2(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
-                       "select timer: %d, delta: %d", timer, (int) delta);
+                       "select timer: %M, delta: %M", timer, delta);
 
     } else {
         if (ready == 0) {
@@ -594,9 +575,7 @@ ngx_select_process_events(ngx_cycle_t *cycle)
         ngx_log_error(NGX_LOG_ALERT, cycle->log, 0, "select ready != events");
     }
 
-    if (expire && delta) {
-        ngx_event_expire_timers((ngx_msec_t) delta);
-    }
+    ngx_event_expire_timers();
 
     if (!ngx_threaded) {
         ngx_event_process_posted(cycle);
diff --git a/src/event/ngx_event.h b/src/event/ngx_event.h
index eee165e81..308d460c5 100644
--- a/src/event/ngx_event.h
+++ b/src/event/ngx_event.h
@@ -136,11 +136,11 @@ struct ngx_event_s {
      * STUB: The inline of "ngx_rbtree_t  rbtree;"
      */
 
-    ngx_int_t        rbtree_key;
-    void            *rbtree_left;
-    void            *rbtree_right;
-    void            *rbtree_parent;
-    char             rbtree_color;
+    ngx_rbtree_key_t   rbtree_key;
+    void              *rbtree_left;
+    void              *rbtree_right;
+    void              *rbtree_parent;
+    char               rbtree_color;
 
 
     unsigned         closed:1;
diff --git a/src/event/ngx_event_timer.c b/src/event/ngx_event_timer.c
index 4d6c647da..c3d3c7ee8 100644
--- a/src/event/ngx_event_timer.c
+++ b/src/event/ngx_event_timer.c
@@ -60,28 +60,18 @@ ngx_event_find_timer(void)
 
     ngx_mutex_unlock(ngx_event_timer_mutex);
 
-    timer = (ngx_msec_t)
-         (node->key * NGX_TIMER_RESOLUTION -
-               ngx_elapsed_msec / NGX_TIMER_RESOLUTION * NGX_TIMER_RESOLUTION);
-#if 0
-                         (node->key * NGX_TIMER_RESOLUTION - ngx_elapsed_msec);
-#endif
+    timer = (ngx_msec_t) node->key - ngx_current_time;
 
     return timer > 0 ? timer : 0 ;
 }
 
 
 void
-ngx_event_expire_timers(ngx_msec_t timer)
+ngx_event_expire_timers(void)
 {
     ngx_event_t   *ev;
     ngx_rbtree_t  *node;
 
-    if (timer < 0) {
-        /* avoid the endless loop if the time goes backward for some reason */
-        timer = 0;
-    }
-
     for ( ;; ) {
 
         if (ngx_event_timer_rbtree == &ngx_event_timer_sentinel) {
@@ -95,8 +85,11 @@ ngx_event_expire_timers(ngx_msec_t timer)
         node = ngx_rbtree_min((ngx_rbtree_t *) ngx_event_timer_rbtree,
                               &ngx_event_timer_sentinel);
 
-        if (node->key <= (ngx_msec_t)
-                         (ngx_old_elapsed_msec + timer) / NGX_TIMER_RESOLUTION)
+        /* node->key <= ngx_current_time */
+
+        if ((ngx_rbtree_key_int_t) node->key
+                                      - (ngx_rbtree_key_int_t) ngx_current_time
+            <= 0)
         {
             ev = (ngx_event_t *)
                            ((char *) node - offsetof(ngx_event_t, rbtree_key));
@@ -120,7 +113,7 @@ ngx_event_expire_timers(ngx_msec_t timer)
 #endif
 
             ngx_log_debug2(NGX_LOG_DEBUG_EVENT, ev->log, 0,
-                           "event timer del: %d: %i",
+                           "event timer del: %d: %M",
                            ngx_event_ident(ev->data), ev->rbtree_key);
 
             ngx_rbtree_delete((ngx_rbtree_t **) &ngx_event_timer_rbtree,
diff --git a/src/event/ngx_event_timer.h b/src/event/ngx_event_timer.h
index 4954809e7..a9d3176c1 100644
--- a/src/event/ngx_event_timer.h
+++ b/src/event/ngx_event_timer.h
@@ -16,24 +16,12 @@
 #define NGX_TIMER_INFINITE  (ngx_msec_t) -1
 #define NGX_TIMER_ERROR     (ngx_msec_t) -2
 
-
-/*
- * the 32-bit timer key value resolution
- *
- * 1 msec - 24 days
- * 10 msec - 8 months
- * 50 msec - 3 years 5 months
- * 100 msec - 6 years 10 months
- */
-
-#define NGX_TIMER_RESOLUTION  1
-
 #define NGX_TIMER_LAZY_DELAY  300
 
 
 ngx_int_t ngx_event_timer_init(ngx_log_t *log);
 ngx_msec_t ngx_event_find_timer(void);
-void ngx_event_expire_timers(ngx_msec_t timer);
+void ngx_event_expire_timers(void);
 
 
 #if (NGX_THREADS)
@@ -49,7 +37,7 @@ static ngx_inline void
 ngx_event_del_timer(ngx_event_t *ev)
 {
     ngx_log_debug2(NGX_LOG_DEBUG_EVENT, ev->log, 0,
-                   "event timer del: %d: %d",
+                   "event timer del: %d: %M",
                     ngx_event_ident(ev->data), ev->rbtree_key);
 
     if (ngx_mutex_lock(ngx_event_timer_mutex) == NGX_ERROR) {
@@ -75,14 +63,10 @@ ngx_event_del_timer(ngx_event_t *ev)
 static ngx_inline void
 ngx_event_add_timer(ngx_event_t *ev, ngx_msec_t timer)
 {
-    ngx_int_t  key;
+    ngx_rbtree_key_t      key;
+    ngx_rbtree_key_int_t  diff;
 
-    key = (ngx_int_t)
-              (ngx_elapsed_msec / NGX_TIMER_RESOLUTION * NGX_TIMER_RESOLUTION
-                                              + timer) / NGX_TIMER_RESOLUTION;
-#if 0
-                             (ngx_elapsed_msec + timer) / NGX_TIMER_RESOLUTION;
-#endif
+    key = ngx_current_time + timer;
 
     if (ev->timer_set) {
 
@@ -92,11 +76,11 @@ ngx_event_add_timer(ngx_event_t *ev, ngx_msec_t timer)
          * the rbtree operations for the fast connections.
          */
 
-        if (abs(key - ev->rbtree_key)
-                                 < NGX_TIMER_LAZY_DELAY / NGX_TIMER_RESOLUTION)
-        {
+        diff = (ngx_rbtree_key_int_t) (key - ev->rbtree_key);
+
+        if (ngx_abs(diff) < NGX_TIMER_LAZY_DELAY) {
             ngx_log_debug3(NGX_LOG_DEBUG_EVENT, ev->log, 0,
-                           "event timer: %d, old: %i, new: %i",
+                           "event timer: %d, old: %M, new: %M",
                             ngx_event_ident(ev->data), ev->rbtree_key, key);
             return;
         }
@@ -106,9 +90,9 @@ ngx_event_add_timer(ngx_event_t *ev, ngx_msec_t timer)
 
     ev->rbtree_key = key;
 
-    ngx_log_debug2(NGX_LOG_DEBUG_EVENT, ev->log, 0,
-                   "event timer add: %d: %i",
-                    ngx_event_ident(ev->data), ev->rbtree_key);
+    ngx_log_debug3(NGX_LOG_DEBUG_EVENT, ev->log, 0,
+                   "event timer add: %d: %M:%M",
+                    ngx_event_ident(ev->data), timer, ev->rbtree_key);
 
     if (ngx_mutex_lock(ngx_event_timer_mutex) == NGX_ERROR) {
         return;