X-Git-Url: https://code.citadel.org/?a=blobdiff_plain;f=citadel%2Fthreads.c;h=1f066a0cd6e79e88f390db5bad0cec7f5d97e500;hb=cb8cd32734a354007d10d75959ba990ac8baaa19;hp=e87ac935dd02b151c338de2c31e38b4311ebe720;hpb=7716f155f4145d83b6acfe6157599e6a9ee04608;p=citadel.git

diff --git a/citadel/threads.c b/citadel/threads.c
index e87ac935d..1f066a0cd 100644
--- a/citadel/threads.c
+++ b/citadel/threads.c
@@ -61,13 +61,8 @@
 #include "context.h"
 #include "event_client.h"
 
-/*
- * define this to use the new worker_thread method of handling connections
- */
-//#define NEW_WORKER
 
 /*
- * New thread interface.
  * To create a thread you must call one of the create thread functions.
  * You must pass it the address of (a pointer to a CtdlThreadNode initialised to NULL) like this
  * struct CtdlThreadNode *node = NULL;
@@ -119,9 +114,6 @@ int try_critical_section(int which_one)
 	 * transaction; this could lead to deadlock.
 	 */
 	if (	(which_one != S_FLOORCACHE)
-#ifdef DEBUG_MEMORY_LEAKS
-		&& (which_one != S_DEBUGMEMLEAKS)
-#endif
 		&& (which_one != S_RPLIST)
 	) {
 		cdb_check_handles();
@@ -142,9 +134,6 @@ void begin_critical_section(int which_one)
 	 * transaction; this could lead to deadlock.
 	 */
 	if (	(which_one != S_FLOORCACHE)
-#ifdef DEBUG_MEMORY_LEAKS
-		&& (which_one != S_DEBUGMEMLEAKS)
-#endif
 		&& (which_one != S_RPLIST)
 	) {
 		cdb_check_handles();
@@ -300,30 +289,6 @@ void ctdl_thread_internal_init(void)
 }
 
 
-/*
- * A function to update a threads load averages
- */
- void ctdl_thread_internal_update_avgs(CtdlThreadNode *this_thread)
- {
-	struct timeval now, result;
-	double last_duration;
-
-	gettimeofday(&now, NULL);
-	timersub(&now, &(this_thread->last_state_change), &result);
-	/* I don't think these mutex's are needed here */
-	citthread_mutex_lock(&this_thread->ThreadMutex);
-	// result now has a timeval for the time we spent in the last state since we last updated
-	last_duration = (double)result.tv_sec + ((double)result.tv_usec / (double) 1000000);
-	if (this_thread->state == CTDL_THREAD_SLEEPING)
-		this_thread->avg_sleeping += last_duration;
-	if (this_thread->state == CTDL_THREAD_RUNNING)
-		this_thread->avg_running += last_duration;
-	if (this_thread->state == CTDL_THREAD_BLOCKED)
-		this_thread->avg_blocked += last_duration;
-	memcpy (&this_thread->last_state_change, &now, sizeof (struct timeval));
-	citthread_mutex_unlock(&this_thread->ThreadMutex);
-}
-
 /*
  * A function to chenge the state of a thread
  */
@@ -332,7 +297,6 @@ void ctdl_thread_internal_change_state (CtdlThreadNode *this_thread, enum CtdlTh
 	/*
 	 * Wether we change state or not we need update the load values
 	 */
-	ctdl_thread_internal_update_avgs(this_thread);
 	/* This mutex not needed here? */
 	citthread_mutex_lock(&this_thread->ThreadMutex); /* To prevent race condition of a sleeping thread */
 	if ((new_state == CTDL_THREAD_STOP_REQ) && (this_thread->state > CTDL_THREAD_STOP_REQ))
@@ -638,54 +602,6 @@ static void ctdl_internal_thread_cleanup(void *arg)
 	citthread_mutex_unlock(&CT->ThreadMutex);
 }
 
-/*
- * A quick function to show the load averages
- */
-void ctdl_thread_internal_calc_loadavg(void)
-{
-	CtdlThreadNode *that_thread;
-	double load_avg, worker_avg;
-	int workers = 0;
-
-	that_thread = CtdlThreadList;
-	load_avg = 0;
-	worker_avg = 0;
-	while(that_thread)
-	{
-		/* Update load averages */
-		ctdl_thread_internal_update_avgs(that_thread);
-		citthread_mutex_lock(&that_thread->ThreadMutex);
-		that_thread->load_avg = (that_thread->avg_sleeping + that_thread->avg_running) / (that_thread->avg_sleeping + that_thread->avg_running + that_thread->avg_blocked) * 100;
-		that_thread->avg_sleeping /= 2;
-		that_thread->avg_running /= 2;
-		that_thread->avg_blocked /= 2;
-		load_avg += that_thread->load_avg;
-		if (that_thread->flags & CTDLTHREAD_WORKER)
-		{
-			worker_avg += that_thread->load_avg;
-			workers++;
-		}
-#ifdef WITH_THREADLOG
-		syslog(LOG_DEBUG, "CtdlThread, \"%s\" (%lu) \"%s\" %.2f %.2f %.2f %.2f\n",
-			that_thread->name,
-			that_thread->tid,
-			CtdlThreadStates[that_thread->state],
-			that_thread->avg_sleeping,
-			that_thread->avg_running,
-			that_thread->avg_blocked,
-			that_thread->load_avg);
-#endif
-		citthread_mutex_unlock(&that_thread->ThreadMutex);
-		that_thread = that_thread->next;
-	}
-	CtdlThreadLoadAvg = load_avg/num_threads;
-	CtdlThreadWorkerAvg = worker_avg/workers;
-#ifdef WITH_THREADLOG
-	syslog(LOG_INFO, "System load average %.2f, workers averag %.2f, threads %d, workers %d, sessions %d\n", CtdlThreadGetLoadAvg(), CtdlThreadWorkerAvg, num_threads, num_workers, num_sessions);
-#endif
-}
-
-
 /*
  * Garbage collection routine.
  * Gets called by main() in a loop to clean up the thread list periodically.
@@ -1032,7 +948,6 @@ CtdlThreadNode *ctdl_internal_create_thread(char *name, long flags, void *(*thre
 	CtdlThreadList = this_thread;
 	if (this_thread->next)
 		this_thread->next->prev = this_thread;
-	ctdl_thread_internal_calc_loadavg();
 	
 	end_critical_section(S_THREAD_LIST);
 	
@@ -1088,7 +1003,6 @@ CtdlThreadNode *ctdl_thread_internal_start_scheduled (CtdlThreadNode *this_threa
 	if (this_thread->next)
 		this_thread->next->prev = this_thread;
 	
-	ctdl_thread_internal_calc_loadavg();
 	end_critical_section(S_THREAD_LIST);
 	
 	
@@ -1213,8 +1127,6 @@ void go_threading(void)
 {
 	int i;
 	CtdlThreadNode *last_worker;
-	struct timeval start, now, result;
-	double last_duration;
 
 	/*
 	 * Initialise the thread system
@@ -1249,7 +1161,6 @@ void go_threading(void)
 		if (CT->state > CTDL_THREAD_STOP_REQ)
 		{
 			begin_critical_section(S_THREAD_LIST);
-			ctdl_thread_internal_calc_loadavg();
 			end_critical_section(S_THREAD_LIST);
 			
 			ctdl_thread_internal_check_scheduled(); /* start scheduled threads */