Changeset 764

Timestamp:

05/29/07 22:42:50 (2 years ago)

Author:

alo

Message:

--

Files:

• cherokee/trunk/ChangeLog (modified) (1 diff)
• cherokee/trunk/cherokee/handler_server_info.c (modified) (1 diff)
• cherokee/trunk/cherokee/macros.h (modified) (3 diffs)
• cherokee/trunk/cherokee/server-protected.h (modified) (1 diff)
• cherokee/trunk/cherokee/server.c (modified) (17 diffs)
• cherokee/trunk/cherokee/server.h (modified) (1 diff)
• cherokee/trunk/cherokee/socket.c (modified) (2 diffs)
• cherokee/trunk/cherokee/thread.c (modified) (36 diffs)
• cherokee/trunk/cherokee/thread.h (modified) (2 diffs)

cherokee/trunk/ChangeLog

@@ +1 @@
+2007-05-22  A.D.F  <adefacc@tin.it>
+
+        * cherokee/macros.h:
+        - use saner values in defines;
+
+        * cherokee/thread.h:
+        - added new fields to struct cherokee_thread_t
+          in order to keep exact numbers of connections per thread;
+        - added new parameter to cherokee_thread_new();
+        - added new functions (for SINGLE THREAD):
+                cherokee_thread_accept_on();
+                cherokee_thread_accept_off();
+
+        * cherokee/thread.c:
+        - cherokee_thread_new():
+          - added new test conditions, calculation
+            of conns_accept limit, etc.;
+
+        -cherokee_thread_step_SINGLE_THREAD() and
+          cherokee_thread_step_MULTI_THREAD():
+          - added code to disable accepting new connections
+            when there are no more free slots (100% full)
+            and to reenable accepting new connections
+            when the number of connections is below 95% - 99%;
+          - removed calls to cherokee_fdpoll_is_full()
+            (by using #ifdef 0 ... #endif) because now
+            we test the number of open connections and
+            because cherokee_fdpoll_add() tests upper limit
+            and returns error if it is reached;
+          - now cherokee_fdpoll_watch() is always called
+            in order to avoid a busy wait loop when
+            there are no more free connection slots.
+
+        - process_active_connections():
+          - added tests on total server number of open connections,
+            if the number is > max_keepalive limit
+            then keepalive is disabled until that number
+            goes down (high water principle);
+            this is done because if the server reaches the max number
+            of connections and open connections are kept alive,
+            then the server is no more able to accept new connections
+            (for minutes or even for hours);
+
+        - other minor space cleanups.
+
+        * cherokee/server.c:
+        - removed local define MIN_SPARE_FDS;
+        - added local define MIN_LISTEN_FDS;
+        - better distribution of spare fds for each thread;
+        - forced a minimum number of fds per thread by
+          lowering the number of requested threads to reach
+          a minimum number as set in macros.h;
+        - now if srv->thread_num == 1 then
+          cherokee_thread_step_SINGLE_THREAD() is called
+          even if the server has been compiled with HAVE_PTHREAD 1
+          (this speedup connection handling by 2% - 3%);
+        - set max_keepalive limit to 93% of max. number of connections
+          so that server tries to close connections before
+          it reaches 100% of opened connections (this should prevent
+          the scenario where server is not able to accept new connections
+          for minutes or even hours);
+        - print_banner(),
+          added new information about max. server connections, etc.;
+        - minor space cleanups;
+
+        * cherokee/handler_server_info.c:
+        - added new info about current number of server connections
+          (which is different from the number of active connections);
+
+        * cherokee/socket.c:
+        - cherokee_socket_accept_fd(),
+          now ECONNABORTED returns ret_deny,
+          so callers should call this function again (retry loop)
+          instead of giving up and execute the process phase
+          (this should speed up a lot the server when clients
+           try to connect and abort connections before they
+           are accepted by server).
+        
-2007-05-06  Alvaro Lopez Ortega  <alvaro@alobbs.com>
-

cherokee/trunk/cherokee/handler_server_info.c

@@ -254 +254 @@
-build_connections_table_content (cherokee_buffer_t *buf, cherokee_server_t *srv)
-{
-
-
-
+
+
+
+
+
-        cherokee_server_get_active_conns (srv, &active);
-        cherokee_server_get_reusable_conns (srv, &reusable);
-
+        table_add_row_int (buf, "Open connections", conns_num);
-        table_add_row_int (buf, "Active connections", active);
-        table_add_row_int (buf, "Reusable connections", reusable);

cherokee/trunk/cherokee/macros.h

@@ -102 +102 @@
-#define MIN_SYSTEM_FD_NUM             20        /* range: 16 - 64 */
-#define MIN_SPARE_FDS                 10        /* range:  8 - 20 */
-4       /* range:  4 ... 32
-4       /* range:  4 ... 32
+8       /* range:  8 ... 65
+8       /* range:  8 ... 65
-
-#if (MIN_SYSTEM_FD_NUM < 16) 
@@ -111 +111 @@
-#error MIN_SPARE_FDS too low, < 8 !
-#endif
-4
-4
-
-4
-4
+8
+8
+
+8
+8
-#endif
-#if (MIN_THR_FDS > MIN_MAX_FDS)
-#error MIN_THR_FDS too high, > MIN_MAX_FDS !
-#endif
-(MIN_SYSTEM_FD_NUM - MIN_SPARE_FDS) / 2
+MIN_SYSTEM_FD_NUM - MIN_SPARE_FDS
-#error MIN_SYSTEM_FD_NUM too low or MIN_SPARE FDS too high !
-#endif
@@ -199 +199 @@
-        type * obj = (type *) malloc(sizeof(type)); \
-        return_if_fail (obj != NULL, ret_nomem) 
+
+/* We assume to have a C ANSI free().
+ */
+#define CHEROKEE_FREE(obj) \
+        do {            \
+        free (obj);     \
+        (obj) = NULL;   \
+        } while (0)
-
-#define CHEROKEE_TEMP(obj, size)                 \

cherokee/trunk/cherokee/server-protected.h

@@ -122 +122 @@
-        cherokee_poll_type_t       fdpoll_method;
-
+        /* Connection related.
+         */
+        int                        max_conns;
+        int                        max_keepalive_conns;
+
-        /* Networking config
-         */

cherokee/trunk/cherokee/server.c

@@ -91 +91 @@
-#define ENTRIES "core,server"
-
-
-
+
- */
-IN_SPARE_FDS  10
+AX_LISTEN_FDS 2
-
-ret_t
@@ -156 +155 @@
-        n->max_fds         = -1;
-        n->system_fd_limit = -1;
+        n->max_conns       =  0;
+        n->max_keepalive_conns =  0;
-        n->max_conn_reuse  = -1;
-
@@ -397 +398 @@
-        int error;
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
-        /* Reset `groups' attributes.
-         */
@@ -641 +644 @@
-        /* File descriptor limit
-         */
-fd
+conn
-
-        /* Threading stuff
@@ -647 +650 @@
-        if (srv->thread_num <= 1) {
-                cherokee_buffer_add_str (&n, ", single thread");
+                cherokee_buffer_add_va (&n, ", %d fds per thread", srv->max_fds);       
-        } else {
-                cherokee_buffer_add_va (&n, ", %d threads", srv->thread_num);
@@ -738 +742 @@
-{       
-        ret_t ret;
-
+, conns_per_thread
-#ifdef HAVE_PTHREAD
-        int   thr_fds, spare_fds;
-#endif
+
+        /* Reset max. conns value
+         */
+        srv->max_conns = 0;
+        srv->max_keepalive_conns = 0;
-
-        /* Verify max_fds value
@@ -759 +768 @@
-        srv->thread_num = 1;
-#endif
-
+
+
+
-#ifdef HAVE_PTHREAD
-        thr_fds = fds_per_thread * srv->thread_num;
-        spare_fds = srv->max_fds - thr_fds;
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-
-        /* Create the main thread
-         */
-        ret = cherokee_thread_new (&srv->main_thread, srv, thread_sync, 
-
+
+
-        if (unlikely(ret < ret_ok))
-                return ret;
@@ -780 +807 @@
-         * add the server socket to the fdpoll of the sync thread
-         */
-
-
-
-
-
-
-
-
-
+
+
+
+
+
-
-        /* If Cherokee has been compiled in multi-thread mode,
@@ -797 +820 @@
-                cherokee_thread_t *thread;
-
-one more fd
+a couple more fds
-                 * this is useful if we are using a huge number of threads
-                 * (i.e. 1000 or more) and we don't want to leave lots of
@@ -803 +826 @@
-                 */
-                fds_per_thread1 = fds_per_thread;
- 0
---
-++
+= 2
+ -= 2
+ += 2
-                }
+                conns_per_thread = fds_per_thread1 / 2;
+                srv->max_conns += conns_per_thread;
+                fds_per_thread1 += MAX_LISTEN_FDS;
-
-                ret = cherokee_thread_new (&thread, srv, thread_async, 
-
+
+
-                if (unlikely(ret < ret_ok))
-                        return ret;
@@ -819 +846 @@
-#endif
-
+        /* Set keepalive limit for open connections.
+         * NOTE: this limit has to be lower (93%)
+         *       than conns_accept limit (95% - 99%) used for threads.
+         */
+        srv->max_keepalive_conns = srv->max_conns - (srv->max_conns / 16);
+        if (srv->max_keepalive_conns + 6 > srv->max_conns)
+                srv->max_keepalive_conns = srv->max_conns - 6;
+
+        /* OK, return.
+         */
-        return ret_ok;
-}
@@ -977 +1014 @@
-         *       (i.e. FastCGI, SCGI, mirror, etc.).
-         */
- / 2
+
-        if (srv->max_fds < MIN_MAX_FDS) {
-connection
+fds
-                return ret_error;
-        }
@@ -1220 +1257 @@
-        ret_t ret;
-
-time
+server time.
-         */
-        update_bogo_now (srv);
-
-
+
+
+
+
+
+
+
+
+
+
+
-        /* Logger flush 
-         */
@@ -1244 +1290 @@
-         */
-        if (unlikely (srv->wanna_reinit)) {
-
+
+
+
-        }
-        
@@ -1252 +1300 @@
-        return ret_eagain;
-}
+
-
-static ret_t 
@@ -1681 +1730 @@
-
-ret_t 
+cherokee_server_get_conns_num (cherokee_server_t *srv, cuint_t *num)
+{
+        cuint_t          conns_num = 0;
+        cherokee_list_t *thread;
+
+        /* Open HTTP connections number
+         */
+        list_for_each (thread, &srv->thread_list) {
+                conns_num += THREAD(thread)->conns_num;
+        }
+        
+        conns_num += srv->main_thread->conns_num;
+
+        /* Return out parameters
+         */
+        *num = conns_num;
+
+        return ret_ok;
+}
+
+
+ret_t 
-cherokee_server_get_active_conns (cherokee_server_t *srv, cuint_t *num)
-{
@@ -1711 +1782 @@
-         */
-        list_for_each (thread, &srv->thread_list) {
-
-
-
-
-
-
-
+
+
+
-
-        /* Return out parameters

cherokee/trunk/cherokee/server.h

@@ -57 +57 @@
-ret_t cherokee_server_write_pidfile      (cherokee_server_t *srv);
-
+ret_t cherokee_server_get_conns_num      (cherokee_server_t *srv, cuint_t *num);
-ret_t cherokee_server_get_active_conns   (cherokee_server_t *srv, cuint_t *num);
-ret_t cherokee_server_get_reusable_conns (cherokee_server_t *srv, cuint_t *num);

cherokee/trunk/cherokee/socket.c

@@ -632 +632 @@
-        new_socket = accept (server_socket, &sa->sa, &len);
-        if (new_socket < 0) {
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-        }               
-
+
-        /* Disable Nagle's algorithm for this connection
-         * so that there is no delay involved when sending data
@@ -1181 +1204 @@
-                if (re < 0) {
-                        int err = SOCK_ERRNO();
-
+
-                        switch (err) {
-#if defined(EWOULDBLOCK) && (EWOULDBLOCK != EAGAIN)

cherokee/trunk/cherokee/thread.c

@@ -142 +142 @@
-         */
-        while (thread->exit == false) {
-
+_MULTI_THREAD
-        }
-
@@ -173 +173 @@
-
-ret_t 
-
-
+
+
+
+
-{
-        ret_t              ret;
+        int                conns_accept;
-        cherokee_server_t *srv = SRV(server);
-NEW_STRUCT (
+CNEW_STRUCT (1, 
-
-        /* Init
@@ -192 +195 @@
-                ret = cherokee_fdpoll_new (&n->fdpoll, fdpoll_type, system_fd_num, fd_num);
-
-
+
+
-                return ret;
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-        n->active_list_num   = 0;
-        n->polling_list_num  = 0;
-        n->reuse_list_num    = 0;
-
-        n->exit              = false;
-        n->pending_conns_num = 0;
+
-        n->server            = server;
-        n->thread_type       = type;
@@ -214 +259 @@
-
-        /* Temporary buffer used by utility functions
-       
+
-        cherokee_buffer_init (&n->tmp_buf1);
-        cherokee_buffer_init (&n->tmp_buf2);
@@ -257 +302 @@
-                /* Finally, create the system thread
-                 */
-
+
+
+
+
-#else
-                SHOULDNT_HAPPEN;
@@ -346 +394 @@
-         */
-        cherokee_connection_mrproper (conn);
+
+        if (thread->conns_num > 0)
+                thread->conns_num--;
-
-        /* Add it to the reusable list
@@ -576 +627 @@
-{
-        ret_t                  ret;
+        cuint_t                srv_conns_num = 0;
-        off_t                  len;
-        cherokee_list_t       *i, *tmp;
@@ -581 +633 @@
-        cherokee_server_t     *srv  = SRV(thd->server);
-
+        /* Get total connection count.
+         */
+        cherokee_server_get_conns_num (srv, &srv_conns_num);
+
-        /* Process active connections
-         */
@@ -591 +647 @@
-                 */
-                if (conn->timeout < thd->bogo_now) {
+                        srv_conns_num--;
-                        purge_closed_connection (thd, conn);
-                        continue;
@@ -617 +674 @@
-                        switch (num) {
-                        case -1:
+                                srv_conns_num--;
-                                purge_closed_connection(thd, conn);
-                                continue;
@@ -643 +701 @@
-                        case ret_eof:
-                        case ret_error:
+                                srv_conns_num--;
-                                purge_closed_connection (thd, conn);
-                                continue;
@@ -648 +707 @@
-                        default:
-                                RET_UNKNOWN(ret);
+                                srv_conns_num--;
-                                purge_closed_connection (thd, conn);
-                                continue;
@@ -674 +734 @@
-
-                        case ret_error:
+                                srv_conns_num--;
-                                purge_closed_connection (thd, conn);
-                                continue;
@@ -679 +740 @@
-                        default:
-                                RET_UNKNOWN(ret);
+                                srv_conns_num--;
-                                purge_closed_connection (thd, conn);
-                                break;
@@ -711 +773 @@
-
-                        case ret_error:
+                                srv_conns_num--;
-                                purge_closed_connection (thd, conn);
-                                continue;
@@ -716 +779 @@
-                        default:
-                                RET_UNKNOWN(ret);
+                                srv_conns_num--;
-                                purge_closed_connection (thd, conn);
-                                continue;
@@ -740 +804 @@
-                                        break;
-                                case ret_error:
+                                        srv_conns_num--;
-                                        purge_closed_connection (thd, conn);
-                                        continue;
-                                default:
-                                        RET_UNKNOWN(ret);
+                                        srv_conns_num--;
-                                        purge_closed_connection (thd, conn);
-                                        continue;
@@ -812 +878 @@
-                        case ret_eagain:
-                                continue;
-
+
-                        default:
-                                cherokee_connection_setup_error_handler (conn);
@@ -1013 +1079 @@
-                        /* Server's "Keep-Alive" could be turned "Off"
-                         */
-
+
+
+
-                                conn->keepalive = 0;
-                        }
@@ -1129 +1197 @@
-                        case ret_eof:
-                        case ret_error:
+                                srv_conns_num--;
-                                purge_closed_connection (thd, conn);
-                                continue;
@@ -1192 +1261 @@
-                                case ret_error:
-                                default:        
+                                        srv_conns_num--;
-                                        purge_closed_connection (thd, conn);
-                                        /* purge_maybe_lingering (thd, conn); */
@@ -1318 +1388 @@
-        cherokee_connection_t *new_conn;
-
-
-
-cherokee_fdpoll_check (thd->fdpoll, srv_socket, FDPOLL_MODE_READ) == 0) {
+too many or 
+
+thd->conns_num >= thd->conns_max)
-                return 0;
+
+        if (cherokee_fdpoll_check (thd->fdpoll, srv_socket, FDPOLL_MODE_READ) <= 0) {
+                return 0;
-        }
-
-        /* Try to get a new connection
-         */
-
-
+
+
+
+
+
+
-
-        /* We got the new socket, now set it up in a new connection object
@@ -1369 +1446 @@
-        }
-
+        thd->conns_num++;
+
-        TRACE (ENTRIES, "new conn %p, fd %d\n", new_conn, new_fd);
-
@@ -1392 +1471 @@
-        /* If it is full, do not accept more!
-         */
+        if (unlikely (thd->conns_num >= thd->conns_max))
+                return 0;
+
+#if 0
-        if (unlikely (cherokee_fdpoll_is_full(thd->fdpoll))) {
-                return 0;
-        }
+#endif
-
-        /* Got new connection
@@ -1424 +1508 @@
-
-ret_t 
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-{
-        int                re;
+        ret_t              ret;
-        cherokee_server_t *srv           = THREAD_SRV(thd);
-        int                fdwatch_msecs = srv->fdwatch_msecs;
@@ -1434 +1583 @@
-        try_to_update_bogo_now (thd);
-
-
+.
-         * cherokee_fdpoll_reset (thd->fdpoll, S_SOCKET_FD(srv->socket));
-         */
-
-        /* If the thread is full of connections, it should not
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
-        if (unlikely (cherokee_fdpoll_is_full (thd->fdpoll))) {
-                goto out;
-        }
+#endif
-
-        /* If thread has pending connections, it should do a 
@@ -1454 +1615 @@
-
-        re = cherokee_fdpoll_watch (thd->fdpoll, fdwatch_msecs);
-
+
+
-
-        do {
@@ -1460 +1622 @@
-        } while (__should_accept_more_from_server (thd, re));
-
+#ifdef HAVE_TLS
-        if (srv->tls_enabled) {
-                do {
@@ -1465 +1628 @@
-                } while (__should_accept_more_from_server (thd, re));
-        }
+#endif /* HAVE_TLS */
-
-out:
@@ -1485 +1649 @@
-        ret_t ret;
-
+        /* In this case, thd->is_accepting_conns is alwasy true.
+         */
-        CHEROKEE_MUTEX_LOCK (mutex);
-        
@@ -1523 +1689 @@
-        int   re;
-        ret_t ret;
-
+ = 1
-