diff --git a/ldap/servers/slapd/connection.c b/ldap/servers/slapd/connection.c
index e0c1a52d2..3d34bc1b4 100644
--- a/ldap/servers/slapd/connection.c
+++ b/ldap/servers/slapd/connection.c
@@ -1186,7 +1186,7 @@ connection_read_operation(Connection *conn, Operation *op, ber_tag_t *tag, int *
                 /* Connection is closed */
                 disconnect_server_nomutex(conn, conn->c_connid, -1, SLAPD_DISCONNECT_BAD_BER_TAG, 0);
                 conn->c_gettingber = 0;
-                signal_listner();
+                signal_listner(conn->c_ct_list);
                 ret = CONN_DONE;
                 goto done;
             }
@@ -1342,7 +1342,7 @@ connection_make_readable(Connection *conn)
     pthread_mutex_lock(&(conn->c_mutex));
     conn->c_gettingber = 0;
     pthread_mutex_unlock(&(conn->c_mutex));
-    signal_listner();
+    signal_listner(conn->c_ct_list);
 }
 
 void
@@ -1716,7 +1716,7 @@ connection_threadmain()
                 pthread_mutex_unlock(&(conn->c_mutex));
                 /* once the connection is readable, another thread may access conn,
                  * so need locking from here on */
-                signal_listner();
+                signal_listner(conn->c_ct_list);
             } else { /* more data in conn - just put back on work_q - bypass poll */
                 bypasspollcnt++;
                 pthread_mutex_lock(&(conn->c_mutex));
@@ -1794,7 +1794,7 @@ connection_threadmain()
             slapi_counter_decrement(g_get_global_snmp_vars()->ops_tbl.dsConnectionsInMaxThreads);
             connection_release_nolock(conn);
             pthread_mutex_unlock(&(conn->c_mutex));
-            signal_listner();
+            signal_listner(conn->c_ct_list);
             slapi_pblock_destroy(pb);
             return;
         }
@@ -1879,13 +1879,13 @@ connection_threadmain()
                      * before that call.
                      */
                     if (need_wakeup) {
-                        signal_listner();
+                        signal_listner(conn->c_ct_list);
                         need_wakeup = 0;
                     }
                 } else if (1 == is_timedout) {
                     /* covscan reports this code is unreachable  (2019/6/4) */
                     connection_make_readable_nolock(conn);
-                    signal_listner();
+                    signal_listner(conn->c_ct_list);
                 }
             }
             pthread_mutex_unlock(&(conn->c_mutex));
diff --git a/ldap/servers/slapd/conntable.c b/ldap/servers/slapd/conntable.c
index feb9c0d75..bbe1e5152 100644
--- a/ldap/servers/slapd/conntable.c
+++ b/ldap/servers/slapd/conntable.c
@@ -121,16 +121,19 @@
 #include "fe.h"
 
 Connection_Table *
