Import my recent 1:1 threading working. some features improved includes:

 1. fast simple type mutex.
 2. __thread tls works.
 3. asynchronous cancellation works ( using signal ).
 4. thread synchronization is fully based on umtx, mainly, condition
    variable and other synchronization objects were rewritten by using
    umtx directly. those objects can be shared between processes via
    shared memory, it has to change ABI which does not happen yet.
 5. default stack size is increased to 1M on 32 bits platform, 2M for
    64 bits platform.
As the result, some mysql super-smack benchmarks show performance is
improved massivly.

Okayed by: jeff, mtm, rwatson, scottl

1 files changed, 83 insertions, 70 deletions

diff --git a/lib/libthr/thread/thr_setschedparam.c b/lib/libthr/thread/thr_setschedparam.c
index fff1abf..4f0a60d 100644
--- a/lib/libthr/thread/thr_setschedparam.c
+++ b/lib/libthr/thread/thr_setschedparam.c
@@ -31,93 +31,106 @@
  *
  * $FreeBSD$
  */
+
 #include <errno.h>
 #include <sys/param.h>
 #include <pthread.h>
-#include <stdlib.h>
+
 #include "thr_private.h"
 
-__weak_reference(_pthread_getschedparam, pthread_getschedparam);
 __weak_reference(_pthread_setschedparam, pthread_setschedparam);
 
 int
-_pthread_getschedparam(pthread_t pthread, int *policy, 
-    struct sched_param *param)
-{
-	if (param == NULL || policy == NULL)
-		return (EINVAL);
-	if (_find_thread(pthread) == ESRCH)
-		return (ESRCH);
-	param->sched_priority = pthread->base_priority;
-	*policy = pthread->attr.sched_policy;
-	return(0);
-}
-
-int
 _pthread_setschedparam(pthread_t pthread, int policy, 
 	const struct sched_param *param)
 {
-	struct pthread_mutex *mtx;
-	int old_prio;
+	struct pthread *curthread = _get_curthread();
+	int	in_syncq;
+	int	in_readyq = 0;
+	int	old_prio;
+	int	ret = 0;
 
-	mtx = NULL;
-	old_prio = 0;
-	if ((param == NULL) || (policy < SCHED_FIFO) || (policy > SCHED_RR))
-		return (EINVAL);
-	if ((param->sched_priority < PTHREAD_MIN_PRIORITY) ||
-	    (param->sched_priority > PTHREAD_MAX_PRIORITY))
-		return (ENOTSUP);
-	if (_find_thread(pthread) != 0)
-		return (ESRCH);
-
-	/*
-	 * If the pthread is waiting on a mutex grab it now. Doing it now
-	 * even though we do not need it immediately greatly simplifies the
-	 * LOR avoidance code.
-	 */
-	do {
-		PTHREAD_LOCK(pthread);
-		if ((pthread->flags & PTHREAD_FLAGS_IN_MUTEXQ) != 0) {
-			mtx = pthread->data.mutex;
-			if (_spintrylock(&mtx->lock) == EBUSY)
-				PTHREAD_UNLOCK(pthread);
-			else
-				break;
-		} else {
-			mtx = NULL;
-			break;
-		}
-	} while (1);
+	if ((param == NULL) || (policy < SCHED_FIFO) || (policy > SCHED_RR)) {
+		/* Return an invalid argument error: */
+		ret = EINVAL;
+	} else if ((param->sched_priority < THR_MIN_PRIORITY) ||
+	    (param->sched_priority > THR_MAX_PRIORITY)) {
+		/* Return an unsupported value error. */
+		ret = ENOTSUP;
 
-	PTHREAD_ASSERT(pthread->active_priority >= pthread->inherited_priority,
-	    "active priority cannot be less than inherited priority");
-	old_prio = pthread->base_priority;
-	pthread->base_priority = param->sched_priority;
-	if (param->sched_priority <= pthread->active_priority) {
+	/* Find the thread in the list of active threads: */
+	} else if ((ret = _thr_ref_add(curthread, pthread, /*include dead*/0))
+	    == 0) {
 		/*
-		 * Active priority is affected only if it was the
-		 * base priority and the new base priority is lower.
+		 * Lock the threads scheduling queue while we change
+		 * its priority:
 		 */
-		if (pthread->active_priority == old_prio &&
-		    pthread->active_priority != pthread->inherited_priority) {
-			pthread->active_priority = param->sched_priority;
-			readjust_priorities(pthread, mtx);
+		THR_THREAD_LOCK(curthread, pthread);
+		if (pthread->state == PS_DEAD) {
+			THR_THREAD_UNLOCK(curthread, pthread);
+			_thr_ref_delete(curthread, pthread);
+			return (ESRCH);
 		}
+		in_syncq = pthread->sflags & THR_FLAGS_IN_SYNCQ;
 
-	} else {
-		/*
-		 * New base priority is greater than active priority. This
-		 * only affects threads that are holding priority inheritance
-		 * mutexes this thread is waiting on and its position in the
-		 * queue.
-		 */
-		pthread->active_priority = param->sched_priority;
-		readjust_priorities(pthread, mtx);
+		/* Set the scheduling policy: */
+		pthread->attr.sched_policy = policy;
+
+		if (param->sched_priority ==
+		    THR_BASE_PRIORITY(pthread->base_priority))
+			/*
+			 * There is nothing to do; unlock the threads
+			 * scheduling queue.
+			 */
+			THR_THREAD_UNLOCK(curthread, pthread);
+		else {
+			/*
+			 * Remove the thread from its current priority
+			 * queue before any adjustments are made to its
+			 * active priority:
+			 */
+			old_prio = pthread->active_priority;
+			/* if ((pthread->flags & THR_FLAGS_IN_RUNQ) != 0) */ {
+				in_readyq = 1;
+				/* THR_RUNQ_REMOVE(pthread); */
+			}
+
+			/* Set the thread base priority: */
+			pthread->base_priority &=
+			    (THR_SIGNAL_PRIORITY | THR_RT_PRIORITY);
+			pthread->base_priority = param->sched_priority;
 
+			/* Recalculate the active priority: */
+			pthread->active_priority = MAX(pthread->base_priority,
+			    pthread->inherited_priority);
+
+			if (in_readyq) {
+				if ((pthread->priority_mutex_count > 0) &&
+				    (old_prio > pthread->active_priority)) {
+					/*
+					 * POSIX states that if the priority is
+					 * being lowered, the thread must be
+					 * inserted at the head of the queue for
+					 * its priority if it owns any priority
+					 * protection or inheritence mutexes.
+					 */
+					/* THR_RUNQ_INSERT_HEAD(pthread); */
+				}
+				else
+					/* THR_RUNQ_INSERT_TAIL(pthread)*/ ;
+			}
+
+			/* Unlock the threads scheduling queue: */
+			THR_THREAD_UNLOCK(curthread, pthread);
+
+			/*
+			 * Check for any mutex priority adjustments.  This
+			 * includes checking for a priority mutex on which
+			 * this thread is waiting.
+			 */
+			_mutex_notify_priochange(curthread, pthread, in_syncq);
+		}
+		_thr_ref_delete(curthread, pthread);
 	}
-	pthread->attr.sched_policy = policy;
-	PTHREAD_UNLOCK(pthread);
-	if (mtx != NULL)
-		_SPINUNLOCK(&mtx->lock);
-	return(0);
+	return (ret);
 }