New thread infrastructure -- not used anywhere yet, but tested.

4 files changed, 219 insertions, 0 deletions

diff --git a/src/core/nng_impl.h b/src/core/nng_impl.h
index 46341863..4c00a522 100644
--- a/src/core/nng_impl.h
+++ b/src/core/nng_impl.h
@@ -31,6 +31,7 @@
 #include "core/panic.h"
 #include "core/platform.h"
 #include "core/protocol.h"
+#include "core/thread.h"
 #include "core/transport.h"
 
 // These have to come after the others - particularly transport.h
diff --git a/src/core/platform.h b/src/core/platform.h
index 21793086..bdec8bb6 100644
--- a/src/core/platform.h
+++ b/src/core/platform.h
@@ -63,41 +63,53 @@ extern void nni_free(void *, size_t);
 typedef struct nni_mutex	nni_mutex;
 typedef struct nni_cond		nni_cond;
 
+typedef struct nni_plat_mtx nni_plat_mtx;
+typedef struct nni_plat_cv nni_plat_cv;
+typedef struct nni_plat_thr nni_plat_thr;
+
 // Mutex handling.
 
 // nni_mutex_init initializes a mutex structure.  This may require dynamic
 // allocation, depending on the platform.  It can return NNG_ENOMEM if that
 // fails.
+extern int nni_plat_mtx_init(nni_plat_mtx *);
 extern int nni_mutex_init(nni_mutex *);
 
 // nni_mutex_fini destroys the mutex and releases any resources allocated for
 // it's use.
 extern void nni_mutex_fini(nni_mutex *);
+extern void nni_plat_mtx_fini(nni_plat_mtx *);
 
 // nni_mutex_enter locks the mutex.  This is not recursive -- a mutex can only
 // be entered once.
 extern void nni_mutex_enter(nni_mutex *);
+extern void nni_plat_mtx_lock(nni_plat_mtx *);
 
 // nni_mutex_exit unlocks the mutex.  This can only be performed by the thread
 // that owned the mutex.
 extern void nni_mutex_exit(nni_mutex *);
+extern void nni_plat_mtx_unlock(nni_plat_mtx *);
 
 // nni_mutex_tryenter tries to lock the mutex.  If it can't, it may return
 // NNG_EBUSY.
 extern int nni_mutex_tryenter(nni_mutex *);
+extern int nni_plat_mtx_trylock(nni_plat_mtx *);
 
 // nni_cond_init initializes a condition variable.  We require a mutex be
 // supplied with it, and that mutex must always be held when performing any
 // operations on the condition variable (other than fini.)  This may require
 // dynamic allocation, and if so this operation may fail with NNG_ENOMEM.
 extern int nni_cond_init(nni_cond *, nni_mutex *);
+extern int nni_plat_cv_init(nni_plat_cv *, nni_plat_mtx *);
 
 // nni_cond_fini releases all resources associated with condition variable.
 extern void nni_cond_fini(nni_cond *);
+extern void nni_plat_cv_fini(nni_plat_cv *);
 
 // nni_cond_broadcast wakes all waiters on the condition.  This should be
 // called with the lock held.
 extern void nni_cond_broadcast(nni_cond *);
+extern void nni_plat_cv_wake(nni_plat_cv *);
 
 // nni_cond_signal wakes a signal waiter.
 extern void nni_cond_signal(nni_cond *);
@@ -106,23 +118,27 @@ extern void nni_cond_signal(nni_cond *);
 // associated lock is atomically released and reacquired upon wake up.
 // Callers can be spuriously woken.  The associated lock must be held.
 extern void nni_cond_wait(nni_cond *);
+extern void nni_plat_cv_wait(nni_plat_cv *);
 
 // nni_cond_waituntil waits for a wakeup on the condition variable, or
 // until the system time reaches the specified absolute time.  (It is an
 // absolute form of nni_cond_timedwait.)  Early wakeups are possible, so
 // check the condition.  It will return either NNG_ETIMEDOUT, or 0.
 extern int nni_cond_waituntil(nni_cond *, nni_time);
