netio.c: Lazily call gettimeofday(2). Usually gettimeofday(2) is only

needed when there are active TCP connections.


git-svn-id: file:///svn/nsd/trunk@1189 a26ef69c-88ff-0310-839f-98b793d9c207

Author: Erik Rozendaal

netio.c

@@ -90,13 +90,28 @@ netio_remove_handler(netio_type *netio, netio_handler_type *handler)
 	}
 }
 
+const struct timespec *
+netio_current_time(netio_type *netio)
+{
+	assert(netio);
+
+	if (!netio->have_current_time) {
+		struct timeval current_timeval;
+		if (gettimeofday(&current_timeval, NULL) == -1) {
+			return NULL;
+		}
+		timeval_to_timespec(&netio->cached_current_time, &current_timeval);
+		netio->have_current_time = 1;
+	}
+
+	return &netio->cached_current_time;
+}
+
 int
 netio_dispatch(netio_type *netio, const struct timespec *timeout, const sigset_t *sigmask)
 {
 	fd_set readfds, writefds, exceptfds;
 	int max_fd;
-	struct timeval current_timeval;
-	struct timespec current_time;
 	int have_timeout = 0;
 	struct timespec minimum_timeout;
 	netio_handler_type *timeout_handler = NULL;
@@ -107,14 +122,10 @@ netio_dispatch(netio_type *netio, const struct timespec *timeout, const sigset_t
 	assert(netio);
 
 	/*
-	 * Retrieve the current time to convert all absolute handler
-	 * timeouts to a relative timeout.
+	 * Clear the cached current time.
 	 */
-	if (gettimeofday(&current_timeval, NULL) == -1) {
-		return -1;
-	}
-	timeval_to_timespec(&current_time, &current_timeval);
-
+	netio->have_current_time = 0;
+	
 	/*
 	 * Initialize the minimum timeout with the timeout parameter.
 	 */
@@ -153,7 +164,7 @@ netio_dispatch(netio_type *netio, const struct timespec *timeout, const sigset_t
 
 			relative.tv_sec = handler->timeout->tv_sec;
 			relative.tv_nsec = handler->timeout->tv_nsec;
-			timespec_subtract(&relative, &current_time);
+			timespec_subtract(&relative, netio_current_time(netio));
 
 			if (!have_timeout ||
 			    timespec_compare(&relative, &minimum_timeout) < 0)
@@ -186,11 +197,11 @@ netio_dispatch(netio_type *netio, const struct timespec *timeout, const sigset_t
 		return -1;
 	}
 
-	/* Initialize the current time member of netio.  */
-	if (gettimeofday(&current_timeval, NULL) == -1) {
-		return -1;
-	}
-	timeval_to_timespec(&netio->current_time, &current_timeval);
+	/*
+	 * Clear the cached current_time (pselect(2) may block for
+	 * some time so the cached value is likely to be old).
+	 */
+	netio->have_current_time = 0;
 
 	if (rc == 0) {
 		/*

netio.h

@@ -70,11 +70,16 @@ typedef struct netio_handler_list netio_handler_list_type;
 struct netio
 {
 	/*
-	 * The current time, which is initialized just before the
-	 * event handlers are called.  This structure member should be
-	 * considered read-only.
+	 * Cached value of the current time.  The cached value is
+	 * cleared at the start of netio_dispatch to calculate the
+	 * relative timeouts of the event handlers and after calling
+	 * pselect(2) so handlers can use it to calculate a new
+	 * absolute timeout.
+	 *
+	 * Use netio_current_time() to read the current time.
 	 */
-	struct timespec current_time;
+	int have_current_time;
+	struct timespec cached_current_time;
 
 	/* Private.  */
 	region_type             *region;
@@ -140,6 +145,11 @@ void netio_add_handler(netio_type *netio, netio_handler_type *handler);
  */
 void netio_remove_handler(netio_type *netio, netio_handler_type *handler);
 
+/*
+ * Retrieve the current time (using gettimeofday(2).
+ */
+const struct timespec *netio_current_time(netio_type *netio);
+
 /*
  * Check for events and dispatch them to the handlers.  If TIMEOUT is
  * specified it specifies the maximum time to wait for an event to

server.c

@@ -747,7 +747,7 @@ handle_tcp_reading(netio_type *netio,
 
 	handler->timeout->tv_sec = TCP_TIMEOUT;
 	handler->timeout->tv_nsec = 0L;
-	timespec_add(handler->timeout, &netio->current_time);
+	timespec_add(handler->timeout, netio_current_time(netio));
 
 	handler->event_types = NETIO_EVENT_WRITE | NETIO_EVENT_TIMEOUT;
 	handler->event_handler = handle_tcp_writing;
@@ -842,7 +842,7 @@ handle_tcp_writing(netio_type *netio,
 			/* Reset timeout.  */
 			handler->timeout->tv_sec = TCP_TIMEOUT;
 			handler->timeout->tv_nsec = 0;
-			timespec_add(handler->timeout, &netio->current_time);
+			timespec_add(handler->timeout, netio_current_time(netio));
 
 			/*
 			 * Write data if/when the socket is writable
@@ -861,7 +861,7 @@ handle_tcp_writing(netio_type *netio,
 
 	handler->timeout->tv_sec = TCP_TIMEOUT;
 	handler->timeout->tv_nsec = 0;
-	timespec_add(handler->timeout, &netio->current_time);
+	timespec_add(handler->timeout, netio_current_time(netio));
 
 	handler->event_types = NETIO_EVENT_READ | NETIO_EVENT_TIMEOUT;
 	handler->event_handler = handle_tcp_reading;
@@ -945,7 +945,7 @@ handle_accept(netio_type *netio,
 	tcp_handler->timeout = region_alloc(tcp_region, sizeof(struct timespec));
 	tcp_handler->timeout->tv_sec = TCP_TIMEOUT;
 	tcp_handler->timeout->tv_nsec = 0L;
-	timespec_add(tcp_handler->timeout, &netio->current_time);
+	timespec_add(tcp_handler->timeout, netio_current_time(netio));
 
 	tcp_handler->user_data = tcp_data;
 	tcp_handler->event_types = NETIO_EVENT_READ | NETIO_EVENT_TIMEOUT;