Changed the way we create aditional threads. One for every connection is

[citadel.git] / citadel / server_main.c

diff --git a/citadel/server_main.c b/citadel/server_main.c
index 8634d6c0d0b2b7359bb75f4cb5f7336e6e7e35e1..3715bb356fba85b797906885d5c864317f92bb60 100644 (file)
--- a/citadel/server_main.c
+++ b/citadel/server_main.c
@@ -71,13 +71,17 @@
 const char *CitadelServiceUDS="citadel-UDS";
 const char *CitadelServiceTCP="citadel-TCP";
 
+
+void go_threading(void);
+
+
 /*
  * Here's where it all begins.
  */
 int main(int argc, char **argv)
 {
        char facility[32];
-       int a, i;                       /* General-purpose variables */
+       int a;                  /* General-purpose variables */
        struct passwd pw, *pwp = NULL;
        char pwbuf[SIZ];
        int drop_root_perms = 1;
@@ -321,20 +325,39 @@ int main(int argc, char **argv)
        /* We want to check for idle sessions once per minute */
        CtdlRegisterSessionHook(terminate_idle_sessions, EVT_TIMER);
 
+       go_threading();
+       
+       
+       master_cleanup(exit_signal);
+       return(0);
+}
+
+
+
+void go_threading(void)
+{
+       int i;
+       struct CtdlThreadNode *last_worker;
+       
+       /* We can't use CT_PUSH() here so we do it the long way 
+        * So we can still use CT for current thread */
+       struct CtdlThreadNode *_this_cit_thread;
+       
        /*
         * Initialise the thread system
         */
        ctdl_thread_internal_init();
-       
+       _this_cit_thread = CtdlThreadSelf();
        /*
         * Now create a bunch of worker threads.
         */
-       CtdlLogPrintf(CTDL_DEBUG, "Starting %d worker threads\n",
-               config.c_min_workers-1);
+       CtdlLogPrintf(CTDL_DEBUG, "Starting %d worker threads\n", config.c_min_workers);
        begin_critical_section(S_THREAD_LIST);
-       for (i=0; i<(config.c_min_workers-1); ++i) {
+       i=0;    /* Always start at least 1 worker thread */
+       do
+       {
                ctdl_internal_create_thread("Worker Thread", CTDLTHREAD_BIGSTACK + CTDLTHREAD_WORKER, worker_thread, NULL);
-       }
+       } while (++i < config.c_min_workers);
        end_critical_section(S_THREAD_LIST);
 
        /* Second call to module init functions now that threading is up */
@@ -345,32 +368,93 @@ int main(int argc, char **argv)
         */
        CtdlLogPrintf(CTDL_INFO, "Startup thread %d becoming garbage collector,\n", pthread_self());
 
-       /* Sleep 10 seconds before first garbage collection */  
-       CtdlThreadSleep(10);
+       /*
+        * We do a lot of locking and unlocking of the thread list in here.
+        * We do this so that we can repeatedly release time for other threads
+        * that may be waiting on the thread list.
+        * We are a low priority thread so we can afford to do this
+        */
        
        while (CtdlThreadGetCount())
        {
                if (exit_signal)
                        CtdlThreadStopAll();
+               check_sched_shutdown();
                begin_critical_section(S_THREAD_LIST);
                ctdl_thread_internal_calc_loadavg();
                end_critical_section(S_THREAD_LIST);
-               CtdlThreadSleep(1);
+       
+               /* Reduce the size of the worker thread pool if necessary. */
+               if ((CtdlThreadGetWorkers() > config.c_min_workers) && (CtdlThreadWorkerAvg < 20))
+               {
+                       /* Ask a worker thread to stop as we no longer need it */
+                       begin_critical_section(S_THREAD_LIST);
+                       last_worker = CtdlThreadList;
+                       while (last_worker)
+                       {
+                               if (last_worker->flags & CTDLTHREAD_WORKER && last_worker->state > CTDL_THREAD_STOPPING)
+                                       break;
+                               else
+                                       last_worker = last_worker->next;
+                       }
+                       end_critical_section(S_THREAD_LIST);
+                       if (last_worker)
+                       {
+#ifdef WITH_THREADLOG
+                               CtdlLogPrintf(CTDL_DEBUG, "Thread system, stopping excess worker thread \"%s\" (%ld).\n",
+                                       last_worker->name,
+                                       last_worker->tid
+                                       );
+#endif
+                               CtdlThreadStop(last_worker);
+                       }
+               }
+       
+               /*
+                * If all our workers are working hard, start some more to help out
+                * with things
+                */
+               begin_critical_section(S_THREAD_LIST);
+               /* FIXME: come up with a better way to dynamically alter the number of threads
+                * based on the system load
+                */
+//             if ((CtdlThreadGetWorkers() < config.c_max_workers) && (CtdlThreadGetWorkers() < num_sessions))
+               // && (CtdlThreadLoadAvg < 90) )
+               if ((CtdlThreadGetWorkers() < config.c_max_workers) && (CtdlThreadWorkerAvg > 60) && (CtdlThreadLoadAvg < 90) )
+               {
+                       end_critical_section(S_THREAD_LIST);
+                       for (i=0; i<5 ; i++)
+//                     for (i=0; i< (num_sessions - CtdlThreadGetWorkers()) ; i++)
+//                     for (i=0; i< (10 - (55 - CtdlThreadWorkerAvg) / CtdlThreadWorkerAvg / CtdlThreadGetWorkers()) ; i++)
+                       {
+                               begin_critical_section(S_THREAD_LIST);
+                               ctdl_internal_create_thread("Worker Thread",
+                                       CTDLTHREAD_BIGSTACK + CTDLTHREAD_WORKER,
+                                       worker_thread,
+                                       NULL
+                                       );
+                               end_critical_section(S_THREAD_LIST);
+                       }
+               }
+               else
+                       end_critical_section(S_THREAD_LIST);
+               
                begin_critical_section(S_THREAD_LIST);
                ctdl_internal_thread_gc();
                end_critical_section(S_THREAD_LIST);
+               
                if (CtdlThreadGetCount() <= 1) // Shutting down clean up the garbage collector
                {
                        begin_critical_section(S_THREAD_LIST);
                        ctdl_internal_thread_gc();
                        end_critical_section(S_THREAD_LIST);
                }
+               
+               if (CtdlThreadGetCount())
+                       CtdlThreadSleep(1);
        }
        /*
         * If the above loop exits we must be shutting down since we obviously have no threads
         */
        ctdl_thread_internal_cleanup();
-       
-       master_cleanup(exit_signal);
-       return(0);
 }