--- a/src/event/modules/ngx_select_module.c
+++ b/src/event/modules/ngx_select_module.c
@@ -319,6 +319,19 @@ static int ngx_select_process_events(ngx
     if (timer) {
 #if (HAVE_SELECT_CHANGE_TIMEOUT)
         delta = timer - (tv.tv_sec * 1000 + tv.tv_usec / 1000);
+
+#if 0
+        /*
+         * update the cached time if the sum of the last deltas
+         * is more than 0.5 seconds
+         */
+        deltas += delta;
+        if (deltas > 500000) {
+            ngx_cached_time = ngx_real_time();
+            deltas = 0;
+        }
+#endif
+
 #else
         delta = ngx_msec() - delta;
 #endif

--- a/src/event/ngx_event_connect.c
+++ b/src/event/ngx_event_connect.c
@@ -2,7 +2,7 @@
 #include <ngx_event_connect.h>
 
 
-int ngx_event_connect_peer(ngx_connect_peer_t *cp)
+int ngx_event_connect_peer(ngx_peer_connecttion_t *pc)
 {
     time_t   now;
 
@@ -10,21 +10,21 @@ int ngx_event_connect_peer(ngx_connect_p
 
     now = ngx_time();
 
-    if (cp->peers->number > 1) {
+    if (pc->peers->number > 1) {
 
         /* there are several peers */
 
-        if (cp->tries == cp->peers->number) {
+        if (pc->tries == pc->peers->number) {
 
             /* it's a first try - get a current peer */
 
             /* Here is the race condition when the peers are shared between
                the threads or the processes but it should not be serious */
 
-            cp->cur_peer = cp->peers->current++;
+            pc->cur_peer = pc->peers->current++;
 
             if (cp->peers->current >= cp->peers->number) {
-                cp->peers->current = 0;
+                pc->peers->current = 0;
             }
 
             /* the end of the race condition */
@@ -32,39 +32,39 @@ int ngx_event_connect_peer(ngx_connect_p
 #if (NGX_MULTITHREADED || NGX_MULTIPROCESSED)
             /* eliminate the sequences of the race condition */
 
-            if (cp->cur_peer >= cp->peers->number) {
-                cp->cur_peer = 0;
+            if (pc->cur_peer >= pc->peers->number) {
+                pc->cur_peer = 0;
             }
 #endif
         }
 
-        if (cp->peers->max_fails > 0) {
+        if (pc->peers->max_fails > 0) {
 
             /* the peers support a fault tolerance */
 
             for ( ;; ) {
-                peer = &cp->peers->peers[cp->cur_peer];
+                peer = &pc->peers->peers[pc->cur_peer];
 
                 /* Here is the race condition when the peers are shared between
                    the threads or the processes but it should not be serious */
 
-                if (peer->fails <= cp->peers->max_fails
-                    || (now - peer->accessed > cp->peers->fail_timeout))
+                if (peer->fails <= pc->peers->max_fails
+                    || (now - peer->accessed > pc->peers->fail_timeout))
                 {
                     break;
                 }
 
                 /* the end of the race condition */
 
-                cp->cur_peer++;
+                pc->cur_peer++;
 
-                if (cp->cur_peer >= cp->peers->number) {
-                    cp->cur_peer = 0;
+                if (pc->cur_peer >= pc->peers->number) {
+                    pc->cur_peer = 0;
                 }
 
-                cp->tries--;
+                pc->tries--;
 
-                if (cp->tries == 0) {
+                if (pc->tries == 0) {
                     return NGX_ERROR;
                 }
             }

--- a/src/event/ngx_event_connect.h
+++ b/src/event/ngx_event_connect.h
@@ -25,7 +25,7 @@ typedef struct {
     int                fail_timeout;
 
  /* ngx_mutex_t       *mutex; */
- /* ngx_connection_t  *cached; */
+    ngx_connection_t  *cached;
 
     ngx_peer_t         peers[1];
 } ngx_peers_t;
@@ -36,8 +36,10 @@ typedef struct {
     int                cur_peer;
     int                tries;
 
+    ngx_connection_t  *connection;
+
     unsigned           cached:1;
-} ngx_connect_peer_t;
+} ngx_peer_connection_t;
 
 
 #endif /* _NGX_EVENT_CONNECT_H_INCLUDED_ */