-connection_table_new(int table_size)
+connection_table_new(int table_size, int num_lists)
 {
     Connection_Table *ct;
     int i = 0;
+    int j = 0;
     ber_len_t maxbersize = config_get_maxbersize();
 
     ct = (Connection_Table *)slapi_ch_calloc(1, sizeof(Connection_Table));
     ct->size = table_size;
-    ct->c = (Connection *)slapi_ch_calloc(1, table_size * sizeof(Connection));
-    ct->fd = (struct POLL_STRUCT *)slapi_ch_calloc(1, table_size * sizeof(struct POLL_STRUCT));
+    ct->numlists = num_lists;
+    ct->listindex = 0;
+    ct->c = (Connection **)slapi_ch_calloc(1, table_size * sizeof(Connection));
+    ct->fd = (struct POLL_STRUCT **)slapi_ch_calloc(1, table_size * sizeof(struct POLL_STRUCT));
     ct->table_mutex = PR_NewLock();
     /* Allocate the freelist */
     ct->c_freelist = (Connection **)slapi_ch_calloc(1, table_size * sizeof(Connection *));
@@ -141,53 +144,57 @@ connection_table_new(int table_size)
     pthread_mutexattr_t monitor_attr = {0};
     pthread_mutexattr_init(&monitor_attr);
     pthread_mutexattr_settype(&monitor_attr, PTHREAD_MUTEX_RECURSIVE);
+    for (j = 0; j < num_lists; j++) {
+
+        ct->c[j] = (Connection *)slapi_ch_calloc(1, table_size * sizeof(Connection));
+        ct->fd[j] = (struct POLL_STRUCT *)slapi_ch_calloc(1, table_size * sizeof(struct POLL_STRUCT));
+        /* We rely on the fact that we called calloc, which zeros the block, so we don't
+        * init any structure element unless a zero value is troublesome later
+        */
+        for (i = 0; i < table_size; i++) {
+            /*
+            * Technically this is a no-op due to calloc, but we should always be
+            * careful with things like this ....
+            */
+            ct->c[j][i].c_state = CONN_STATE_FREE;
+            /* Start the conn setup. */
+
+            LBER_SOCKET invalid_socket;
+            /* DBDB---move this out of here once everything works */
+            ct->c[j][i].c_sb = ber_sockbuf_alloc();
+            invalid_socket = SLAPD_INVALID_SOCKET;
+            ct->c[j][i].c_sd = SLAPD_INVALID_SOCKET;
+            ber_sockbuf_ctrl(ct->c[j][i].c_sb, LBER_SB_OPT_SET_FD, &invalid_socket);
+            ber_sockbuf_ctrl(ct->c[j][i].c_sb, LBER_SB_OPT_SET_MAX_INCOMING, &maxbersize);
+            /* all connections start out invalid */
+            ct->fd[j][i].fd = SLAPD_INVALID_SOCKET;
+
+            /* The connection table has a double linked list running through it.
+            * This is used to find out which connections should be looked at
+            * in the poll loop.  Slot 0 in the table is always the head of
+            * the linked list.  Each slot has a c_next and c_prev which are
+            * pointers back into the array of connection slots. */
+            ct->c[j][i].c_next = NULL;
+            ct->c[j][i].c_prev = NULL;
+            ct->c[j][i].c_ci = i;
+            ct->c[j][i].c_fdi = SLAPD_INVALID_SOCKET_INDEX;
+
+            if (pthread_mutex_init(&(ct->c[j][i].c_mutex), &monitor_attr) != 0) {
+                slapi_log_err(SLAPI_LOG_ERR, "connection_table_get_connection", "pthread_mutex_init failed\n");
+                exit(1);
+            }
 
-    /* We rely on the fact that we called calloc, which zeros the block, so we don't
-     * init any structure element unless a zero value is troublesome later
-     */
-    for (i = 0; i < table_size; i++) {
-        /*
-         * Technically this is a no-op due to calloc, but we should always be
-         * careful with things like this ....
-         */
-        ct->c[i].c_state = CONN_STATE_FREE;
-        /* Start the conn setup. */
-
-        LBER_SOCKET invalid_socket;
-        /* DBDB---move this out of here once everything works */
-        ct->c[i].c_sb = ber_sockbuf_alloc();
-        invalid_socket = SLAPD_INVALID_SOCKET;
-        ct->c[i].c_sd = SLAPD_INVALID_SOCKET;
-        ber_sockbuf_ctrl(ct->c[i].c_sb, LBER_SB_OPT_SET_FD, &invalid_socket);
-        ber_sockbuf_ctrl(ct->c[i].c_sb, LBER_SB_OPT_SET_MAX_INCOMING, &maxbersize);
-        /* all connections start out invalid */
-        ct->fd[i].fd = SLAPD_INVALID_SOCKET;
-
-        /* The connection table has a double linked list running through it.
-         * This is used to find out which connections should be looked at
-         * in the poll loop.  Slot 0 in the table is always the head of
-         * the linked list.  Each slot has a c_next and c_prev which are
-         * pointers back into the array of connection slots. */
-        ct->c[i].c_next = NULL;
-        ct->c[i].c_prev = NULL;
-        ct->c[i].c_ci = i;
-        ct->c[i].c_fdi = SLAPD_INVALID_SOCKET_INDEX;
-
-        if (pthread_mutex_init(&(ct->c[i].c_mutex), &monitor_attr) != 0) {
-            slapi_log_err(SLAPI_LOG_ERR, "connection_table_get_connection", "pthread_mutex_init failed\n");
-            exit(1);
-        }
+            ct->c[j][i].c_pdumutex = PR_NewLock();
+            if (ct->c[j][i].c_pdumutex == NULL) {
+                slapi_log_err(SLAPI_LOG_ERR, "connection_table_get_connection", "PR_NewLock failed\n");
+                exit(1);
+            }
 
-        ct->c[i].c_pdumutex = PR_NewLock();
-        if (ct->c[i].c_pdumutex == NULL) {
-            slapi_log_err(SLAPI_LOG_ERR, "connection_table_get_connection", "PR_NewLock failed\n");
-            exit(1);
+            /* Ready to rock, mark as such. */
+            ct->c[j][i].c_state = CONN_STATE_INIT;
+            /* Prepare the connection into the freelist. */
+            ct->c_freelist[i] = &(ct->c[j][i]);
         }
-
-        /* Ready to rock, mark as such. */
-        ct->c[i].c_state = CONN_STATE_INIT;
-        /* Prepare the connection into the freelist. */
-        ct->c_freelist[i] = &(ct->c[i]);
     }
 
     return ct;
@@ -198,11 +205,13 @@ connection_table_free(Connection_Table *ct)
 {
     /* Release the freelist */
     slapi_ch_free((void **)&ct->c_freelist);
-    /* Now release the connections. */
-    for (size_t i = 0; i < ct->size; i++) {
-        /* Free the contents of the connection structure */
-        Connection *c = &(ct->c[i]);
-        connection_done(c);
+    for (size_t j = 0; j < ct->numlists; j++) {
+        /* Now release the connections. */
+        for (size_t i = 0; i < ct->size; i++) {
+            /* Free the contents of the connection structure */
+            Connection *c = &(ct->c[j][i]);
+            connection_done(c);
+        }
     }
     slapi_ch_free((void **)&ct->c);
     slapi_ch_free((void **)&ct->fd);
@@ -213,11 +222,13 @@ connection_table_free(Connection_Table *ct)
 void
 connection_table_abandon_all_operations(Connection_Table *ct)
 {
-    for (size_t i = 0; i < ct->size; i++) {
-        if (ct->c[i].c_state != CONN_STATE_FREE) {
-            pthread_mutex_lock(&(ct->c[i].c_mutex));
-            connection_abandon_operations(&ct->c[i]);
-            pthread_mutex_unlock(&(ct->c[i].c_mutex));
+    for (size_t j = 0; j < ct->numlists; j++) {
+        for (size_t i = 0; i < ct->size; i++) {
+            if (ct->c[j][i].c_state != CONN_STATE_FREE) {
+                pthread_mutex_lock(&(ct->c[j][i].c_mutex));
+                connection_abandon_operations(&ct->c[j][i]);
+                pthread_mutex_unlock(&(ct->c[j][i].c_mutex));
+            }
         }
     }
 }
@@ -225,12 +236,14 @@ connection_table_abandon_all_operations(Connection_Table *ct)
 void
 connection_table_disconnect_all(Connection_Table *ct)
 {
-    for (size_t i = 0; i < ct->size; i++) {
-        if (ct->c[i].c_state != CONN_STATE_FREE) {
-            Connection *c = &(ct->c[i]);
-            pthread_mutex_lock(&(c->c_mutex));
-            disconnect_server_nomutex(c, c->c_connid, -1, SLAPD_DISCONNECT_ABORT, ECANCELED);
-            pthread_mutex_unlock(&(c->c_mutex));
+    for (size_t j = 0; j < ct->numlists; j++) {
+        for (size_t i = 0; i < ct->size; i++) {
+            if (ct->c[j][i].c_state != CONN_STATE_FREE) {
+                Connection *c = &(ct->c[j][i]);
+                pthread_mutex_lock(&(c->c_mutex));
+                disconnect_server_nomutex(c, c->c_connid, -1, SLAPD_DISCONNECT_ABORT, ECANCELED);
+                pthread_mutex_unlock(&(c->c_mutex));
+            }
         }
     }
 }
@@ -294,9 +307,9 @@ connection_table_get_connection(Connection_Table *ct, int sd)
 /* active connection iteration functions */
 
 Connection *
-connection_table_get_first_active_connection(Connection_Table *ct)
+connection_table_get_first_active_connection(Connection_Table *ct, int listnum)
 {
-    return ct->c[0].c_next;
+    return ct->c[listnum][0].c_next;
 }
 
 Connection *
@@ -314,14 +327,17 @@ connection_table_iterate_active_connections(Connection_Table *ct, void *arg, Con
      */
     Connection *current_conn = NULL;
     int ret = 0;
+    int i = 0;
     PR_Lock(ct->table_mutex);
-    current_conn = connection_table_get_first_active_connection(ct);
-    while (current_conn) {
-        ret = f(current_conn, arg);
-        if (ret) {
-            break;
+    for (i = 0; i < ct->numlists; i++) {
+        current_conn = connection_table_get_first_active_connection(ct, i);
+        while (current_conn) {
+            ret = f(current_conn, arg);
+            if (ret) {
+                break;
+            }
+            current_conn = connection_table_get_next_active_connection(ct, current_conn);
         }
-        current_conn = connection_table_get_next_active_connection(ct, current_conn);
     }
     PR_Unlock(ct->table_mutex);
     return ret;
@@ -332,22 +348,25 @@ static void
 connection_table_dump_active_connection(Connection *c)
 {
     slapi_log_err(SLAPI_LOG_DEBUG, "connection_table_dump_active_connection", "conn=%p fd=%d refcnt=%d c_flags=%d\n"
-                                                                              "mutex=%p next=%p prev=%p\n\n",
+                                                                              "mutex=%p next=%p prev=%p ctlist=%d\n\n",
                   c, c->c_sd, c->c_refcnt, c->c_flags,
-                  c->c_mutex, c->c_next, c->c_prev);
+                  c->c_mutex, c->c_next, c->c_prev, c->c_ct_list);
 }
 
 static void
 connection_table_dump_active_connections(Connection_Table *ct)
 {
     Connection *c;
+    int i = 0;
 
     PR_Lock(ct->table_mutex);
-    slapi_log_err(SLAPI_LOG_DEBUG, "connection_table_dump_active_connections", "********** BEGIN DUMP ************\n");
-    c = connection_table_get_first_active_connection(ct);
-    while (c) {
-        connection_table_dump_active_connection(c);
-        c = connection_table_get_next_active_connection(ct, c);
+    for (i = 0; i < ct->numlists; i++) {
+        slapi_log_err(SLAPI_LOG_DEBUG, "connection_table_dump_active_connections", "********** BEGIN DUMP ************\n");
+        c = connection_table_get_first_active_connection(ct, i);
+        while (c) {
+            connection_table_dump_active_connection(c);
+            c = connection_table_get_next_active_connection(ct, c);
+        }
     }
 
     slapi_log_err(SLAPI_LOG_DEBUG, "connection_table_dump_active_connections", "********** END DUMP ************\n");
@@ -471,12 +490,15 @@ connection_table_move_connection_on_to_active_list(Connection_Table *ct, Connect
     connection_table_dump_active_connection(c);
 #endif
 
-    c->c_next = ct->c[0].c_next;
+    /* Map new connection to connection table list */
+    c->c_ct_list = connection_table_get_list(ct);
+
+    c->c_next = ct->c[c->c_ct_list][0].c_next;
     if (c->c_next != NULL) {
         c->c_next->c_prev = c;
     }
-    c->c_prev = &(ct->c[0]);
-    ct->c[0].c_next = c;
+    c->c_prev = &(ct->c[c->c_ct_list][0]);
+    ct->c[c->c_ct_list][0].c_next = c;
 
     PR_Unlock(ct->table_mutex);
 
@@ -484,6 +506,16 @@ connection_table_move_connection_on_to_active_list(Connection_Table *ct, Connect
     connection_table_dump_active_connections(ct);
 #endif
 }
+/* Get which active list to use */
+int
+connection_table_get_list(Connection_Table *ct)
+{
+    int ret = -1;
+    /* No need to lock here as calling function will have the ct lock */
+    ret = ct->listindex;
+    ct->listindex = (ct->listindex + 1) % ct->numlists;
+    return ret;
+}
 
 /*
  * Replace the following attributes within the entry 'e' with
@@ -501,7 +533,7 @@ connection_table_as_entry(Connection_Table *ct, Slapi_Entry *e)
     char maxthreadbuf[BUFSIZ];
     struct berval val;
     struct berval *vals[2];
-    int i, nconns, nreadwaiters;
+    int i, j, nconns, nreadwaiters;
     struct tm utm;
 
     vals[0] = &val;
@@ -510,90 +542,92 @@ connection_table_as_entry(Connection_Table *ct, Slapi_Entry *e)
     attrlist_delete(&e->e_attrs, "connection");
     nconns = 0;
     nreadwaiters = 0;
-    for (i = 0; i < (ct != NULL ? ct->size : 0); i++) {
-        PR_Lock(ct->table_mutex);
-        if (ct->c[i].c_state == CONN_STATE_FREE) {
+    for (j = 0; j < (ct != NULL ? ct->numlists : 0); j++) {
+        for (i = 0; i < (ct != NULL ? ct->size : 0); i++) {
+            PR_Lock(ct->table_mutex);
+            if (ct->c[j][i].c_state == CONN_STATE_FREE) {
+                PR_Unlock(ct->table_mutex);
+                continue;
+            }
+            /* Can't take c_mutex if holding table_mutex; temporarily unlock */
             PR_Unlock(ct->table_mutex);
-            continue;
-        }
-        /* Can't take c_mutex if holding table_mutex; temporarily unlock */
-        PR_Unlock(ct->table_mutex);
 
-        pthread_mutex_lock(&(ct->c[i].c_mutex));
-        if (ct->c[i].c_sd != SLAPD_INVALID_SOCKET) {
-            char buf2[SLAPI_TIMESTAMP_BUFSIZE+1];
-            size_t lendn = ct->c[i].c_dn ? strlen(ct->c[i].c_dn) : 6; /* "NULLDN" */
-            size_t lenip = ct->c[i].c_ipaddr ? strlen(ct->c[i].c_ipaddr) : 0;
-            size_t lenconn = 1;
-            uint64_t connid = ct->c[i].c_connid;
-            char *bufptr = &buf[0];
-            char *newbuf = NULL;
-            int maxthreadstate = 0;
-
-            /* Get the connid length */
-            while (connid > 9) {
-                lenconn++;
-                connid /= 10;
-            }
+            pthread_mutex_lock(&(ct->c[j][i].c_mutex));
+            if (ct->c[j][i].c_sd != SLAPD_INVALID_SOCKET) {
+                char buf2[SLAPI_TIMESTAMP_BUFSIZE+1];
+                size_t lendn = ct->c[j][i].c_dn ? strlen(ct->c[j][i].c_dn) : 6; /* "NULLDN" */
+                size_t lenip = ct->c[j][i].c_ipaddr ? strlen(ct->c[j][i].c_ipaddr) : 0;
+                size_t lenconn = 1;
+                uint64_t connid = ct->c[j][i].c_connid;
+                char *bufptr = &buf[0];
+                char *newbuf = NULL;
+                int maxthreadstate = 0;
+
+                /* Get the connid length */
+                while (connid > 9) {
+                    lenconn++;
+                    connid /= 10;
+                }
 
-            if (ct->c[i].c_flags & CONN_FLAG_MAX_THREADS) {
-                maxthreadstate = 1;
-            }
+                if (ct->c[j][i].c_flags & CONN_FLAG_MAX_THREADS) {
+                    maxthreadstate = 1;
+                }
 
-            nconns++;
-            if (ct->c[i].c_gettingber) {
-                nreadwaiters++;
-            }
+                nconns++;
+                if (ct->c[j][i].c_gettingber) {
+                    nreadwaiters++;
+                }
 
-            gmtime_r(&ct->c[i].c_starttime, &utm);
-            strftime(buf2, SLAPI_TIMESTAMP_BUFSIZE, "%Y%m%d%H%M%SZ", &utm);
+                gmtime_r(&ct->c[j][i].c_starttime, &utm);
+                strftime(buf2, SLAPI_TIMESTAMP_BUFSIZE, "%Y%m%d%H%M%SZ", &utm);
 
-            /*
-             * Max threads per connection stats
-             *
-             * Appended output "1:2:3"
-             *
-             * 1 = Connection max threads state:  1 is in max threads, 0 is not
-             * 2 = The number of times this thread has hit max threads
-             * 3 = The number of operations attempted that were blocked
-             *     by max threads.
-             */
-            snprintf(maxthreadbuf, sizeof(maxthreadbuf), "%d:%" PRIu64 ":%" PRIu64 "",
-                     maxthreadstate, ct->c[i].c_maxthreadscount,
-                     ct->c[i].c_maxthreadsblocked);
-
-            if ((lenconn + lenip + lendn + strlen(maxthreadbuf)) > (BUFSIZ - 54)) {
                 /*
-                 * 54 =  8 for the colon separators +
-                 *       6 for the "i" counter +
-                 *      15 for buf2 (date) +
-                 *      10 for c_opsinitiated +
-                 *      10 for c_opscompleted +
-                 *       1 for c_gettingber +
-                 *       3 for "ip=" +
-                 *       1 for NULL terminator
-                 */
-                newbuf = (char *)slapi_ch_malloc(lenconn + lendn + lenip + strlen(maxthreadbuf) + 54);
-                bufptr = newbuf;
-            }
+                * Max threads per connection stats
+                *
+                * Appended output "1:2:3"
+                *
+                * 1 = Connection max threads state:  1 is in max threads, 0 is not
+                * 2 = The number of times this thread has hit max threads
+                * 3 = The number of operations attempted that were blocked
+                *     by max threads.
+                */
+                snprintf(maxthreadbuf, sizeof(maxthreadbuf), "%d:%" PRIu64 ":%" PRIu64 "",
+                        maxthreadstate, ct->c[j][i].c_maxthreadscount,
+                        ct->c[j][i].c_maxthreadsblocked);
+
+                if ((lenconn + lenip + lendn + strlen(maxthreadbuf)) > (BUFSIZ - 54)) {
+                    /*
+                    * 54 =  8 for the colon separators +
+                    *       6 for the "i" counter +
+                    *      15 for buf2 (date) +
+                    *      10 for c_opsinitiated +
+                    *      10 for c_opscompleted +
+                    *       1 for c_gettingber +
+                    *       3 for "ip=" +
+                    *       1 for NULL terminator
+                    */
+                    newbuf = (char *)slapi_ch_malloc(lenconn + lendn + lenip + strlen(maxthreadbuf) + 54);
+                    bufptr = newbuf;
+                }
 
-            sprintf(bufptr, "%d:%s:%d:%d:%s%s:%s:%s:%" PRIu64 ":ip=%s",
-                    i,
-                    buf2,
-                    ct->c[i].c_opsinitiated,
-                    ct->c[i].c_opscompleted,
-                    ct->c[i].c_gettingber ? "r" : "-",
-                    "",
-                    ct->c[i].c_dn ? ct->c[i].c_dn : "NULLDN",
-                    maxthreadbuf,
-                    ct->c[i].c_connid,
-                    ct->c[i].c_ipaddr);
-            val.bv_val = bufptr;
-            val.bv_len = strlen(bufptr);
-            attrlist_merge(&e->e_attrs, "connection", vals);
-            slapi_ch_free_string(&newbuf);
+                sprintf(bufptr, "%d:%s:%d:%d:%s%s:%s:%s:%" PRIu64 ":ip=%s",
+                        i,
+                        buf2,
+                        ct->c[j][i].c_opsinitiated,
+                        ct->c[j][i].c_opscompleted,
+                        ct->c[j][i].c_gettingber ? "r" : "-",
+                        "",
+                        ct->c[j][i].c_dn ? ct->c[j][i].c_dn : "NULLDN",
+                        maxthreadbuf,
+                        ct->c[j][i].c_connid,
+                        ct->c[j][i].c_ipaddr);
+                val.bv_val = bufptr;
+                val.bv_len = strlen(bufptr);
+                attrlist_merge(&e->e_attrs, "connection", vals);
+                slapi_ch_free_string(&newbuf);
+            }
+            pthread_mutex_unlock(&(ct->c[j][i].c_mutex));
         }
-        pthread_mutex_unlock(&(ct->c[i].c_mutex));
     }
 
     snprintf(buf, sizeof(buf), "%d", nconns);
@@ -631,22 +665,24 @@ void
 connection_table_dump_activity_to_errors_log(Connection_Table *ct)
 {
     int i;
-
-    for (i = 0; i < ct->size; i++) {
-        Connection *c = &(ct->c[i]);
-        if (c->c_state) {
-            /* Find the connection we are referring to */
-            int j = c->c_fdi;
-            pthread_mutex_lock(&(c->c_mutex));
-            if ((c->c_sd != SLAPD_INVALID_SOCKET) &&
-                (j >= 0) && (c->c_prfd == ct->fd[j].fd)) {
-                int r = ct->fd[j].out_flags & SLAPD_POLL_FLAGS;
-                if (r) {
-                    slapi_log_err(SLAPI_LOG_CONNS, "connection_table_dump_activity_to_errors_log",
-                                  "activity on %d%s\n", i, r ? "r" : "");
+    int l;
+    for (l = 0; l < ct->numlists; l++) {
+        for (i = 0; i < ct->size; i++) {
+            Connection *c = &(ct->c[l][i]);
+            if (c->c_state) {
+                /* Find the connection we are referring to */
+                int j = c->c_fdi;
+                pthread_mutex_lock(&(c->c_mutex));
+                if ((c->c_sd != SLAPD_INVALID_SOCKET) &&
+                    (j >= 0) && (c->c_prfd == ct->fd[l][j].fd)) {
+                    int r = ct->fd[l][j].out_flags & SLAPD_POLL_FLAGS;
+                    if (r) {
+                        slapi_log_err(SLAPI_LOG_CONNS, "connection_table_dump_activity_to_errors_log",
+                                    "activity on %d%s\n", i, r ? "r" : "");
+                    }
                 }
+                pthread_mutex_unlock(&(c->c_mutex));
             }
-            pthread_mutex_unlock(&(c->c_mutex));
         }
     }
 }
diff --git a/ldap/servers/slapd/daemon.c b/ldap/servers/slapd/daemon.c
index 90354801e..346a674ae 100644
--- a/ldap/servers/slapd/daemon.c
+++ b/ldap/servers/slapd/daemon.c
@@ -66,6 +66,7 @@
 
 int slapd_wakeup_timer = SLAPD_WAKEUP_TIMER; /* time in ms to wakeup */
 int slapd_accept_wakeup_timer = SLAPD_ACCEPT_WAKEUP_TIMER; /* time in ms to wakeup */
+int slapd_ct_thread_wakeup_timer = SLAPD_WAKEUP_TIMER; /* time in ms to wakeup */
 #ifdef notdef                                /* GGOODREPL */
 /*
  * time in secs to do housekeeping:
@@ -74,17 +75,20 @@ int slapd_accept_wakeup_timer = SLAPD_ACCEPT_WAKEUP_TIMER; /* time in ms to wake
 short slapd_housekeeping_timer = 10;
 #endif /* notdef GGOODREPL */
 
-PRFileDesc *signalpipe[2];
-static int writesignalpipe = SLAPD_INVALID_SOCKET;
-static int readsignalpipe = SLAPD_INVALID_SOCKET;
 #define FDS_SIGNAL_PIPE 0
 
+//jc, i think we should hardcode this. 2 ct lists seems the optimal config. Or make it a config option ?
+#define NUM_CT_LISTS 2
+static signal_pipe signalpipes[NUM_CT_LISTS]; /* One signal pipe per connection table list */
+static PRInt32 ct_shutdown = 0;
 static PRThread *disk_thread_p = NULL;
 static PRThread *accept_thread_p = NULL;
 static pthread_cond_t diskmon_cvar;
 static pthread_mutex_t diskmon_mutex;
 
 void disk_monitoring_stop(void);
+void init_ct_list_threads(void);
+void ct_thread_cleanup(void);
 
 typedef struct listener_info
 {
@@ -116,13 +120,13 @@ static const char *netaddr2string(const PRNetAddr *addr, char *addrbuf, size_t a
 static void set_shutdown(int);
 static void setup_pr_ct_firsttime_pds(Connection_Table *ct);
 static PRIntn setup_pr_accept_pds(PRFileDesc **n_tcps, PRFileDesc **s_tcps, PRFileDesc **i_unix, struct POLL_STRUCT **fds);
-static PRIntn setup_pr_read_pds(Connection_Table *ct);
+static PRIntn setup_pr_read_pds(Connection_Table *ct, int num_ct_lists);
 
 #ifdef HPUX10
 static void *catch_signals();
 #endif
 
-static int createsignalpipe(void);
+static int createsignalpipe(int num_ct_lists);
 
 static char *
 get_pid_file(void)
@@ -152,8 +156,8 @@ accept_and_configure(int s __attribute__((unused)), PRFileDesc *pr_acceptfd, PRN
  * This is the shiny new re-born daemon function, without all the hair
  */
 static int handle_new_connection(Connection_Table *ct, int tcps, PRFileDesc *pr_acceptfd, int secure, int local, Connection **newconn);
-static void handle_pr_read_ready(Connection_Table *ct, PRIntn num_poll);
-static int clear_signal(struct POLL_STRUCT *fds);
+static void handle_pr_read_ready(Connection_Table *ct, int list_id, PRIntn num_poll);
+static int clear_signal(struct POLL_STRUCT *fds, int list_id);
 static void unfurl_banners(Connection_Table *ct, daemon_ports_t *ports, PRFileDesc **n_tcps, PRFileDesc **s_tcps, PRFileDesc **i_unix);
 static int write_pid_file(void);
 static int init_shutdown_detect(void);
@@ -766,6 +770,7 @@ handle_listeners(struct POLL_STRUCT *fds)
 {
     Connection_Table *ct = the_connection_table;
     size_t idx;
+    int ctlist;
     for (idx = 0; idx < listeners; ++idx) {
         int fdidx = listener_idxs[idx].idx;
         PRFileDesc *listenfd = listener_idxs[idx].listenfd;
@@ -776,14 +781,14 @@ handle_listeners(struct POLL_STRUCT *fds)
             PR_ASSERT(listenfd == fds[fdidx].fd);
             if (SLAPD_POLL_LISTEN_READY(fds[fdidx].out_flags)) {
                 /* accept() the new connection, put it on the active list for handle_pr_read_ready */
-                int rc = handle_new_connection(ct, SLAPD_INVALID_SOCKET, listenfd, secure, local, NULL);
-                if (rc) {
+                ctlist = handle_new_connection(ct, SLAPD_INVALID_SOCKET, listenfd, secure, local, NULL);
+                if (ctlist < 0) {
                     slapi_log_err(SLAPI_LOG_CONNS, "handle_listeners", "Error accepting new connection listenfd=%d\n",
                                   PR_FileDesc2NativeHandle(listenfd));
                     continue;
                 } else {
                     /* Wake up the main event loop to handle this immediately. */
-                    signal_listner();
+                    signal_listner(ctlist);
                 }
             }
         }
@@ -925,7 +930,8 @@ slapd_daemon(daemon_ports_t *ports)
     uint64_t threads;
     int in_referral_mode = config_check_referral_mode();
     int connection_table_size = get_configured_connection_table_size();
-    the_connection_table = connection_table_new(connection_table_size);
+
+    the_connection_table = connection_table_new(connection_table_size, NUM_CT_LISTS);
 
     /*
      * Log a warning if we detect nunc-stans
@@ -956,7 +962,7 @@ slapd_daemon(daemon_ports_t *ports)
     i_unix = ports->i_socket;
 #endif /* ENABLE_LDAPI */
 
-    createsignalpipe();
+    createsignalpipe(NUM_CT_LISTS);
     /* Setup our signal interception. */
     init_shutdown_detect();
 
@@ -972,6 +978,7 @@ slapd_daemon(daemon_ports_t *ports)
 
     init_op_threads();
 
+    init_ct_list_threads();
     /*
      *  If we are monitoring disk space, then create the mutex, the cvar,
      *  and the monitoring thread.
@@ -1105,33 +1112,11 @@ slapd_daemon(daemon_ports_t *ports)
                   "MAINPID=%lu",
                   (unsigned long)getpid());
 #endif
-
     /* The meat of the operation is in a loop on a call to select */
     while (!g_get_shutdown()) {
-        int select_return = 0;
-        PRErrorCode prerr;
 
-        num_poll = setup_pr_read_pds(the_connection_table);
-        select_return = POLL_FN(the_connection_table->fd, num_poll, pr_timeout);
-        switch (select_return) {
-        case 0: /* Timeout */
-            break;
-        case -1: /* Error */
-            prerr = PR_GetError();
-            slapi_log_err(SLAPI_LOG_TRACE, "slapd_daemon", "PR_Poll() failed, " SLAPI_COMPONENT_NAME_NSPR " error %d (%s)\n",
-                          prerr, slapd_system_strerror(prerr));
-            break;
-        default: /* some new data ready */
-            /* handle new connections from the listeners */
-            /*
-             *  Now done in accept_thread
-             * handle_listeners(the_connection_table);
-             */
-            /* handle new data ready */
-            handle_pr_read_ready(the_connection_table, connection_table_size);
-            clear_signal(the_connection_table->fd);
-            break;
-        }
+        //jc, replace this with thread health checking code
+        usleep(250);
     }
     /* We get here when the server is shutting down */
     /* Do what we have to do before death */
@@ -1147,6 +1132,7 @@ slapd_daemon(daemon_ports_t *ports)
     }
 
     op_thread_cleanup();
+    ct_thread_cleanup();
     housekeeping_stop(); /* Run this after op_thread_cleanup() logged sth */
     disk_monitoring_stop();
 
@@ -1171,37 +1157,42 @@ slapd_daemon(daemon_ports_t *ports)
     threads = g_get_active_threadcnt();
     if (threads > 0) {
         slapi_log_err(SLAPI_LOG_INFO, "slapd_daemon",
-                      "slapd shutting down - waiting for %" PRIu64 " thread%s to terminate\n",
+                       "slapd shutting down - waiting for %" PRIu64 " thread%s to terminate\n",
                       threads, (threads > 1) ? "s" : "");
     }
 
     threads = g_get_active_threadcnt();
     while (threads > 0) {
         PRPollDesc xpd;
+        PRPollDesc xpd2;
         char x;
         int spe = 0;
+        int i = 0;
 
         /* try to read from the signal pipe, in case threads are
          * blocked on it. */
-        xpd.fd = signalpipe[0];
-        xpd.in_flags = PR_POLL_READ;
-        xpd.out_flags = 0;
-        spe = PR_Poll(&xpd, 1, PR_INTERVAL_NO_WAIT);
-        if (spe > 0) {
-            spe = PR_Read(signalpipe[0], &x, 1);
-            if (spe < 0) {
+        for(i = 0; i < the_connection_table->numlists; i++)
+        {
+            xpd.fd = signalpipes[i].signalpipe[0];
+            xpd.in_flags = PR_POLL_READ;
+            xpd.out_flags = 0;
+            spe = PR_Poll(&xpd, 1, PR_INTERVAL_NO_WAIT);
+            if (spe > 0) {
+                spe = PR_Read(signalpipes[i].signalpipe[0], &x, 1);
+                if (spe < 0) {
+                    PRErrorCode prerr = PR_GetError();
+                    slapi_log_err(SLAPI_LOG_ERR, "slapd_daemon", "listener could not clear signal pipe, " SLAPI_COMPONENT_NAME_NSPR " error %d (%s)\n",
+                                  prerr, slapd_system_strerror(prerr));
+                    break;
+                }
+            } else if (spe == -1) {
                 PRErrorCode prerr = PR_GetError();
-                slapi_log_err(SLAPI_LOG_ERR, "slapd_daemon", "listener could not clear signal pipe, " SLAPI_COMPONENT_NAME_NSPR " error %d (%s)\n",
+                slapi_log_err(SLAPI_LOG_ERR, "slapd_daemon", "PR_Poll() failed, " SLAPI_COMPONENT_NAME_NSPR " error %d (%s)\n",
                               prerr, slapd_system_strerror(prerr));
                 break;
+            } else {
+                /* no data */
             }
-        } else if (spe == -1) {
-            PRErrorCode prerr = PR_GetError();
-            slapi_log_err(SLAPI_LOG_ERR, "slapd_daemon", "PR_Poll() failed, " SLAPI_COMPONENT_NAME_NSPR " error %d (%s)\n",
-                          prerr, slapd_system_strerror(prerr));
-            break;
-        } else {
-            /* no data */
         }
         DS_Sleep(PR_INTERVAL_NO_WAIT);
         if (threads != g_get_active_threadcnt()) {
@@ -1274,30 +1265,100 @@ slapd_daemon(daemon_ports_t *ports)
     }
 }
 
+
+void
+ct_thread_cleanup(void)
+{
+    int i = 0;
+    int numthreads = the_connection_table->numlists;
+    slapi_log_err(SLAPI_LOG_INFO, "ct_thread_cleanup",
+                  "slapd shutting down - signaling connection table threads\n");
+
+    PR_AtomicIncrement(&ct_shutdown);
+    for (i = 0; i < numthreads; i++) {
+        g_decr_active_threadcnt();
+    }
+}
+
+void
+ct_list_thread(uint64_t threadnum)
+{
+    uint64_t threadid = (uint64_t) threadnum;
+
+       while (!ct_shutdown) {
+            int select_return = 0;
+            PRIntn num_poll = 0;
+            PRIntervalTime pr_timeout = PR_MillisecondsToInterval(slapd_ct_thread_wakeup_timer);
+            int connection_table_size = get_configured_connection_table_size();
+            PRErrorCode prerr;
+            num_poll = setup_pr_read_pds(the_connection_table, threadid);
+            select_return = POLL_FN(the_connection_table->fd[threadid], num_poll, pr_timeout);
+            switch (select_return) {
+            case 0: /* Timeout */
+                break;
+            case -1: /* Error */
+                prerr = PR_GetError();
+                slapi_log_err(SLAPI_LOG_TRACE, "ct_list_thread", "PR_Poll() failed, " SLAPI_COMPONENT_NAME_NSPR " error %d (%s)\n",
+                            prerr, slapd_system_strerror(prerr));
+                break;
+            default: /* some new data ready */
+                /* handle new data ready */
+                handle_pr_read_ready(the_connection_table, threadid, connection_table_size);
+                clear_signal(the_connection_table->fd[threadid], threadid);
+                break;
+            }
+       }
+}
+
+/* Create thread for each connection table list */
+void
+init_ct_list_threads(void)
+{
+    pthread_condattr_t condAttr;
+    int ctlists = the_connection_table->numlists;
+
+    /* start the connection table threads, one thread per CT list */
+    for (uint64_t i = 0; i < ctlists; i++) {
+        if(PR_CreateThread(PR_SYSTEM_THREAD,
+                            (VFP)(void *)ct_list_thread, (void *) i,
+                            PR_PRIORITY_URGENT, PR_GLOBAL_THREAD,
+                            PR_JOINABLE_THREAD,
+                            SLAPD_DEFAULT_THREAD_STACKSIZE) == NULL) {
+            int prerr = PR_GetError();
+            slapi_log_err(SLAPI_LOG_ERR, "init_ct_list_threads",
+                          "PR_CreateThread failed - Shutting Down (" SLAPI_COMPONENT_NAME_NSPR " error %d (%s)\n",
+                          prerr, slapd_pr_strerror(prerr));
+                          g_set_shutdown(SLAPI_SHUTDOWN_EXIT);
+        } else {
+            g_incr_active_threadcnt();
+        }
+    }
+}
+
 int
-signal_listner()
+signal_listner(int list_num)
 {
     /* Replaces previous macro---called to bump the thread out of select */
-    if (write(writesignalpipe, "", 1) != 1) {
+    if (write(signalpipes[list_num].writesignalpipe, "", 1) != 1) {
         /* this now means that the pipe is full
-         * this is not a problem just go-on
-         */
+        * this is not a problem just go-on
+        */
         slapi_log_err(SLAPI_LOG_CONNS,
-                      "signal_listner", "Listener could not write to signal pipe %d\n",
-                      errno);
+                    "signal_listner", "Listener could not write to signal pipe %d\n",
+                    errno);
     }
     return (0);
 }
 
 static int
-clear_signal(struct POLL_STRUCT *fds)
+clear_signal(struct POLL_STRUCT *fds, int list_num)
 {
     if (fds[FDS_SIGNAL_PIPE].out_flags & SLAPD_POLL_FLAGS) {
         char buf[200];
 
-        slapi_log_err(SLAPI_LOG_CONNS, "clear_signal", "Listener got signaled\n");
-        if (read(readsignalpipe, buf, 200) < 1) {
-            slapi_log_err(SLAPI_LOG_ERR, "clear_signal", "Listener could not clear signal pipe\n");
+        if (read(signalpipes[list_num].readsignalpipe, buf, 200) < 1) {
+            slapi_log_err(SLAPI_LOG_ERR, "clear_signal", "Listener %d could not clear signal pipe\n",
+            list_num);
         }
     }
     return 0;
@@ -1398,18 +1459,24 @@ setup_pr_accept_pds(PRFileDesc **n_tcps, PRFileDesc **s_tcps, PRFileDesc **i_uni
 static void
 setup_pr_ct_firsttime_pds(Connection_Table *ct)
 {
-    for (size_t i = 0; i < ct->size; i++) {
-        ct->c[i].c_fdi = SLAPD_INVALID_SOCKET_INDEX;
-    }
-    /* The fds entry for the signalpipe is always FDS_SIGNAL_PIPE (== 0) */
-    PRIntn count = FDS_SIGNAL_PIPE;
-    ct->fd[count].fd = signalpipe[0];
-    ct->fd[count].in_flags = SLAPD_POLL_FLAGS;
-    ct->fd[count].out_flags = 0;
+    size_t i = 0;
+    size_t j = 0;
+
+    for (j = 0; j < ct->numlists; j++) {
+        for (size_t i = 0; i < ct->size; i++) {
+            ct->c[j][i].c_fdi = SLAPD_INVALID_SOCKET_INDEX;
+        }
+
+        /* The fds entry for the signalpipe is always FDS_SIGNAL_PIPE (== 0) */
+        PRIntn count = FDS_SIGNAL_PIPE;
+        ct->fd[j][count].fd = signalpipes[j].signalpipe[0];
+        ct->fd[j][count].in_flags = SLAPD_POLL_FLAGS;
+        ct->fd[j][count].out_flags = 0;
+    }
 }
 
 static PRIntn
-setup_pr_read_pds(Connection_Table *ct)
+setup_pr_read_pds(Connection_Table *ct, int listnum)
 {
     Connection *c = NULL;
     Connection *next = NULL;
@@ -1422,7 +1489,7 @@ setup_pr_read_pds(Connection_Table *ct)
      * out which connections we should poll over.  If a connection
      * is no longer in use, we should remove it from the linked
      * list. */
-    c = connection_table_get_first_active_connection(ct);
+    c = connection_table_get_first_active_connection(ct, listnum);
     while (c && count < ct->size) {
         next = connection_table_get_next_active_connection(ct, c);
         if (c->c_state == CONN_STATE_FREE) {
@@ -1458,8 +1525,8 @@ setup_pr_read_pds(Connection_Table *ct)
                         add_fd = 0; /* do not poll on this fd */
                     }
                     if (add_fd) {
-                        ct->fd[count].fd = c->c_prfd;
-                        ct->fd[count].in_flags = SLAPD_POLL_FLAGS;
+                        ct->fd[listnum][count].fd = c->c_prfd;
+                        ct->fd[listnum][count].in_flags = SLAPD_POLL_FLAGS;
                         /* slot i of the connection table is mapped to slot
                          * count of the fds array */
                         c->c_fdi = count;
@@ -1501,7 +1568,7 @@ daemon_register_reslimits(void)
 }
 
 static void
-handle_pr_read_ready(Connection_Table *ct, PRIntn num_poll __attribute__((unused)))
+handle_pr_read_ready(Connection_Table *ct, int list_num, PRIntn num_poll __attribute__((unused)))
 {
     Connection *c;
     time_t curtime = slapi_current_rel_time_t();
@@ -1517,7 +1584,7 @@ handle_pr_read_ready(Connection_Table *ct, PRIntn num_poll __attribute__((unused
      * This function is called for all connections, so we traverse the entire
      * active connection list to find any errors, activity, etc.
      */
-    for (c = connection_table_get_first_active_connection(ct); c != NULL;
+    for (c = connection_table_get_first_active_connection(ct, list_num); c != NULL;
          c = connection_table_get_next_active_connection(ct, c)) {
         if (c->c_state != CONN_STATE_FREE) {
             /* this check can be done without acquiring the mutex */
@@ -1531,7 +1598,7 @@ handle_pr_read_ready(Connection_Table *ct, PRIntn num_poll __attribute__((unused
                 short readready;
 
                 if (c->c_fdi != SLAPD_INVALID_SOCKET_INDEX) {
-                    out_flags = ct->fd[c->c_fdi].out_flags;
+                    out_flags = ct->fd[list_num][c->c_fdi].out_flags;
                 } else {
                     out_flags = 0;
                 }
@@ -1771,7 +1838,9 @@ handle_closed_connection(Connection *conn)
     ber_sockbuf_remove_io(conn->c_sb, &openldap_sockbuf_io, LBER_SBIOD_LEVEL_PROVIDER);
 }
 
-/* NOTE: this routine is not reentrant */
+/* NOTE: this routine is not reentrant
+ * this function returns the connection table list the new connection is in
+ */
 static int
 handle_new_connection(Connection_Table *ct, int tcps, PRFileDesc *pr_acceptfd, int secure, int local, Connection **newconn)
 {
@@ -1881,7 +1950,7 @@ handle_new_connection(Connection_Table *ct, int tcps, PRFileDesc *pr_acceptfd, i
      * This must be done as the very last thing before we unlock the mutex, because once it
      * is added to the active list, it is live. */
     if (conn != NULL && conn->c_next == NULL && conn->c_prev == NULL) {
-        /* Now give the new connection to the connection code */
+        /* Now give the new connection to the connection code*/
         connection_table_move_connection_on_to_active_list(the_connection_table, conn);
     }
 
@@ -1892,7 +1961,7 @@ handle_new_connection(Connection_Table *ct, int tcps, PRFileDesc *pr_acceptfd, i
     if (newconn) {
         *newconn = conn;
     }
-    return 0;
+    return conn->c_ct_list;
 }
 
 static int
@@ -2361,29 +2430,36 @@ netaddr2string(const PRNetAddr *addr, char *addrbuf, size_t addrbuflen)
 
 
 static int
-createsignalpipe(void)
+createsignalpipe(int numsigpipes)
 {
-    if (PR_CreatePipe(&signalpipe[0], &signalpipe[1]) != 0) {
-        PRErrorCode prerr = PR_GetError();
-        slapi_log_err(SLAPI_LOG_ERR, "createsignalpipe",
-                      "PR_CreatePipe() failed, %s error %d (%s)\n",
-                      SLAPI_COMPONENT_NAME_NSPR, prerr, slapd_pr_strerror(prerr));
-        return (-1);
-    }
-    writesignalpipe = PR_FileDesc2NativeHandle(signalpipe[1]);
-    readsignalpipe = PR_FileDesc2NativeHandle(signalpipe[0]);
-    if (fcntl(writesignalpipe, F_SETFD, O_NONBLOCK) == -1) {
-        slapi_log_err(SLAPI_LOG_ERR, "createsignalpipe",
-                      "Failed to set FD for write pipe (%d).\n", errno);
-    }
-    if (fcntl(readsignalpipe, F_SETFD, O_NONBLOCK) == -1) {
-        slapi_log_err(SLAPI_LOG_ERR, "createsignalpipe",
-                      "Failed to set FD for read pipe (%d).\n", errno);
+    int i;
+    /* there is a signal pipe for each ct list/thread mapping */
+    for (i = 0; i < numsigpipes; i++) {
+        if (PR_CreatePipe(&signalpipes[i].signalpipe[0], &signalpipes[i].signalpipe[1]) != 0) {
+            PRErrorCode prerr = PR_GetError();
+            slapi_log_err(SLAPI_LOG_ERR, "createsignalpipe",
+                          "PR_CreatePipe() failed, %s error %d (%s)\n",
+                          SLAPI_COMPONENT_NAME_NSPR, prerr, slapd_pr_strerror(prerr));
+            return (-1);
+        }
+
+        signalpipes[i].readsignalpipe = PR_FileDesc2NativeHandle(signalpipes[i].signalpipe[0]);
+        signalpipes[i].writesignalpipe = PR_FileDesc2NativeHandle(signalpipes[i].signalpipe[1]);
+
+        if (fcntl(signalpipes[i].readsignalpipe, F_SETFD, O_NONBLOCK) == -1) {
+            slapi_log_err(SLAPI_LOG_ERR, "createsignalpipe",
+                          "Failed to set FD for read pipe (%d).\n", errno);
+        }
+
+        if (fcntl(signalpipes[i].writesignalpipe, F_SETFD, O_NONBLOCK) == -1) {
+            slapi_log_err(SLAPI_LOG_ERR, "createsignalpipe",
+                          "Failed to set FD for write pipe (%d).\n", errno);
+        }
+
+        return (0);
     }
-    return (0);
 }
 
-
 #ifdef HPUX10
 #include <pthread.h> /* for sigwait */
 /*
@@ -2448,8 +2524,8 @@ get_configured_connection_table_size(void)
     if (maxdesc >= 0 && size > maxdesc) {
         size = maxdesc;
     }
-
-    return size;
+    //jc, improve this, feels a bit hackey.
+    return size/NUM_CT_LISTS;
 }
 
 PRFileDesc *
diff --git a/ldap/servers/slapd/fe.h b/ldap/servers/slapd/fe.h
index 3b1207c21..af1fb58a1 100644
--- a/ldap/servers/slapd/fe.h
+++ b/ldap/servers/slapd/fe.h
@@ -80,20 +80,29 @@ int connection_call_io_layer_callbacks(Connection *c);
 struct connection_table
 {
     int size;
+    int numlists;
+    int listindex;
     /* An array of connections, file descriptors, and a mapping between them. */
-    Connection *c;
+    Connection **c;
     /* An array of free connections awaiting allocation. */;
     Connection **c_freelist;
     size_t conn_next_offset;
     size_t conn_free_offset;
-    struct POLL_STRUCT *fd;
+    struct POLL_STRUCT **fd;
     PRLock *table_mutex;
 };
 typedef struct connection_table Connection_Table;
 
+typedef struct signal_pipe
+{
+    PRFileDesc *signalpipe[2];
+    int readsignalpipe;
+    int writesignalpipe;
+} signal_pipe;
+
 extern Connection_Table *the_connection_table; /* JCM - Exported from globals.c for daemon.c, monitor.c, puke, gag, etc */
 
-Connection_Table *connection_table_new(int table_size);
+Connection_Table *connection_table_new(int table_size, int numlists);
 void connection_table_free(Connection_Table *ct);
 void connection_table_abandon_all_operations(Connection_Table *ct);
 void connection_table_disconnect_all(Connection_Table *ct);
@@ -102,15 +111,16 @@ int connection_table_move_connection_out_of_active_list(Connection_Table *ct, Co
 void connection_table_move_connection_on_to_active_list(Connection_Table *ct, Connection *c);
 void connection_table_as_entry(Connection_Table *ct, Slapi_Entry *e);
 void connection_table_dump_activity_to_errors_log(Connection_Table *ct);
-Connection *connection_table_get_first_active_connection(Connection_Table *ct);
+Connection *connection_table_get_first_active_connection(Connection_Table *ct, int listnum);
 Connection *connection_table_get_next_active_connection(Connection_Table *ct, Connection *c);
 typedef int (*Connection_Table_Iterate_Function)(Connection *c, void *arg);
 int connection_table_iterate_active_connections(Connection_Table *ct, void *arg, Connection_Table_Iterate_Function f);
+int connection_table_get_list(Connection_Table *ct);
 
 /*
  * daemon.c
  */
-int signal_listner(void);
+int signal_listner(int listnum);
 int daemon_pre_setuid_init(daemon_ports_t *ports);
 void slapd_sockets_ports_free(daemon_ports_t *ports_info);
 void slapd_daemon(daemon_ports_t *ports);
diff --git a/ldap/servers/slapd/slap.h b/ldap/servers/slapd/slap.h
index 96d549133..e14d910d8 100644
--- a/ldap/servers/slapd/slap.h
+++ b/ldap/servers/slapd/slap.h
@@ -1696,6 +1696,7 @@ typedef struct conn
     Conn_IO_Layer_cb c_pop_io_layer_cb;  /* callback to pop an IO layer off of the conn->c_prfd */
     void *c_io_layer_cb_data;        /* callback data */
     struct connection_table *c_ct;   /* connection table that this connection belongs to */
+    int c_ct_list;                   /* ct active list this conn is part of */
     int c_ns_close_jobs;             /* number of current close jobs */
     char *c_ipaddr;                  /* ip address str - used by monitor */
     /* per conn static config */