+extern int nni_plat_cv_until(nni_plat_cv *, nni_time);
 
 typedef struct nni_thread   nni_thread;
 
 // nni_thread_creates a thread that runs the given function. The thread
 // receives a single argument.
 extern int nni_thread_create(nni_thread **, void (*fn)(void *), void *);
+extern int nni_plat_thr_init(nni_plat_thr *, void (*)(void *), void *);
 
 // nni_thread_reap waits for the thread to exit, and then releases any
 // resources associated with the thread.  After this returns, it
 // is an error to reference the thread in any further way.
 extern void nni_thread_reap(nni_thread *);
+extern void nni_plat_thr_fini(nni_plat_thr *);
 
 // nn_clock returns a number of microseconds since some arbitrary time
 // in the past.  The values returned by nni_clock must use the same base
diff --git a/src/core/thread.c b/src/core/thread.c
new file mode 100644
index 00000000..4f714341
--- /dev/null
+++ b/src/core/thread.c
@@ -0,0 +1,150 @@
+//
+// Copyright 2016 Garrett D'Amore <garrett@damore.org>
+//
+// This software is supplied under the terms of the MIT License, a
+// copy of which should be located in the distribution where this
+// file was obtained (LICENSE.txt).  A copy of the license may also be
+// found online at https://opensource.org/licenses/MIT.
+//
+
+#include "core/nng_impl.h"
+
+int
+nni_mtx_init(nni_mtx *mtx)
+{
+	return (nni_plat_mtx_init(&mtx->mtx));
+}
+
+void
+nni_mtx_fini(nni_mtx *mtx)
+{
+	nni_plat_mtx_fini(&mtx->mtx);
+}
+
+void
+nni_mtx_lock(nni_mtx *mtx)
+{
+	nni_plat_mtx_lock(&mtx->mtx);
+}
+
+void
+nni_mtx_unlock(nni_mtx *mtx)
+{
+	nni_plat_mtx_unlock(&mtx->mtx);
+}
+
+int
+nni_mtx_trylock(nni_mtx *mtx)
+{
+	return (nni_plat_mtx_trylock(&mtx->mtx));
+}
+
+int
+nni_cv_init(nni_cv *cv, nni_mtx *mtx)
+{
+	return (nni_plat_cv_init(&cv->cv, &mtx->mtx));
+}
+
+void
+nni_cv_fini(nni_cv *cv)
+{
+	nni_plat_cv_fini(&cv->cv);
+}
+
+void
+nni_cv_wait(nni_cv *cv)
+{
+	nni_plat_cv_wait(&cv->cv);
+}
+
+int
+nni_cv_until(nni_cv *cv, nni_time until)
+{
+	// Some special cases for times.  Catching these here means that
+	// platforms can assume a valid time is presented to them.
+	if (until == NNI_TIME_NEVER) {
+		nni_plat_cv_wait(&cv->cv);
+		return (0);
+	}
+	if (until == NNI_TIME_ZERO) {
+		return (NNG_EAGAIN);
+	}
+
+	return (nni_plat_cv_until(&cv->cv, until));
+}
+
+void
+nni_cv_wake(nni_cv *cv)
+{
+	return (nni_plat_cv_wake(&cv->cv));
+}
+
+static void
+nni_thr_wrap(void *arg)
+{
+	nni_thr *thr = arg;
+	int stop;
+
+	nni_plat_mtx_lock(&thr->mtx);
+	while (((stop = thr->stop) == 0) && (thr->start == 0)) {
+		nni_plat_cv_wait(&thr->cv);
+	}
+	nni_plat_mtx_unlock(&thr->mtx);
+	if (!stop) {
+		thr->fn(thr->arg);
+	}
+	nni_plat_mtx_lock(&thr->mtx);
+	thr->done = 1;
+	nni_plat_cv_wake(&thr->cv);
+	nni_plat_mtx_unlock(&thr->mtx);
+}
+
+int
+nni_thr_init(nni_thr *thr, nni_thr_func fn, void *arg)
+{
+	int rv;
+
+	thr->done = 0;
+	thr->start = 0;
+	thr->stop = 0;
+	thr->fn = fn;
+	thr->arg = arg;
+
+	if ((rv = nni_plat_mtx_init(&thr->mtx)) != 0) {
+		return (rv);
+	}
+	if ((rv = nni_plat_cv_init(&thr->cv, &thr->mtx)) != 0) {
+		nni_plat_mtx_fini(&thr->mtx);
+		return (rv);
+	}
+	if ((rv = nni_plat_thr_init(&thr->thr, nni_thr_wrap, thr)) != 0) {
+		nni_plat_cv_fini(&thr->cv);
+		nni_plat_mtx_fini(&thr->mtx);
+		return (rv);
+	}
+	return (0);
+}
+
+void
+nni_thr_run(nni_thr *thr)
+{
+	nni_plat_mtx_lock(&thr->mtx);
+	thr->start = 1;
+	nni_plat_cv_wake(&thr->cv);
+	nni_plat_mtx_unlock(&thr->mtx);
+}
+
+void
+nni_thr_fini(nni_thr *thr)
+{
+	nni_plat_mtx_lock(&thr->mtx);
+	thr->stop = 1;
+	nni_plat_cv_wake(&thr->cv);
+	while (!thr->done) {
+		nni_plat_cv_wait(&thr->cv);
+	}
+	nni_plat_mtx_unlock(&thr->mtx);
+	nni_plat_thr_fini(&thr->thr);
+	nni_plat_cv_fini(&thr->cv);
+	nni_plat_mtx_fini(&thr->mtx);
+}
\ No newline at end of file
diff --git a/src/core/thread.h b/src/core/thread.h
new file mode 100644
index 00000000..062941a1
--- /dev/null
+++ b/src/core/thread.h
@@ -0,0 +1,52 @@
+//
+// Copyright 2016 Garrett D'Amore <garrett@damore.org>
+//
+// This software is supplied under the terms of the MIT License, a
+// copy of which should be located in the distribution where this
+// file was obtained (LICENSE.txt).  A copy of the license may also be
+// found online at https://opensource.org/licenses/MIT.
+//
+
+#ifndef CORE_THREAD_H
+#define CORE_THREAD_H
+
+#include "core/nng_impl.h"
+
+typedef struct {
+	nni_plat_mtx mtx;
+} nni_mtx;
+
+typedef struct {
+	nni_plat_cv cv;
+} nni_cv;
+
+typedef void (*nni_thr_func)(void *);
+
+typedef struct {
+	nni_plat_thr	thr;
+	nni_plat_mtx	mtx;
+	nni_plat_cv	cv;
+	nni_thr_func	fn;
+	void		*arg;
+	int		start;
+	int		stop;
+	int		done;
+} nni_thr;
+
+extern int nni_mtx_init(nni_mtx *mtx);
+extern void nni_mtx_fini(nni_mtx *mtx);
+extern void nni_mtx_lock(nni_mtx *mtx);
+extern void nni_mtx_unlock(nni_mtx *mtx);
+extern int nni_mtx_trylock(nni_mtx *mtx);
+
+extern int nni_cv_init(nni_cv *cv, nni_mtx *);
+extern void nni_cv_fini(nni_cv *cv);
+extern void nni_cv_wake(nni_cv *cv);
+extern void nni_cv_wait(nni_cv *cv);
+extern int nni_cv_until(nni_cv *cv, nni_time when);
+
+extern int nni_thr_init(nni_thr *thr, nni_thr_func fn, void *arg);
+extern void nni_thr_fini(nni_thr *thr);
+extern void nni_thr_run(nni_thr *thr);
+
+#endif CORE_THREAD_H
\ No newline at end of file